from retab import Retab

client = Retab()

# Manual inputs: hand-write the handle inputs the block should run with.
workflow_eval = client.workflows.evals.create(
    workflow_id="wf_abc123xyz",
    target={"type": "block", "block_id": "block_extract_invoice"},
    source={
        "type": "manual",
        "handle_inputs": {
            "input-document-0": {
                "type": "file",
                "document": {
                    "id": "file_invoice_q1",
                    "filename": "invoice.pdf",
                    "mime_type": "application/pdf",
                },
            },
        },
    },
    assertion={
        "target": {"output_handle_id": "output-json-0", "path": "total"},
        "condition": {"kind": "equals", "expected": 1234.56},
    },
    name="Q1 invoice total",
)

# Run-step inputs: replay the inputs the block ACTUALLY received in a run.
workflow_eval = client.workflows.evals.create(
    workflow_id="wf_abc123xyz",
    target={"type": "block", "block_id": "block_extract_invoice"},
    source={
        "type": "run_step",
        "run_id": "wfrun_def456",
        "step_id": "block_extract_invoice",
    },
    assertion={
        "target": {"output_handle_id": "output-json-0", "path": "vendor.name"},
        "condition": {"kind": "contains", "expected": "Acme"},
    },
)

print(f"Eval created: {workflow_eval.id}")

import { Retab } from "@retab/node";

const client = new Retab({ apiKey: process.env.RETAB_API_KEY });

const workflowEval = await client.workflows.evals.create("wf_abc123xyz", { type: "block", blockId: "block_extract_invoice" }, {
    type: "manual",
    handleInputs: {
      "input-document-0": {
        type: "file",
        document: {
          id: "file_invoice_q1",
          filename: "invoice.pdf",
          mimeType: "application/pdf",
        },
      },
    },
  }, {
    target: { outputHandleId: "output-json-0", path: "total" },
    condition: { kind: "equals", expected: 1234.56 },
  }, "Q1 invoice total");

console.log(`Eval created: ${workflowEval.id}`);

package main

import (
	"context"
	"fmt"
	"log"

	retab "github.com/retab-dev/retab/clients/go"
)

func ptr[T any](v T) *T { return &v }

func main() {
	ctx := context.Background()

	client, err := retab.NewClient("")
	if err != nil {
		log.Fatal(err)
	}

	// Manual inputs: hand-write the handle inputs the block should run with.
	workflowEval, err := client.Workflows.Evals.Create(ctx, &retab.WorkflowEvalsCreateParams{
		WorkflowID: "wf_abc123xyz",
		Target: retab.WorkflowEvalBlockTarget{
			Type:    ptr("block"),
			BlockID: "block_extract_invoice",
		},
		Source: retab.WorkflowEvalSourceFromManualWorkflowEvalSource(retab.ManualWorkflowEvalSource{
			Type: ptr("manual"),
		}),
		Assertion: retab.AssertionSpec{
			Target:    retab.OutputTarget{OutputHandleID: "output-json-0", Path: ptr("total")},
			Condition: retab.ConditionFromExistCondition(retab.ExistCondition{Kind: ptr("exists")}),
		},
		Name: ptr("Q1 invoice total"),
	})
	if err != nil {
		log.Fatal(err)
	}

	// Run-step inputs: replay the inputs the block actually received in a run.
	runStepEval, err := client.Workflows.Evals.Create(ctx, &retab.WorkflowEvalsCreateParams{
		WorkflowID: "wf_abc123xyz",
		Target: retab.WorkflowEvalBlockTarget{
			Type:    ptr("block"),
			BlockID: "block_extract_invoice",
		},
		Source: retab.WorkflowEvalSourceFromManualWorkflowEvalSource(retab.ManualWorkflowEvalSource{
			Type: ptr("manual"),
		}),
		Assertion: retab.AssertionSpec{
			Target:    retab.OutputTarget{OutputHandleID: "output-json-0", Path: ptr("vendor.name")},
			Condition: retab.ConditionFromExistCondition(retab.ExistCondition{Kind: ptr("exists")}),
		},
	})
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("Eval created: %s\n", workflowEval.ID)
	_ = runStepEval
}

require 'retab'

client = Retab::Client.new(api_key: ENV['RETAB_API_KEY'])

# Manual inputs: hand-write the handle inputs the block should run with.
workflow_eval = client.workflows.evals.create(
  workflow_id: 'wf_abc123xyz',
  target: { type: 'block', block_id: 'block_extract_invoice' },
  source: {
    type: 'manual',
    handle_inputs: {
      'input-document-0' => {
        type: 'file',
        document: {
          id: 'file_invoice_q1',
          filename: 'invoice.pdf',
          mime_type: 'application/pdf',
        },
      },
    },
  },
  assertion: {
    target: { output_handle_id: 'output-json-0', path: 'total' },
    condition: { kind: 'equals', expected: 1234.56 },
  },
  name: 'Q1 invoice total',
)

# Run-step inputs: replay the inputs the block ACTUALLY received in a run.
workflow_eval = client.workflows.evals.create(
  workflow_id: 'wf_abc123xyz',
  target: { type: 'block', block_id: 'block_extract_invoice' },
  source: {
    type: 'run_step',
    run_id: 'wfrun_def456',
    step_id: 'block_extract_invoice',
  },
  assertion: {
    target: { output_handle_id: 'output-json-0', path: 'vendor.name' },
    condition: { kind: 'contains', expected: 'Acme' },
  },
)

puts "Eval created: #{workflow_eval.id}"

use retab::models::{
    AssertionSpec, ContainCondition, CreateWorkflowEvalRequest, OutputTarget,
    RunStepWorkflowEvalSource, WorkflowEvalBlockTarget,
};
use retab::resources::workflow_evals::CreateParams;
use retab::Retab;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Retab::new(std::env::var("RETAB_API_KEY")?);

    let mut source = RunStepWorkflowEvalSource::new("wfrun_def456");
    source.step_id = Some("block_extract_invoice".into());

    let mut target = OutputTarget::new("output-json-0");
    target.path = Some("vendor.name".into());

    let condition = ContainCondition {
        kind: None,
        expected: serde_json::json!("Acme"),
    };

    let body = CreateWorkflowEvalRequest::new(
        "wf_abc123xyz",
        WorkflowEvalBlockTarget::new("block_extract_invoice"),
        source.into(),
        AssertionSpec::new(target, condition.into()),
    );

    let workflow_eval = client
        .workflows()
        .evals()
        .create(CreateParams::new(body))
        .await?;
    println!("Eval created: {}", workflow_eval.id);
    Ok(())
}

<?php
require 'vendor/autoload.php';

use Retab\Client;
use Retab\Resource\AssertionSpec;
use Retab\Resource\ExistCondition;
use Retab\Resource\JsonHandleInput;
use Retab\Resource\ManualWorkflowEvalSource;
use Retab\Resource\OutputTarget;
use Retab\Resource\WorkflowEvalBlockTarget;

$client = new Client(apiKey: getenv('RETAB_API_KEY'));

$result = $client->workflows()->evals()->create(
    workflowId: 'wf_abc123',
    target: new WorkflowEvalBlockTarget(blockId: 'block_extract_invoice'),
    source: new ManualWorkflowEvalSource(handleInputs: [
        'input-json-0' => new JsonHandleInput(data: ['invoice_number' => 'INV-001']),
    ]),
    assertion: new AssertionSpec(
        target: new OutputTarget(outputHandleId: 'output-json-0', path: 'invoice_number'),
        condition: new ExistCondition(),
    ),
    name: 'Invoice number exists',
);
print_r($result);

using Retab;
using RetabClient = Retab.Retab;

var apiKey = Environment.GetEnvironmentVariable("RETAB_API_KEY")!;
var client = new RetabClient(apiKey);

var result = await client.Workflows.Evals.CreateAsync(new WorkflowEvalsCreateOptions());
Console.WriteLine(result);

import com.retab.RetabClient;
import com.retab.workflowevals.WorkflowEvalsApi;

public final class Example {
  public static void main(String[] args) throws Exception {
    RetabClient client = new RetabClient(System.getenv("RETAB_API_KEY"));

    var result = new WorkflowEvalsApi(client).create("wf_abc123", null, null, "Invoice Processing", null);
    System.out.println(result);
  }
}

curl -X 'POST' \
  'https://api.retab.com/v1/workflows/evals' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer <your-api-key>' \
  -d '{
    "workflow_id": "wf_abc123xyz",
    "target": { "type": "block", "block_id": "block_extract_invoice" },
    "source": {
      "type": "manual",
      "handle_inputs": {
        "input-document-0": {
          "type": "file",
          "document": {
            "id": "file_invoice_q1",
            "filename": "invoice.pdf",
            "mime_type": "application/pdf"
          }
        }
      }
    },
    "assertion": {
      "target": { "output_handle_id": "output-json-0", "path": "total" },
      "condition": { "kind": "equals", "expected": 1234.56 }
    },
    "name": "Q1 invoice total"
  }'

{
  "id": "wfnodeeval_hsLEQiM61ez9Piv147MWk",
  "workflow_id": "wf_abc123xyz",
  "target": {
    "type": "block",
    "block_id": "block_extract_invoice"
  },
  "source": {
    "type": "manual",
    "handle_inputs": {
      "input-document-0": {
        "type": "file",
        "document": {
          "id": "file_invoice_q1",
          "filename": "invoice.pdf",
          "mime_type": "application/pdf"
        }
      }
    }
  },
  "name": "Q1 invoice total",
  "assertion": {
    "id": "assert_xyz",
    "target": { "output_handle_id": "output-json-0", "path": "total" },
    "condition": { "kind": "equals", "expected": 1234.56 },
    "label": null
  },
  "assertion_schema_dep": {
    "schema_path": "total",
    "subtree_hash": "7d79dd764ab6548d",
    "depends_on_root": false
  },
  "assertion_drift_status": null,
  "schema_drift": "unknown",
  "schema_drift_detail": null,
  "validation_status": "valid",
  "validation_issues": [],
  "latest_run_summary": null,
  "latest_passing_run_summary": null,
  "latest_failing_run_summary": null,
  "created_at": "2026-05-01T14:30:00Z",
  "updated_at": "2026-05-01T14:30:00Z"
}

{
  "detail": "assertion is required for workflow evals."
}

{
  "detail": "Workflow eval not found: <block_id>"
}