@stigmer/mcp-server 3.0.8-dev.20260612122433

package/gen/workflow.js

@@ -0,0 +1,842 @@
+// Code generated by stigmer-codegen --target=mcp-ts. DO NOT EDIT.
+//
+// Flattened apply-input zod schema + toProto bridge for the Workflow resource.
+// Source proto package: ai.stigmer.agentic.workflow.v1
+import { generateSlug, visibilityFromString, enumFromString, toTimestamp } from "./apply-runtime.js";
+import { create, toJson } from "@bufbuild/protobuf";
+import { ContextManagementConfigSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/spec_pb";
+import { EnvVarDeclarationSchema } from "@stigmer/protos/ai/stigmer/agentic/environment/v1/spec_pb";
+import { Harness } from "@stigmer/protos/ai/stigmer/agentic/session/v1/enum_pb";
+import { WorkflowSchema } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/api_pb";
+import { WorkflowTaskKind, BudgetExceededPolicy } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/enum_pb";
+import { WorkflowSpecSchema, WorkflowDocumentSchema, ExportSchema, FlowControlSchema, WorkflowTaskSchema, WorkflowBudgetSchema } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/spec_pb";
+import { AgentExecutionConfigSchema, AgentCallOutputContractSchema, AgentCallTaskConfigSchema } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/tasks/agent_call_pb";
+import { CallActivityTaskConfigSchema } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/tasks/call_activity_pb";
+import { OnInvalidOutputPolicy } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/tasks/common_pb";
+import { EmitEventSpecSchema, EmitEventTaskConfigSchema } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/tasks/emit_event_pb";
+import { EvalCriterionSchema, EvalTaskConfigSchema, EvalScoringMode, EvalFailPolicy } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/tasks/eval_pb";
+import { ForTaskConfigSchema, ForEachErrorPolicy } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/tasks/for_pb";
+import { ForkBranchSchema, ForkTaskConfigSchema } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/tasks/fork_pb";
+import { GrpcCallTaskConfigSchema } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/tasks/grpc_call_pb";
+import { HttpEndpointSchema, HttpCallTaskConfigSchema } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/tasks/http_call_pb";
+import { HumanInputOutcomeSchema, HumanInputTaskConfigSchema, HumanInputTimeoutPolicy } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/tasks/human_input_pb";
+import { SignalSpecSchema, ListenToSchema, ListenTaskConfigSchema } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/tasks/listen_pb";
+import { LlmCallTaskConfigSchema } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/tasks/llm_call_pb";
+import { NotificationTaskConfigSchema } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/tasks/notification_pb";
+import { RaiseTaskConfigSchema } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/tasks/raise_pb";
+import { RunTaskConfigSchema } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/tasks/run_pb";
+import { SetTaskConfigSchema } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/tasks/set_pb";
+import { SwitchCaseSchema, SwitchTaskConfigSchema } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/tasks/switch_pb";
+import { TransformTaskConfigSchema, TransformEngine } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/tasks/transform_pb";
+import { CatchBlockSchema, TryTaskConfigSchema } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/tasks/try_pb";
+import { ValidationRuleSchema, ValidateTaskConfigSchema, ValidationFailPolicy } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/tasks/validate_pb";
+import { DurationSchema, WaitTaskConfigSchema } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/tasks/wait_pb";
+import { ApiResourceMetadataSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/metadata_pb";
+import { z } from "zod";
+/** WorkflowSpec defines the configurable properties of a workflow. @internal Follows the "kind + Struct" pattern from CloudResource (Planton). This replaces the old `synthesized_yaml` field with structured proto definitions. Each workflow task uses WorkflowTaskKind enum + google.protobuf.Struct for configuration, providing maximum flexibility and extensibility. The overview.md file provides the SDK-facing description and example YAML. */
+export const WorkflowInputShape = {
+    name: z.string().describe("Human-readable name of the resource."),
+    slug: z.string().optional().describe("URL-friendly identifier (lowercase alphanumeric with hyphens). Auto-generated from name if omitted."),
+    org: z.string().describe("Organization that owns this resource (e.g. acme)."),
+    visibility: z.string().optional().describe("Resource visibility: PRIVATE or PUBLIC. Omit to leave unchanged on updates."),
+    labels: z.record(z.string()).optional().describe("Key-value labels for organization and filtering."),
+    tags: z.array(z.string()).optional().describe("Tags for categorization and discovery."),
+    description: z.string().optional().describe("Human-readable description for UI and marketplace display."),
+    document: z.lazy(() => WorkflowDocumentInputSchema).describe("Workflow document metadata including DSL version, namespace, name, and version."),
+    tasks: z.array(z.lazy(() => WorkflowTaskInputSchema)).optional().describe("Ordered list of tasks that make up this workflow. Tasks execute sequentially unless fork/parallel is used."),
+    env: z.record(z.lazy(() => EnvVarDeclarationInputSchema)).optional().describe("Environment variable declarations for this workflow. Keys are variable names; values describe their metadata and optionality."),
+    budget: z.lazy(() => WorkflowBudgetInputSchema).optional().describe("Budget limits for this workflow execution. When set, the runtime (T13) enforces cost, token, and duration limits across all tasks. The existing org-level billing reservation system (AuthorizeExecution / ExecutionBillingSignal) remains the safety net for overall credit exhaustion; workflow budgets prevent individual workflows from consuming more than intended. Optional — when not set, no workflow-level budget is enforced."),
+};
+export const WorkflowInputSchema = z.object(WorkflowInputShape);
+const WorkflowDocumentInputSchema = z.object({
+    dsl: z.string().optional().describe("Workflow DSL version (semver). Must be '1.0.0' for the current specification."),
+    namespace: z.string().describe("Workflow namespace (organization/categorization)."),
+    name: z.string().describe("Workflow name (unique identifier within namespace)."),
+    version: z.string().describe("Workflow version (semver)."),
+    description: z.string().optional().describe("Human-readable description."),
+});
+const ContextManagementConfigInputSchema = z.object({
+    disable_summarization: z.boolean().optional().describe("Disable automatic context summarization for this execution. When true, the agent will never trigger automatic summarization, even if the context window approaches the model's limit. Use cases: - Short-lived executions that won't approach context limits - Debugging context-related issues - Workflows that manage their own context externally Warning: Disabling summarization may cause execution failure if context exceeds model limits. Default: false (summarization enabled based on model defaults)"),
+    custom_trigger_threshold: z.number().optional().describe("Custom token threshold to trigger summarization. When the context token count exceeds this threshold, summarization is triggered to reduce context size. Set to 0 to use model default. The default trigger threshold from Model Registry is typically 90% of the model's context window (e.g., 180K for 200K context models). Must be greater than custom_target_tokens if both are specified. Default: 0 (use model default from Model Registry)"),
+    custom_target_tokens: z.number().optional().describe("Custom target token count after summarization. Summarization aims to reduce context to approximately this size. Set to 0 to use model default. The default target from Model Registry is typically 80% of the model's context window (e.g., 160K for 200K context models). Must be less than custom_trigger_threshold if both are specified. Default: 0 (use model default from Model Registry)"),
+});
+const AgentExecutionConfigInputSchema = z.object({
+    model: z.string().optional().describe("LLM model to use for this invocation. Example: 'claude-3-5-sonnet', 'gpt-4', 'claude-3-opus' Optional - uses agent's default model if not specified."),
+    timeout: z.number().optional().describe("Timeout for agent execution in seconds. Default: 300 (5 minutes) Optional."),
+    temperature: z.number().optional().describe("Temperature for LLM sampling (0.0 to 1.0). Lower = more deterministic, Higher = more creative Default: 0.7 Optional."),
+    context_management: z.lazy(() => ContextManagementConfigInputSchema).optional().describe("Context management configuration for this agent invocation. Controls automatic summarization behavior for long-running conversations. When specified, overrides model defaults from the Model Registry. @internal @since Phase 3 (Context Summarization Architecture) Use cases: - Disable summarization for short-lived agents - Custom thresholds for agents with specific context requirements - Fine-tune summarization behavior per workflow task Example YAML: config: model: 'claude-sonnet-4.5' context_management: custom_trigger_threshold: 150000 custom_target_tokens: 120000"),
+    max_cost_micros: z.union([z.number(), z.string()]).optional().describe("Per-agent-call cost cap in micro-USD (1 USD = 1,000,000 micros). When set, the runtime terminates this agent call if its accumulated cost exceeds this limit. This uses the workflow domain's micro-USD convention and provides per-task cost control at the workflow level. The runtime checks both: per-task limit first, then workflow remaining budget. Optional — when 0, no per-task cost limit is enforced. @since T05 (Workflow-Level Budget Primitives)"),
+});
+const AgentCallOutputContractInputSchema = z.object({
+    schema: z.record(z.unknown()).describe("JSON Schema that the agent's structured output must conform to. Standard JSON Schema (draft 2020-12 or compatible). The workflow runner extracts JSON from the agent's final response and validates it against this schema. If validation fails, the on_invalid policy determines what happens next. The schema is carried as a google.protobuf.Struct to preserve the existing kind+Struct envelope pattern and allow YAML authors to write standard JSON Schema inline without a Stigmer-specific schema language."),
+    on_invalid: z.string().optional().describe("Policy when agent output fails schema validation. Default: ON_INVALID_FAIL (task fails immediately). Allowed values: ON_INVALID_FAIL, ON_INVALID_RETRY, ON_INVALID_FALLBACK."),
+    max_retries: z.number().optional().describe("Maximum retry attempts when on_invalid is ON_INVALID_RETRY. Each retry re-prompts the agent with the specific validation errors and the expected schema, giving the agent an opportunity to self-correct. Only meaningful when on_invalid is ON_INVALID_RETRY; ignored otherwise. Default: 1. Valid range: 1-5."),
+    fallback_task: z.string().optional().describe("Target task to branch to when schema validation cannot be resolved. Used in two scenarios: 1. on_invalid is ON_INVALID_RETRY and all retries are exhausted 2. on_invalid is ON_INVALID_FALLBACK (immediate branch, no retry) Must reference a valid task name in the same workflow. When empty and retries are exhausted, the task fails."),
+});
+const AgentCallTaskConfigInputSchema = z.object({
+    agent: z.string().describe("Agent reference in 'org/slug' or 'slug' format. - 'slug' only: uses the workflow's organization - 'org/slug': explicit organization reference Examples: 'code-reviewer', 'stigmer/code-reviewer', 'acme/data-analyst' Required field."),
+    org: z.string().optional().describe("Explicit organization for agent resolution. Optional. If empty, the org is parsed from the agent field or defaults to workflow's org. Use this when you need to override the parsed org."),
+    message: z.string().describe("Instructions/prompt to send to the agent. Supports interpolation of workflow variables using JQ expressions. Example: 'Analyze this code: ${ $context.fetchCode.body }' Required field."),
+    env: z.record(z.string()).optional().describe("Runtime environment variables to pass to the agent. Values can be literal strings or JQ expressions that reference workflow context or secrets. Example: {'GITHUB_TOKEN': '${ .secrets.GH_TOKEN }'} Optional."),
+    config: z.lazy(() => AgentExecutionConfigInputSchema).optional().describe("Execution configuration for the agent invocation. Optional - defaults are applied if not specified."),
+    output: z.lazy(() => AgentCallOutputContractInputSchema).optional().describe("Structured output contract for this agent call. When set, the workflow runner extracts structured JSON from the agent's final response and validates it against the declared schema. The validated JSON is placed in the task output under the 'structured' key, enabling reliable downstream routing via switch_case expressions. When not set, the task output contains the agent's raw text response (backward compatible with existing workflows). @since T02 (Structured Agent Output Model)"),
+    harness: z.string().optional().describe("Execution harness for the agent invocation. Determines which execution engine processes the agent call: - HARNESS_UNSPECIFIED / HARNESS_NATIVE: Stigmer native engine (Python/LangGraph) - HARNESS_CURSOR: Cursor SDK engine (TypeScript/Cursor) The workflow-runner creates a Session with this harness before creating the AgentExecution. The harness is a session-level concern — it determines tool availability, state management, model access, and billing tier. When unspecified, defaults to HARNESS_NATIVE for backward compatibility. YAML Example: - code_review: call: agent with: agent: 'code-reviewer' harness: cursor message: 'Review this PR' Allowed values: HARNESS_NATIVE, HARNESS_CURSOR."),
+});
+const CallActivityTaskConfigInputSchema = z.object({
+    activity: z.string().describe("Activity name to execute. @internal Must match a registered Temporal activity."),
+    input: z.record(z.unknown()).optional().describe("Activity input (optional). Can be any JSON structure. Supports expressions in string values."),
+});
+const EmitEventInputSchema = z.object({
+    type: z.string().describe("CloudEvents type identifier. A reverse-DNS string that categorizes the event for routing and filtering. Examples: 'stigmer.workflow.ticket.classified', 'acme.order.completed'"),
+    source: z.string().optional().describe("CloudEvents source identifier. URI or URI-reference that identifies the context in which the event happened. Supports ${ } expression interpolation. When empty, the runtime defaults to the workflow execution URI (e.g., '/workflows/{workflow_id}/executions/{execution_id}')."),
+    data: z.record(z.unknown()).optional().describe("Event payload data. Arbitrary JSON object carried as the CloudEvents data attribute. Values within the Struct can contain ${ } expressions that the runtime evaluates before emission. Unlike other Struct fields in the workflow domain (response_schema, form_schema, schema) which carry JSON Schema definitions, this field carries the actual event payload — not a schema."),
+    subject: z.string().optional().describe("CloudEvents subject identifier. Describes the subject of the event in the context of the event producer. Supports ${ } expression interpolation. Examples: '${ $context.ticket.id }', '${ $context.order.number }'"),
+});
+const EmitEventTaskConfigInputSchema = z.object({
+    event: z.lazy(() => EmitEventInputSchema).describe("The event specification to emit. Contains the CloudEvents envelope fields (type, source, data, subject). Required field."),
+});
+const EvalCriterionInputSchema = z.object({
+    name: z.string().describe("Name of this evaluation dimension. Used in the judge prompt and appears in the output. Examples: 'accuracy', 'completeness', 'safety', 'relevance'"),
+    description: z.string().describe("Description of what this criterion measures. Included in the judge prompt to guide the LLM's assessment. Example: 'Does the response accurately reflect the source data without hallucinations?'"),
+    weight: z.number().optional().describe("Relative weight for computing the weighted average overall score. When all weights are equal (or all zero), criteria are averaged uniformly. Example: accuracy=3.0, formatting=1.0 means accuracy counts 3x more."),
+});
+const EvalTaskConfigInputSchema = z.object({
+    model: z.string().describe("LLM model used as the judge. Resolved via the Stigmer model registry. Examples: 'gpt-4o', 'claude-sonnet-4-5'"),
+    subject: z.string().describe("Expression selecting the data to evaluate. Supports ${ } expression interpolation. Example: '${ $context.summarize.text }' to evaluate a summary task's output."),
+    rubric: z.string().describe("Evaluation criteria in natural language. Tells the judge LLM what to assess and what 'good' looks like. For pass_fail: describe what constitutes a pass. For numeric_score: describe the scoring scale. For multi_criteria: provide overall context (per-criterion detail goes in criteria field)."),
+    scoring_mode: z.string().optional().describe("How the judge scores the subject. Default: EVAL_PASS_FAIL. Allowed values: EVAL_PASS_FAIL, EVAL_NUMERIC_SCORE, EVAL_MULTI_CRITERIA."),
+    threshold: z.number().optional().describe("Pass threshold for numeric_score and multi_criteria modes. The subject passes if score >= threshold. Ignored for pass_fail mode (the judge's binary decision is used directly). Valid range: 0.0 to 1.0. Default: 0.5."),
+    on_fail: z.string().optional().describe("Policy applied when the subject fails evaluation. Default: EVAL_FAIL_RAISE (task fails with evaluation error). Allowed values: EVAL_FAIL_RAISE, EVAL_FAIL_BRANCH, EVAL_FAIL_WARN."),
+    fallback_task: z.string().optional().describe("Target task to branch to when on_fail is EVAL_FAIL_BRANCH. Must reference a valid task name in the same workflow. Only meaningful when on_fail is EVAL_FAIL_BRANCH; ignored otherwise."),
+    system_prompt: z.string().optional().describe("Optional custom system prompt override for the judge LLM. When set, replaces the auto-generated judge system prompt entirely. Use only when the default judge prompt template does not fit your needs. When empty, the runtime constructs a judge-appropriate system prompt from the rubric, scoring_mode, and criteria."),
+    criteria: z.array(z.lazy(() => EvalCriterionInputSchema)).optional().describe("Evaluation criteria for multi_criteria mode. Required when scoring_mode is EVAL_MULTI_CRITERIA; ignored otherwise. Each criterion is scored independently, and the overall score is the weighted average (uniform if all weights are equal or zero)."),
+    max_cost_micros: z.union([z.number(), z.string()]).optional().describe("Per-task cost cap in micro-USD (1 USD = 1,000,000 micros). When set, the runtime terminates this eval call if its cost exceeds this limit, independent of the workflow-level budget. Optional — when 0, no per-task cost limit is enforced. @since T05 (Workflow-Level Budget Primitives)"),
+});
+const ForTaskConfigInputSchema = z.lazy(() => z.object({
+    each: z.string().describe("Variable name for each item in the iteration. Accessible via ${ $data.item } in expressions."),
+    in: z.string().describe("Expression evaluating to the collection to iterate over. Example: '${ $data.items }' or '${ [1, 2, 3] }'"),
+    do: z.array(z.lazy(() => WorkflowTaskInputSchema)).optional().describe("Tasks to execute for each iteration. Loop variables available: ${ $data.item }, ${ $data.index }"),
+    max_parallelism: z.number().optional().describe("Maximum number of iterations to execute concurrently. 0 (default): sequential execution — iterations run one at a time in input order. This preserves pre-T17 behavior. 1: effectively sequential (one at a time, but uses the parallel execution path — useful for testing). N > 1: up to N iterations run concurrently using Temporal workflow goroutines with a semaphore-based concurrency limiter. Results are always reassembled in original input order regardless of completion order. @since T17 (Advanced Agentic Orchestration)"),
+    batch_size: z.number().optional().describe("Number of items to process in each batch before moving to the next. 0 (default): no batching — all items are available for parallel execution (up to max_parallelism concurrent). N > 0: items are chunked into groups of N. Each chunk is fully processed before the next chunk begins. Within each chunk, up to max_parallelism iterations run concurrently. Only meaningful when max_parallelism > 0; ignored in sequential mode. @since T17 (Advanced Agentic Orchestration)"),
+    on_error: z.string().optional().describe("Policy for handling individual iteration failures. Default: FOR_EACH_FAIL_FAST (stop on first error). Only meaningful when max_parallelism > 0; in sequential mode, any failure stops the loop regardless of this setting (pre-T17 behavior). @since T17 (Advanced Agentic Orchestration) Allowed values: FOR_EACH_FAIL_FAST, FOR_EACH_CONTINUE, FOR_EACH_SKIP."),
+}));
+const ForkBranchInputSchema = z.lazy(() => z.object({
+    name: z.string().describe("Branch name/identifier."),
+    do: z.array(z.lazy(() => WorkflowTaskInputSchema)).optional().describe("Tasks to execute in this branch."),
+}));
+const ForkTaskConfigInputSchema = z.lazy(() => z.object({
+    branches: z.array(z.lazy(() => ForkBranchInputSchema)).optional().describe("Branches to execute in parallel (at least 2 required)."),
+    compete: z.boolean().optional().describe("If true, first branch to complete wins (race mode). If false, all branches must complete (default)."),
+}));
+const GrpcCallTaskConfigInputSchema = z.object({
+    service: z.string().describe("Fully qualified service name. Example: 'com.example.UserService'"),
+    method: z.string().describe("Method name to call. Example: 'GetUser'"),
+    request: z.record(z.unknown()).optional().describe("Request message (optional). Can be any JSON structure matching the proto schema. Supports expressions in string values."),
+});
+const HttpEndpointInputSchema = z.object({
+    uri: z.string().describe("URI of the endpoint. Can contain expressions: 'https://api.example.com/${.resource}'"),
+});
+const HttpCallTaskConfigInputSchema = z.object({
+    method: z.string().describe("HTTP method (GET, POST, PUT, DELETE, PATCH). Allowed values: GET, POST, PUT, DELETE, PATCH."),
+    endpoint: z.lazy(() => HttpEndpointInputSchema).describe("HTTP endpoint configuration."),
+    headers: z.record(z.string()).optional().describe("HTTP headers (optional). Values can contain expressions: 'Bearer ${TOKEN}'"),
+    body: z.record(z.unknown()).optional().describe("Request body (optional). Can be any JSON structure. Supports expressions in string values."),
+    timeout_seconds: z.number().optional().describe("Request timeout in seconds (optional, default: 30)."),
+});
+const HumanInputOutcomeInputSchema = z.object({
+    name: z.string().describe("Outcome identifier used in task output and routing. Examples: 'approve', 'deny', 'needs_revision', 'escalate', 'defer' Must be unique within the outcomes list."),
+    label: z.string().optional().describe("Human-readable label for the button/action in the approval UI. When empty, the UI displays the capitalized name. Examples: 'Approve Escalation', 'Reject — Not Customer-Impacting'"),
+    then: z.string().optional().describe("Task to branch to when this outcome is selected. Must reference a valid task name in the same workflow. When empty, the workflow continues to the next task in sequence."),
+});
+const HumanInputTaskConfigInputSchema = z.object({
+    prompt: z.string().describe("Message shown to the reviewer explaining what needs approval or input. Supports ${ } expression interpolation for injecting workflow context. Example: 'Approve escalation for ticket ${ $context.ticket.id }?'"),
+    form_schema: z.record(z.unknown()).optional().describe("JSON Schema defining the input form rendered to the reviewer. When set, the approval UI renders a typed form based on this schema. The reviewer's form response is validated against the schema before the task completes, and the validated data appears in the task output under the 'form_data' key. When not set, the reviewer sees only the outcome buttons (approve/deny or custom outcomes) without a data entry form. Uses the same google.protobuf.Struct + JSON Schema pattern as AgentCallOutputContract.schema and LlmCallTaskConfig.response_schema."),
+    outcomes: z.array(z.lazy(() => HumanInputOutcomeInputSchema)).optional().describe("Named outcomes that the reviewer can select. Each outcome represents a decision the reviewer can make, with optional routing to a different downstream task. This enables rich branching beyond binary approve/deny. When empty, the task defaults to binary behavior: - 'approve': task completes, workflow continues to next task - 'deny': task fails (enters try_catch or EXECUTION_FAILED) When custom outcomes are defined, the first outcome is used as the default for HUMAN_INPUT_TIMEOUT_APPROVE, and the last outcome is used as the default for HUMAN_INPUT_TIMEOUT_DENY."),
+    approvers: z.array(z.string()).optional().describe("Approver identifiers — who is allowed to respond to this task. Supports user IDs, team slugs, and role names. Format examples: - 'user:jane@acme.com' — specific user - 'team:engineering-leads' — any member of the team - 'role:content-admin' — any user with the role When empty, any authenticated user can respond. Resolution of these identifiers is a runtime concern (T13)."),
+    timeout: z.number().optional().describe("Timeout in seconds before the on_timeout policy applies. Default: 0 (no timeout — the task waits indefinitely). Max: 2592000 (30 days). A timeout of 0 means the workflow will wait until a human responds. For production workflows, setting a timeout with an appropriate on_timeout policy is strongly recommended."),
+    on_timeout: z.string().optional().describe("Policy applied when the timeout expires without a response. Only meaningful when timeout > 0; ignored when timeout is 0. Default: HUMAN_INPUT_TIMEOUT_FAIL (task fails with timeout error). Allowed values: HUMAN_INPUT_TIMEOUT_FAIL, HUMAN_INPUT_TIMEOUT_APPROVE, HUMAN_INPUT_TIMEOUT_DENY, HUMAN_INPUT_TIMEOUT_ESCALATE."),
+    notification_channels: z.array(z.string()).optional().describe("Channel identifiers for sending approval request notifications. When the task starts, the runtime sends notifications through these channels to alert potential approvers. Format examples: - 'slack:#approvals' — Slack channel - 'email:ops@acme.com' — email address - 'teams:#incident-response' — Microsoft Teams channel The format and routing of notifications is a runtime concern (T13). The proto carries the identifiers; the runtime resolves them to actual notification providers configured in the workflow instance's environment."),
+});
+const SignalInputSchema = z.object({
+    id: z.string().describe("Signal identifier."),
+    type: z.string().describe("Signal type: 'signal', 'query', or 'update'. Allowed values: signal, query, update."),
+});
+const ListenToInputSchema = z.object({
+    mode: z.string().describe("Listening mode: - 'one': Wait for any one signal - 'all': Wait for all signals Allowed values: one, all."),
+    signals: z.array(z.lazy(() => SignalInputSchema)).optional().describe("Signals to listen for."),
+});
+const ListenTaskConfigInputSchema = z.object({
+    to: z.lazy(() => ListenToInputSchema).describe("Signal listening configuration."),
+});
+const LlmCallTaskConfigInputSchema = z.object({
+    model: z.string().describe("Model reference resolved via the Stigmer model registry. Examples: 'gpt-4o', 'gpt-4o-mini', 'claude-sonnet-4-5', 'claude-haiku-3-5' Required field."),
+    system_prompt: z.string().optional().describe("System prompt that sets the LLM's role and constraints. Supports ${ } expression interpolation for dynamic system prompts. Optional — omit for tasks where the user prompt is self-contained."),
+    prompt: z.string().describe("User prompt / instruction sent to the LLM. Supports ${ } expression interpolation for injecting workflow context. Example: 'Classify this ticket: ${ $context.ticket.description }' Required field."),
+    response_schema: z.record(z.unknown()).optional().describe("JSON Schema for structured output. When set, the runner requests structured output from the provider (e.g., OpenAI's response_format, Anthropic's tool_use extraction) and validates the response against this schema. Uses the same google.protobuf.Struct + JSON Schema pattern as AgentCallOutputContract.schema for consistency across the workflow domain. When not set, the task output is the LLM's raw text response."),
+    temperature: z.number().optional().describe("Sampling temperature (0.0 to 2.0). Lower = more deterministic, higher = more creative. Range is 0.0-2.0 to accommodate all major providers (OpenAI supports up to 2.0; others clamp to their supported range at runtime). Optional — uses the provider's default when not set."),
+    max_tokens: z.number().optional().describe("Maximum tokens in the LLM response. Optional — uses the provider's default when not set."),
+    timeout: z.number().optional().describe("Timeout for the LLM call in seconds. Default: 60. Max: 600 (10 minutes). Optional."),
+    on_invalid: z.string().optional().describe("Policy when the LLM response fails schema validation. Only meaningful when response_schema is set; ignored otherwise. Default: ON_INVALID_FAIL (task fails immediately). Allowed values: ON_INVALID_FAIL, ON_INVALID_RETRY, ON_INVALID_FALLBACK."),
+    max_retries: z.number().optional().describe("Maximum schema-validation retry attempts when on_invalid is ON_INVALID_RETRY. Each retry re-prompts the LLM with the validation errors and expected schema, giving it an opportunity to self-correct. Only meaningful when on_invalid is ON_INVALID_RETRY; ignored otherwise. Default: 1. Valid range: 1-5."),
+    fallback_task: z.string().optional().describe("Target task to branch to when schema validation cannot be resolved. Used in two scenarios: 1. on_invalid is ON_INVALID_RETRY and all retries are exhausted 2. on_invalid is ON_INVALID_FALLBACK (immediate branch, no retry) Must reference a valid task name in the same workflow. When empty and retries are exhausted, the task fails."),
+    max_cost_micros: z.union([z.number(), z.string()]).optional().describe("Per-task cost cap in micro-USD (1 USD = 1,000,000 micros). When set, the runtime terminates this specific LLM call if its cost exceeds this limit, independent of the workflow-level budget. The runtime checks both: per-task limit first, then workflow remaining budget. Optional — when 0, no per-task cost limit is enforced. @since T05 (Workflow-Level Budget Primitives)"),
+    max_total_tokens: z.union([z.number(), z.string()]).optional().describe("Per-task token cap (input + output tokens combined). When set, the runtime terminates this specific LLM call if total tokens exceed this limit. Complements max_tokens (field 6), which limits only the output token count as a generation parameter. Optional — when 0, no per-task total token limit is enforced. @since T05 (Workflow-Level Budget Primitives)"),
+});
+const NotificationTaskConfigInputSchema = z.object({
+    channel: z.string().describe("Notification channel identifier. Determines which notification provider processes this message. Common values: 'slack', 'email', 'discord', 'teams', 'webhook' This is a string (not an enum) for extensibility — new channels can be added without proto changes. The runtime resolves the channel to its configured provider in the workflow instance's environment."),
+    recipients: z.array(z.string()).optional().describe("Recipient identifiers for the notification. Format depends on the channel: - slack: '#channel-name', '@username', or Slack user IDs - email: 'user@example.com' - discord: '#channel-name', '@role' - teams: '#channel-name' - webhook: URL or webhook identifier At least one recipient is required. Individual values may contain ${ } expressions that the runtime evaluates before delivery (e.g., '${ $context.customer.email }')."),
+    subject: z.string().optional().describe("Notification subject or title. Supports ${ } expression interpolation. Used as: email subject line, Slack message title, webhook payload title. Optional — some channels (e.g., simple Slack messages) may not use it."),
+    body: z.string().describe("Notification body / message content. Supports ${ } expression interpolation. The primary content of the notification. Formatting depends on channel (e.g., Slack Markdown, HTML for email, plain text for SMS). When template is also set, body serves as the fallback content if the template cannot be resolved."),
+    template: z.string().optional().describe("Named template reference for rendering the notification. When set, the runtime looks up this template in the workflow instance's environment and uses it for rendering, with the workflow context as template data. The body field is used as fallback if the template cannot be resolved. Examples: 'incident-alert', 'order-confirmation', 'approval-request' Template resolution and rendering is a runtime concern (T13)."),
+    metadata: z.record(z.string()).optional().describe("Channel-specific metadata as key-value pairs. Provides additional configuration that varies by notification channel: - slack: {'thread_ts': '...', 'unfurl_links': 'false'} - email: {'priority': 'high', 'reply_to': '...', 'cc': '...'} - webhook: {'method': 'POST', 'content_type': 'application/json'} Values may contain ${ } expressions that the runtime evaluates before delivery."),
+});
+const RaiseTaskConfigInputSchema = z.object({
+    error: z.string().describe("Error type/name."),
+    message: z.string().describe("Error message. Can contain expressions: '${ .errorMessage }'"),
+});
+const RunTaskConfigInputSchema = z.object({
+    workflow: z.string().describe("Sub-workflow name/identifier to execute."),
+    input: z.record(z.unknown()).optional().describe("Sub-workflow input (optional). Can be any JSON structure. Supports expressions in string values."),
+});
+const SetTaskConfigInputSchema = z.object({
+    variables: z.record(z.string()).describe("Variables to set in workflow state. Keys are variable names, values can be literals or expressions. Expressions use ${...} syntax, e.g., '${.a + .b}' or '${now}'"),
+});
+const SwitchCaseInputSchema = z.object({
+    name: z.string().describe("Case name/identifier."),
+    when: z.string().optional().describe("Condition expression (optional). If empty, this is the default case. Example: '${ $context.value > 5 }'"),
+    then: z.string().describe("Target task name to execute if condition matches."),
+});
+const SwitchTaskConfigInputSchema = z.object({
+    cases: z.array(z.lazy(() => SwitchCaseInputSchema)).optional().describe("List of switch cases (at least one required). Cases are evaluated in order. First matching case executes. If no 'when' is specified, the case acts as default."),
+});
+const TransformTaskConfigInputSchema = z.object({
+    engine: z.string().describe("Transformation engine to use. Required — must be explicitly set (not UNSPECIFIED). Allowed values: TRANSFORM_ENGINE_JQ, TRANSFORM_ENGINE_JSONATA, TRANSFORM_ENGINE_TEMPLATE."),
+    expression: z.string().describe("Transformation expression in the chosen engine's syntax. For JQ: a JQ filter expression (e.g., '{name: .full_name}') For JSONata: a JSONata expression (e.g., '{'name': full_name}') For TEMPLATE: a Go text/template string with {{ }} placeholders Required field."),
+    input: z.string().optional().describe("Expression selecting the input data for the transformation. Supports ${ } expression interpolation. When omitted, the entire workflow context is used as input. Example: '${ $context.triage }' to transform just the triage output."),
+});
+const CatchBlockInputSchema = z.lazy(() => z.object({
+    as: z.string().optional().describe("Variable name to store the error (optional). Accessible via ${ .error } in catch tasks."),
+    do: z.array(z.lazy(() => WorkflowTaskInputSchema)).optional().describe("Tasks to execute when error is caught."),
+    compensate: z.boolean().optional().describe("Whether to run compensation tasks for already-completed try tasks before executing the catch do block. When true, the runtime walks the compensation stack (completed tasks that declared a 'compensate' block) in reverse order and executes each task's compensation actions. After all compensations complete (or fail), the catch 'do' block runs as normal. Compensation failures do not prevent the catch block from running. They are logged and included in the task output for diagnostics. Default: false (no compensation — preserves pre-T17 behavior). @since T17 (Advanced Agentic Orchestration)"),
+}));
+const TryTaskConfigInputSchema = z.lazy(() => z.object({
+    try: z.array(z.lazy(() => WorkflowTaskInputSchema)).optional().describe("Tasks to attempt (at least one required). If any task fails, execution jumps to catch block."),
+    catch: z.lazy(() => CatchBlockInputSchema).optional().describe("Catch block for error handling (optional). If not provided, errors propagate to parent."),
+}));
+const ValidationRuleInputSchema = z.object({
+    name: z.string().describe("Rule identifier for error reporting and debugging. Appears in validation error output so operators can identify which specific rule failed. Examples: 'critical_needs_rationale', 'customer_impact_requires_high_severity'"),
+    expression: z.string().describe("Boolean expression that must evaluate to true for the rule to pass. Supports ${ } expression interpolation. The expression receives the validate task's input data as its context. Example: '${ .severity != 'critical' || (.rationale != null && .rationale != '') }'"),
+    message: z.string().optional().describe("Error message included in validation output when the rule fails. Supports ${ } expression interpolation for dynamic error messages. When empty, a generic message is generated from the rule name. Example: 'Critical severity requires a rationale'"),
+});
+const ValidateTaskConfigInputSchema = z.object({
+    input: z.string().describe("Expression selecting the data to validate. Supports ${ } expression interpolation. Example: '${ $context.triage }' to validate the triage task's output."),
+    schema: z.record(z.unknown()).optional().describe("JSON Schema to validate the input data against. Standard JSON Schema (draft 2020-12 or compatible). The runtime validates the input data against this schema and reports detailed errors for any constraint violations. Uses the same google.protobuf.Struct + JSON Schema pattern as AgentCallOutputContract.schema, LlmCallTaskConfig.response_schema, and HumanInputTaskConfig.form_schema. At least one of schema or rules must be set."),
+    rules: z.array(z.lazy(() => ValidationRuleInputSchema)).optional().describe("Business rules to evaluate against the input data. Each rule is a boolean expression that must evaluate to true. Rules complement schema validation by expressing constraints that JSON Schema cannot: cross-field dependencies, conditional requirements, and domain-specific invariants. At least one of schema or rules must be set."),
+    on_fail: z.string().optional().describe("Policy applied when validation fails. Default: VALIDATION_FAIL_RAISE (task fails with validation error). Allowed values: VALIDATION_FAIL_RAISE, VALIDATION_FAIL_BRANCH, VALIDATION_FAIL_WARN."),
+    fallback_task: z.string().optional().describe("Target task to branch to when on_fail is VALIDATION_FAIL_BRANCH. Must reference a valid task name in the same workflow. Only meaningful when on_fail is VALIDATION_FAIL_BRANCH; ignored otherwise. When on_fail is BRANCH and fallback_task is empty, the task fails."),
+});
+const DurationInputSchema = z.object({
+    days: z.number().optional().describe("Number of days to wait (24 hours each)."),
+    hours: z.number().optional().describe("Number of hours to wait."),
+    minutes: z.number().optional().describe("Number of minutes to wait."),
+    seconds: z.number().optional().describe("Number of seconds to wait."),
+    milliseconds: z.number().optional().describe("Number of milliseconds to wait."),
+});
+const WaitTaskConfigInputSchema = z.object({
+    duration: z.lazy(() => DurationInputSchema).optional().describe("Relative duration to wait from now. Use this when you want to wait for a specific amount of time regardless of when the workflow reaches this task. Example: { days: 7 } = wait 1 week from now"),
+    until: z.string().optional().describe("Absolute timestamp to wait until. Use this when you want to wait until a specific point in time. If the timestamp is in the past, the task completes immediately. Example: '2026-03-01T09:00:00Z' = wait until March 1st, 2026 at 9am UTC"),
+});
+const ExportInputSchema = z.object({
+    as: z.string().optional().describe("Expression defining how to export output using ${...} syntax."),
+});
+const FlowControlInputSchema = z.object({
+    then: z.string().optional().describe("Target task name or 'end' to terminate workflow."),
+});
+const WorkflowTaskInputSchema = z.lazy(() => z.object({
+    name: z.string().optional().describe("Task name/identifier (must be unique within workflow). Must be a valid C-style identifier: starts with a letter or underscore, followed by letters, digits, or underscores."),
+    kind: z.string().describe("Task type. Set the matching config field (e.g. kind='http_call' -> populate http_call). Allowed values: set_vars, http_call, grpc_call, activity_call, switch_case, for_each, fork, try_catch, listen, wait, raise_error, run_workflow, agent_call, llm_call, transform, human_input, validate, emit_event, notification, eval."),
+    agent_call: z.lazy(() => AgentCallTaskConfigInputSchema).optional().describe("Required when kind='agent_call'. AgentCallTaskConfig defines the configuration for agent_call tasks that invoke AI agents. @internal The agent is referenced by org/slug format (e.g., 'stigmer/code-reviewer'). Resolution order: 1. If org is specified: look in that org's agents 2. If org is empty: use the workflow's org 3. Before external lookup, check manifest (current deployment) The workflow's execution context (environment variables, secrets) is passed to the agent invocation, allowing agents to access workflow state. YAML Example (without structured output): - analyze: call: agent with: agent: 'code-reviewer' message: 'Review this code: ${ $context.fetchCode.body }' env: GITHUB_TOKEN: '${ .secrets.GH_TOKEN }' config: model: 'claude-3-5-sonnet' timeout: 300 YAML Example (with structured output): - triage_ticket: call: agent with: agent: 'support-triage' message: '${ .ticket.description }' output: schema: type: object required: [severity, category, customer_impact] properties: severity: type: string enum: [low, medium, high, critical] category: type: string customer_impact: type: boolean rationale: type: string on_invalid: ON_INVALID_RETRY max_retries: 2 fallback_task: human_review export: as: '${ .structured }' Reference: design doc at stigmer/_cursor/add-agent-config-to-workflow.md"),
+    activity_call: z.lazy(() => CallActivityTaskConfigInputSchema).optional().describe("Required when kind='activity_call'. CallActivityTaskConfig defines the configuration for activity_call tasks that execute activities. @internal Executes Temporal activities. YAML Example: - taskName: call: activity with: activity: 'ProcessDataActivity' input: data: ${ .data } Reference: zigflow-dsl-pattern-catalog.md - Task Type 10"),
+    emit_event: z.lazy(() => EmitEventTaskConfigInputSchema).optional().describe("Required when kind='emit_event'. EmitEventTaskConfig defines the configuration for emit_event tasks that publish CloudEvents to external consumers, other workflows, audit trails, and metrics systems. @internal emit_event is the complement to listen. While listen waits for Temporal signals (internal workflow primitives), emit_event publishes business events using the CloudEvents envelope (a standard external contract). The runtime (T13) bridges the two: an emitted CloudEvent can be delivered as a Temporal signal to another workflow's listen task, or routed to external consumers via message queues, webhooks, or event buses. The task output is the fully-resolved CloudEvents envelope with runtime-generated fields populated: { 'id': '<generated UUID>', 'specversion': '1.0', 'type': 'stigmer.workflow.ticket.classified', 'source': '/workflows/triage/executions/abc-123', 'time': '2026-05-12T14:30:00Z', 'subject': 'TICKET-456', 'datacontenttype': 'application/json', 'data': { <resolved payload> } } YAML Example (emit a classification event): - notify_classified: emit_event: event: type: 'stigmer.workflow.ticket.classified' subject: '${ $context.ticket.id }' data: ticket_id: '${ $context.ticket.id }' severity: '${ $context.triage.severity }' category: '${ $context.triage.category }' classified_by: '${ $context.workflow_instance_id }' export: as: '${ . }' YAML Example (emit with explicit source): - publish_completion: emit_event: event: type: 'acme.order.fulfilled' source: 'urn:acme:fulfillment-service' subject: '${ $context.order.number }' data: order_id: '${ $context.order.id }' status: 'fulfilled' fulfilled_at: '${ $context.timestamp }' export: as: '${ . }'"),
+    eval: z.lazy(() => EvalTaskConfigInputSchema).optional().describe("Required when kind='eval'. EvalTaskConfig defines the configuration for eval tasks that use an LLM judge to assess the semantic quality of workflow data. @internal Use eval when you need to assess quality, correctness, safety, or completeness of LLM-generated or agent-produced content. This fills the gap between structural validation (validate task — JSON Schema, business rules) and human review (human_input task — manual inspection). The eval task constructs a judge prompt from the rubric and subject, calls the specified LLM with structured output enforcement, parses the judge's response, and applies the threshold to determine pass/fail. Key differences from validate: - validate checks deterministic structural properties (schema, rules) - eval checks semantic quality via an LLM judge (hallucination, relevance, safety) Key differences from llm_call: - llm_call is a general-purpose LLM invocation - eval has built-in judge prompt construction, scoring semantics, threshold application, and on_fail branching Task output structure: { 'pass': true/false, 'score': 0.85, // present for numeric_score and multi_criteria 'reasoning': 'The response...', 'criteria': [ // present only for multi_criteria {'name': 'accuracy', 'score': 0.9, 'reasoning': '...'}, {'name': 'safety', 'score': 0.8, 'reasoning': '...'} ], 'model_used': 'gpt-4o', 'subject': <original subject data> } YAML Example (binary pass/fail evaluation): - check_summary_quality: call: eval with: model: 'gpt-4o' subject: '${ $context.summarize.text }' rubric: | Evaluate whether this summary accurately captures the key points of the source document without hallucinations or omissions. The summary should be concise (under 3 sentences) and factually correct. scoring_mode: EVAL_PASS_FAIL on_fail: EVAL_FAIL_BRANCH fallback_task: regenerate_summary export: as: '${ . }' YAML Example (numeric score with threshold): - score_translation: call: eval with: model: 'gpt-4o' subject: '${ $context.translate.text }' rubric: | Rate the quality of this translation on accuracy, fluency, and preservation of meaning. Score 0.0 (unusable) to 1.0 (perfect). scoring_mode: EVAL_NUMERIC_SCORE threshold: 0.7 on_fail: EVAL_FAIL_WARN export: as: '${ . }' YAML Example (multi-criteria evaluation): - evaluate_response: call: eval with: model: 'gpt-4o' subject: '${ $context.agent_response }' rubric: 'Evaluate this customer support response.' scoring_mode: EVAL_MULTI_CRITERIA threshold: 0.75 criteria: - name: accuracy description: 'Is the information factually correct?' weight: 3.0 - name: helpfulness description: 'Does it address the customer's actual question?' weight: 2.0 - name: tone description: 'Is the tone professional and empathetic?' weight: 1.0 on_fail: EVAL_FAIL_RAISE export: as: '${ . }'"),
+    for_each: z.lazy(() => ForTaskConfigInputSchema).optional().describe("Required when kind='for_each'. ForTaskConfig defines the configuration for for_each tasks that iterate over collections. @internal Supports both sequential (default) and parallel execution modes. When max_parallelism is set, iterations run concurrently using Temporal workflow goroutines with bounded concurrency. Backward compatibility: all new fields default to values that preserve the pre-T17 sequential behavior. Existing workflows require no changes. YAML Example (sequential, unchanged from pre-T17): - taskName: for: each: item in: ${ $data.items } do: - processItem: call: http with: method: POST body: item: ${ $data.item } index: ${ $data.index } YAML Example (parallel with bounded concurrency): - batchProcess: for: each: item in: ${ $data.items } max_parallelism: 5 on_error: FOR_EACH_CONTINUE do: - callApi: call: http with: method: POST endpoint: uri: 'https://api.example.com/process' body: item: ${ $data.item } Reference: zigflow-dsl-pattern-catalog.md - Task Type 4 @since max_parallelism, batch_size, on_error: T17 (Advanced Agentic Orchestration)"),
+    fork: z.lazy(() => ForkTaskConfigInputSchema).optional().describe("Required when kind='fork'. ForkTaskConfig defines the configuration for fork tasks that execute branches in parallel. @internal YAML Example: - taskName: fork: branches: - branch1: do: - task1: call: http with: method: POST endpoint: uri: https://api.example.com/branch1 - branch2: do: - task2: call: http Reference: zigflow-dsl-pattern-catalog.md - Task Type 5"),
+    grpc_call: z.lazy(() => GrpcCallTaskConfigInputSchema).optional().describe("Required when kind='grpc_call'. GrpcCallTaskConfig defines the configuration for grpc_call tasks that make gRPC requests. @internal YAML Example: - taskName: call: grpc with: service: 'com.example.UserService' method: 'GetUser' request: userId: ${ .userId } Reference: zigflow-dsl-pattern-catalog.md - Task Type 9"),
+    http_call: z.lazy(() => HttpCallTaskConfigInputSchema).optional().describe("Required when kind='http_call'. HttpCallTaskConfig defines the configuration for http_call tasks that make HTTP requests. @internal YAML Example: - taskName: call: http with: method: POST endpoint: uri: https://api.example.com/data headers: Authorization: 'Bearer ${TOKEN}' body: field1: value Reference: zigflow-dsl-pattern-catalog.md - Task Type 2"),
+    human_input: z.lazy(() => HumanInputTaskConfigInputSchema).optional().describe("Required when kind='human_input'. HumanInputTaskConfig defines the configuration for human_input tasks that pause workflow execution to collect typed input or approval from a human reviewer, then resume based on the reviewer's response. @internal Use human_input when a workflow needs human judgment before proceeding: approvals before API calls, sign-off before publishing, confirmation before customer-impacting actions, or structured data collection from a human operator. This is a workflow-level approval gate — distinct from agent-level HITL (tool approval inside an agent session). Workflow-level gates are visible in the execution viewer as explicit tasks with input/output/timing, and they can route to different branches based on the reviewer's decision. Runtime implementation (T13) will use Temporal signals for workflow resumption. The proto definition is intentionally runtime-agnostic. The reviewer's response (selected outcome + form data) becomes the task output, accessible via export: { 'outcome': 'approve', 'form_data': { <validated form response if form_schema is set> }, 'reviewer': '<user who responded>', 'responded_at': '<ISO 8601 timestamp>' } YAML Example (approval gate with custom outcomes): - manager_approval: human_input: prompt: 'Customer-impacting incident classified as ${ $context.triage.severity }. Approve escalation?' form_schema: type: object properties: notes: type: string description: 'Optional notes for the engineering team' priority_override: type: string enum: [P1, P2, P3] outcomes: - name: approve label: 'Approve Escalation' - name: deny label: 'Reject — Not Customer-Impacting' then: re_classify - name: needs_revision label: 'Needs More Info' then: gather_more_context approvers: - 'team:engineering-leads' timeout: 86400 on_timeout: HUMAN_INPUT_TIMEOUT_ESCALATE notification_channels: - 'slack:#incident-approvals' export: as: '${ . }' YAML Example (simple binary approval, no form): - confirm_publish: human_input: prompt: 'Ready to publish ${ $context.document.title } to production?' approvers: - 'role:content-admin' timeout: 3600 on_timeout: HUMAN_INPUT_TIMEOUT_FAIL export: as: '${ . }'"),
+    listen: z.lazy(() => ListenTaskConfigInputSchema).optional().describe("Required when kind='listen'. ListenTaskConfig defines the configuration for listen tasks that wait for external signals. @internal Implemented via Temporal signals. YAML Example: - taskName: listen: to: one: with: id: approval_signal type: signal Reference: zigflow-dsl-pattern-catalog.md - Task Type 7"),
+    llm_call: z.lazy(() => LlmCallTaskConfigInputSchema).optional().describe("Required when kind='llm_call'. LlmCallTaskConfig defines the configuration for llm_call tasks that make direct LLM API calls without the overhead of a full agent invocation. @internal Use llm_call when the task is focused and deterministic: classification, extraction, scoring, summarization, moderation, or routing. An agent_call carries setup overhead (system prompt, tool resolution, MCP server setup, session management) that is unnecessary when all you need is a single prompt-response cycle with optional structured output. When response_schema is set, the runner requests structured output from the provider and validates the response against the schema. The on_invalid / max_retries / fallback_task fields control what happens when validation fails, using the same OnInvalidOutputPolicy enum as agent_call's output contract. YAML Example (classification with structured output): - classify_severity: call: llm with: model: 'gpt-4o-mini' system_prompt: 'You are a support ticket classifier.' prompt: 'Classify this ticket: ${ $context.ticket.description }' response_schema: type: object required: [severity, category] properties: severity: type: string enum: [low, medium, high, critical] category: type: string on_invalid: ON_INVALID_RETRY max_retries: 2 export: as: '${ . }' YAML Example (simple summarization, no schema): - summarize: call: llm with: model: 'claude-sonnet-4-5' prompt: 'Summarize in 2 sentences: ${ $context.document.text }' temperature: 0.3 max_tokens: 200 export: as: '${ . }'"),
+    notification: z.lazy(() => NotificationTaskConfigInputSchema).optional().describe("Required when kind='notification'. NotificationTaskConfig defines the configuration for notification tasks that send messages to humans through channels like Slack, email, Discord, Microsoft Teams, or webhooks. @internal notification is a convenience abstraction for 'send a message to humans' — simpler and more intuitive than emit_event for common operational notification patterns. While emit_event publishes system-level CloudEvents for machine consumption, notification is purpose-built for human-readable messages with channel routing and recipient targeting. Key distinction from related task types: emit_event = system-to-system (CloudEvents, consumed by workflows/services) notification = system-to-human (Slack, email, Discord — read by people) human_input = system-to-human-to-system (waits for a response; notification is fire-and-forget) Notifications are fire-and-forget by default. The task output confirms delivery was attempted but does not wait for acknowledgment: { 'channel': 'slack', 'recipients': ['#incident-response'], 'delivered': true, 'delivered_at': '<ISO 8601 timestamp>' } For notifications that require acknowledgment or a response, use human_input instead — it pauses the workflow until a human responds. The channel field is a string (not an enum) to allow extensibility: new notification channels can be added without proto changes. The runtime (T13) resolves channel identifiers to actual notification providers configured in the workflow instance's environment. YAML Example (Slack notification): - alert_slack: notification: channel: 'slack' recipients: - '#incident-response' - '@oncall-lead' subject: 'P${ $context.triage.severity } Incident: ${ $context.ticket.title }' body: | *Severity*: ${ $context.triage.severity } *Category*: ${ $context.triage.category } *Customer Impact*: ${ $context.triage.customer_impact } *Summary*: ${ $context.agent_analysis.structured.summary } metadata: thread_ts: '${ $context.slack_thread_id }' export: as: '${ . }' YAML Example (email with template): - send_confirmation: notification: channel: 'email' recipients: - '${ $context.customer.email }' subject: 'Order ${ $context.order.number } Confirmed' body: 'Your order has been confirmed. You will receive tracking information shortly.' template: 'order-confirmation' metadata: priority: 'high' reply_to: 'support@acme.com' export: as: '${ . }'"),
+    raise_error: z.lazy(() => RaiseTaskConfigInputSchema).optional().describe("Required when kind='raise_error'. RaiseTaskConfig defines the configuration for raise_error tasks that raise errors. @internal YAML Example: - taskName: raise: error: ValidationError message: ${ .errorMessage } Reference: zigflow-dsl-pattern-catalog.md - Task Type 11"),
+    run_workflow: z.lazy(() => RunTaskConfigInputSchema).optional().describe("Required when kind='run_workflow'. RunTaskConfig defines the configuration for run_workflow tasks that execute sub-workflows. @internal Implemented via Temporal child workflows. YAML Example: - taskName: run: workflow: 'sub-workflow-name' input: data: ${ .data } Reference: zigflow-dsl-pattern-catalog.md - Task Type 12"),
+    set_vars: z.lazy(() => SetTaskConfigInputSchema).optional().describe("Required when kind='set_vars'. SetTaskConfig defines the configuration for set_vars tasks that assign variables in workflow state. @internal YAML Example: - taskName: set: variable1: value variable2: ${ expression } computed: ${ .a + .b } Reference: zigflow-dsl-pattern-catalog.md - Task Type 1"),
+    switch_case: z.lazy(() => SwitchTaskConfigInputSchema).optional().describe("Required when kind='switch_case'. SwitchTaskConfig defines the configuration for switch_case tasks that branch conditionally. @internal YAML Example: - taskName: switch: - case1: when: ${ $context.value > 5 } then: highValueTask - defaultCase: then: unknownTask Reference: zigflow-dsl-pattern-catalog.md - Task Type 3"),
+    transform: z.lazy(() => TransformTaskConfigInputSchema).optional().describe("Required when kind='transform'. TransformTaskConfig defines the configuration for transform tasks that perform deterministic data transformation without LLM calls. @internal Use transform when you need to reshape data between tasks: projecting fields, joining objects, converting formats, or building API payloads. Unlike set_vars (which mutates workflow state variables as a side effect), transform produces an explicit output that flows through export like any other task — visible and inspectable in the execution viewer. The distinction from set_vars: set_vars = imperative assignment ('set X to Y'), mutates workflow context transform = functional transformation ('reshape this data'), produces output YAML Example (JQ — reshape data for an API call): - build_api_payload: transform: engine: jq expression: '{name: .customer.full_name, severity: .triage.severity, summary: .agent_analysis.structured.summary}' input: '${ $context }' export: as: '${ . }' YAML Example (template — render a notification message): - render_notification: transform: engine: template expression: 'Ticket {{ .ticket_id }} classified as {{ .severity }} — {{ .summary }}' input: '${ $context.build_api_payload }' export: as: '${ . }'"),
+    try_catch: z.lazy(() => TryTaskConfigInputSchema).optional().describe("Required when kind='try_catch'. TryTaskConfig defines the configuration for try_catch tasks that handle errors. @internal YAML Example: - taskName: try: - attemptTask: call: http with: method: POST endpoint: uri: https://api.example.com/flaky catch: as: error do: - errorHandler: call: http with: body: error: ${ .error } Reference: zigflow-dsl-pattern-catalog.md - Task Type 6"),
+    validate: z.lazy(() => ValidateTaskConfigInputSchema).optional().describe("Required when kind='validate'. ValidateTaskConfig defines the configuration for validate tasks that perform explicit schema and business-rule validation on workflow data. @internal Use validate when you need an explicit validation checkpoint before downstream actions. This is how you distinguish 'the API call succeeded' from 'the data is safe and complete enough to continue.' While switch_case + raise_error can approximate validation, a dedicated validate task makes the intent explicit, the error messages richer, and the execution trace clearer. In the execution viewer (T09), a validate task shows exactly what was checked, what passed, and what failed — visible as a distinct verification step. The task supports two complementary validation modes: - schema: JSON Schema validation for structural correctness - rules: business-rule expressions for domain-specific constraints At least one of schema or rules must be set. Both can be used together for comprehensive validation (schema checks structure, rules check business logic). This cross-field constraint is enforced at runtime validation since buf.validate cannot express it on individual fields. Task output includes the full validation result: { 'valid': true/false, 'errors': [ {'rule': 'critical_needs_rationale', 'message': 'Critical severity requires a rationale'}, {'path': '$.category', 'message': 'must have at least 1 character'} ], 'data': <original input data> } YAML Example (schema + business rules): - check_triage_quality: validate: input: '${ $context.triage }' schema: type: object required: [severity, category, customer_impact] properties: severity: type: string enum: [low, medium, high, critical] category: type: string minLength: 1 customer_impact: type: boolean rules: - name: critical_needs_rationale expression: '${ .severity != 'critical' || (.rationale != null && .rationale != '') }' message: 'Critical severity requires a rationale' - name: customer_impact_needs_severity expression: '${ .customer_impact != true || .severity in ['high', 'critical'] }' message: 'Customer-impacting issues must be high or critical severity' on_fail: VALIDATION_FAIL_BRANCH fallback_task: human_review export: as: '${ . }' YAML Example (schema-only validation with warn policy): - check_payload_shape: validate: input: '${ $context.api_payload }' schema: type: object required: [name, email] properties: name: type: string email: type: string format: email on_fail: VALIDATION_FAIL_WARN export: as: '${ . }'"),
+    wait: z.lazy(() => WaitTaskConfigInputSchema).optional().describe("Required when kind='wait'. WaitTaskConfig defines the configuration for wait tasks that pause workflow execution. Supports both relative durations and absolute timestamps. @internal Implemented via Temporal timers. YAML Examples: Relative duration: - waitForApproval: wait: duration: days: 7 Absolute timestamp: - waitUntilMarketOpen: wait: until: '2026-03-02T09:30:00Z' Reference: zigflow-dsl-pattern-catalog.md - Task Type 8"),
+    export: z.lazy(() => ExportInputSchema).optional().describe("Export configuration (how to save task output to context). Optional - if not set, output is not saved."),
+    flow: z.lazy(() => FlowControlInputSchema).optional().describe("Flow control (which task executes next). Optional - if not set, continues to next task in sequence."),
+    compensate: z.array(z.lazy(() => WorkflowTaskInputSchema)).optional().describe("Compensation tasks to execute if this task needs to be 'undone.' @internal Saga-style compensation for workflows with side effects. When a try_catch block catches an error, it can optionally run the compensation tasks for all already-completed tasks in reverse order. The compensation tasks receive the original task's output in their input context, allowing them to construct the appropriate undo operation (e.g., cancel an API call, delete a created resource, send a reversal notification). Only executed when: 1. The task completed successfully (failed tasks are not compensated) 2. A subsequent task within the same try_catch scope fails 3. The catch block is configured to run compensations YAML Example: try: - create_order: call: http with: method: POST endpoint: { uri: 'https://api.example.com/orders' } body: { ... } compensate: - cancel_order: call: http with: method: DELETE endpoint: { uri: 'https://api.example.com/orders/${ $context.create_order.id }' } export: as: '${ . }' - charge_payment: call: http with: method: POST endpoint: { uri: 'https://api.example.com/payments' } catch: as: error compensate: true do: - log_failure: call: notification with: ... Optional - when empty, this task has no compensation action. @since T17 (Advanced Agentic Orchestration)"),
+}));
+const EnvVarDeclarationInputSchema = z.object({
+    is_secret: z.boolean().optional().describe("Whether the resolved value should be treated as a secret. @internal When true: encrypted at rest, redacted in logs and Temporal history. When false: stored as plaintext, visible in audit logs."),
+    description: z.string().optional().describe("Human-readable description shown in the UI credential form. Should explain what the variable is used for and where to obtain it."),
+    optional: z.boolean().optional().describe("Whether this variable is optional. @internal When false (default): the execution pipeline rejects a run if this variable is missing from the user's environment. When true: a missing value is acceptable (the MCP server or agent degrades gracefully without it)."),
+});
+const WorkflowBudgetInputSchema = z.object({
+    max_cost_micros: z.union([z.number(), z.string()]).optional().describe("Maximum total cost for this workflow execution in micro-USD. 1 USD = 1,000,000 micros. Example: 2000000 = $2.00. When exceeded, the on_exceeded policy is applied. Optional — when 0, no cost limit is enforced."),
+    max_total_tokens: z.union([z.number(), z.string()]).optional().describe("Maximum total tokens (input + output) across all LLM/agent tasks. Optional — when 0, no token limit is enforced."),
+    max_duration_seconds: z.number().optional().describe("Maximum wall-clock duration for the entire workflow execution in seconds. Optional — when 0, no duration limit is enforced (Temporal's own workflow execution timeout still applies)."),
+    on_exceeded: z.string().optional().describe("Policy when any budget limit is exceeded. Allowed values: budget_exceeded_terminate, budget_exceeded_human_review, budget_exceeded_warn."),
+});
+/** Build the fully-formed Workflow proto from the flat MCP apply input. */
+export function workflowInputToProto(input) {
+    const slug = input.slug && input.slug.length > 0 ? input.slug : generateSlug(input.name);
+    const spec = create(WorkflowSpecSchema);
+    if (input.description !== undefined)
+        spec.description = input.description;
+    if (input.document !== undefined)
+        spec.document = workflowDocumentInputToProto(input.document);
+    if (input.tasks !== undefined)
+        spec.tasks = input.tasks.map(workflowTaskInputToProto);
+    if (input.env !== undefined) {
+        for (const [k, v] of Object.entries(input.env))
+            spec.env[k] = envVarDeclarationInputToProto(v);
+    }
+    if (input.budget !== undefined)
+        spec.budget = workflowBudgetInputToProto(input.budget);
+    return Object.assign(create(WorkflowSchema), {
+        apiVersion: "agentic.stigmer.ai/v1",
+        kind: "Workflow",
+        metadata: Object.assign(create(ApiResourceMetadataSchema), {
+            name: input.name,
+            slug,
+            org: input.org,
+            ...(input.visibility !== undefined && { visibility: visibilityFromString(input.visibility) }),
+            ...(input.labels !== undefined && { labels: input.labels }),
+            ...(input.tags !== undefined && { tags: input.tags }),
+        }),
+        spec,
+    });
+}
+function workflowDocumentInputToProto(input) {
+    const result = create(WorkflowDocumentSchema);
+    if (input.dsl !== undefined)
+        result.dsl = input.dsl;
+    if (input.namespace !== undefined)
+        result.namespace = input.namespace;
+    if (input.name !== undefined)
+        result.name = input.name;
+    if (input.version !== undefined)
+        result.version = input.version;
+    if (input.description !== undefined)
+        result.description = input.description;
+    return result;
+}
+function contextManagementConfigInputToProto(input) {
+    const result = create(ContextManagementConfigSchema);
+    if (input.disable_summarization !== undefined)
+        result.disableSummarization = input.disable_summarization;
+    if (input.custom_trigger_threshold !== undefined)
+        result.customTriggerThreshold = input.custom_trigger_threshold;
+    if (input.custom_target_tokens !== undefined)
+        result.customTargetTokens = input.custom_target_tokens;
+    return result;
+}
+function agentExecutionConfigInputToProto(input) {
+    const result = create(AgentExecutionConfigSchema);
+    if (input.model !== undefined)
+        result.model = input.model;
+    if (input.timeout !== undefined)
+        result.timeout = input.timeout;
+    if (input.temperature !== undefined)
+        result.temperature = input.temperature;
+    if (input.context_management !== undefined)
+        result.contextManagement = contextManagementConfigInputToProto(input.context_management);
+    if (input.max_cost_micros !== undefined)
+        result.maxCostMicros = BigInt(input.max_cost_micros);
+    return result;
+}
+function agentCallOutputContractInputToProto(input) {
+    const result = create(AgentCallOutputContractSchema);
+    if (input.schema !== undefined)
+        result.schema = input.schema;
+    result.onInvalid = enumFromString(OnInvalidOutputPolicy, input.on_invalid);
+    if (input.max_retries !== undefined)
+        result.maxRetries = input.max_retries;
+    if (input.fallback_task !== undefined)
+        result.fallbackTask = input.fallback_task;
+    return result;
+}
+function agentCallTaskConfigInputToProto(input) {
+    const result = create(AgentCallTaskConfigSchema);
+    if (input.agent !== undefined)
+        result.agent = input.agent;
+    if (input.org !== undefined)
+        result.org = input.org;
+    if (input.message !== undefined)
+        result.message = input.message;
+    if (input.env !== undefined)
+        result.env = input.env;
+    if (input.config !== undefined)
+        result.config = agentExecutionConfigInputToProto(input.config);
+    if (input.output !== undefined)
+        result.output = agentCallOutputContractInputToProto(input.output);
+    result.harness = enumFromString(Harness, input.harness);
+    return result;
+}
+function callActivityTaskConfigInputToProto(input) {
+    const result = create(CallActivityTaskConfigSchema);
+    if (input.activity !== undefined)
+        result.activity = input.activity;
+    if (input.input !== undefined)
+        result.input = input.input;
+    return result;
+}
+function emitEventInputToProto(input) {
+    const result = create(EmitEventSpecSchema);
+    if (input.type !== undefined)
+        result.type = input.type;
+    if (input.source !== undefined)
+        result.source = input.source;
+    if (input.data !== undefined)
+        result.data = input.data;
+    if (input.subject !== undefined)
+        result.subject = input.subject;
+    return result;
+}
+function emitEventTaskConfigInputToProto(input) {
+    const result = create(EmitEventTaskConfigSchema);
+    if (input.event !== undefined)
+        result.event = emitEventInputToProto(input.event);
+    return result;
+}
+function evalCriterionInputToProto(input) {
+    const result = create(EvalCriterionSchema);
+    if (input.name !== undefined)
+        result.name = input.name;
+    if (input.description !== undefined)
+        result.description = input.description;
+    if (input.weight !== undefined)
+        result.weight = input.weight;
+    return result;
+}
+function evalTaskConfigInputToProto(input) {
+    const result = create(EvalTaskConfigSchema);
+    if (input.model !== undefined)
+        result.model = input.model;
+    if (input.subject !== undefined)
+        result.subject = input.subject;
+    if (input.rubric !== undefined)
+        result.rubric = input.rubric;
+    result.scoringMode = enumFromString(EvalScoringMode, input.scoring_mode);
+    if (input.threshold !== undefined)
+        result.threshold = input.threshold;
+    result.onFail = enumFromString(EvalFailPolicy, input.on_fail);
+    if (input.fallback_task !== undefined)
+        result.fallbackTask = input.fallback_task;
+    if (input.system_prompt !== undefined)
+        result.systemPrompt = input.system_prompt;
+    if (input.criteria !== undefined)
+        result.criteria = input.criteria.map(evalCriterionInputToProto);
+    if (input.max_cost_micros !== undefined)
+        result.maxCostMicros = BigInt(input.max_cost_micros);
+    return result;
+}
+function forTaskConfigInputToProto(input) {
+    const result = create(ForTaskConfigSchema);
+    if (input.each !== undefined)
+        result.each = input.each;
+    if (input.in !== undefined)
+        result.in = input.in;
+    if (input.do !== undefined)
+        result.do = input.do.map(workflowTaskInputToProto);
+    if (input.max_parallelism !== undefined)
+        result.maxParallelism = input.max_parallelism;
+    if (input.batch_size !== undefined)
+        result.batchSize = input.batch_size;
+    result.onError = enumFromString(ForEachErrorPolicy, input.on_error);
+    return result;
+}
+function forkBranchInputToProto(input) {
+    const result = create(ForkBranchSchema);
+    if (input.name !== undefined)
+        result.name = input.name;
+    if (input.do !== undefined)
+        result.do = input.do.map(workflowTaskInputToProto);
+    return result;
+}
+function forkTaskConfigInputToProto(input) {
+    const result = create(ForkTaskConfigSchema);
+    if (input.branches !== undefined)
+        result.branches = input.branches.map(forkBranchInputToProto);
+    if (input.compete !== undefined)
+        result.compete = input.compete;
+    return result;
+}
+function grpcCallTaskConfigInputToProto(input) {
+    const result = create(GrpcCallTaskConfigSchema);
+    if (input.service !== undefined)
+        result.service = input.service;
+    if (input.method !== undefined)
+        result.method = input.method;
+    if (input.request !== undefined)
+        result.request = input.request;
+    return result;
+}
+function httpEndpointInputToProto(input) {
+    const result = create(HttpEndpointSchema);
+    if (input.uri !== undefined)
+        result.uri = input.uri;
+    return result;
+}
+function httpCallTaskConfigInputToProto(input) {
+    const result = create(HttpCallTaskConfigSchema);
+    if (input.method !== undefined)
+        result.method = input.method;
+    if (input.endpoint !== undefined)
+        result.endpoint = httpEndpointInputToProto(input.endpoint);
+    if (input.headers !== undefined)
+        result.headers = input.headers;
+    if (input.body !== undefined)
+        result.body = input.body;
+    if (input.timeout_seconds !== undefined)
+        result.timeoutSeconds = input.timeout_seconds;
+    return result;
+}
+function humanInputOutcomeInputToProto(input) {
+    const result = create(HumanInputOutcomeSchema);
+    if (input.name !== undefined)
+        result.name = input.name;
+    if (input.label !== undefined)
+        result.label = input.label;
+    if (input.then !== undefined)
+        result.then = input.then;
+    return result;
+}
+function humanInputTaskConfigInputToProto(input) {
+    const result = create(HumanInputTaskConfigSchema);
+    if (input.prompt !== undefined)
+        result.prompt = input.prompt;
+    if (input.form_schema !== undefined)
+        result.formSchema = input.form_schema;
+    if (input.outcomes !== undefined)
+        result.outcomes = input.outcomes.map(humanInputOutcomeInputToProto);
+    if (input.approvers !== undefined)
+        result.approvers = input.approvers;
+    if (input.timeout !== undefined)
+        result.timeout = input.timeout;
+    result.onTimeout = enumFromString(HumanInputTimeoutPolicy, input.on_timeout);
+    if (input.notification_channels !== undefined)
+        result.notificationChannels = input.notification_channels;
+    return result;
+}
+function signalInputToProto(input) {
+    const result = create(SignalSpecSchema);
+    if (input.id !== undefined)
+        result.id = input.id;
+    if (input.type !== undefined)
+        result.type = input.type;
+    return result;
+}
+function listenToInputToProto(input) {
+    const result = create(ListenToSchema);
+    if (input.mode !== undefined)
+        result.mode = input.mode;
+    if (input.signals !== undefined)
+        result.signals = input.signals.map(signalInputToProto);
+    return result;
+}
+function listenTaskConfigInputToProto(input) {
+    const result = create(ListenTaskConfigSchema);
+    if (input.to !== undefined)
+        result.to = listenToInputToProto(input.to);
+    return result;
+}
+function llmCallTaskConfigInputToProto(input) {
+    const result = create(LlmCallTaskConfigSchema);
+    if (input.model !== undefined)
+        result.model = input.model;
+    if (input.system_prompt !== undefined)
+        result.systemPrompt = input.system_prompt;
+    if (input.prompt !== undefined)
+        result.prompt = input.prompt;
+    if (input.response_schema !== undefined)
+        result.responseSchema = input.response_schema;
+    if (input.temperature !== undefined)
+        result.temperature = input.temperature;
+    if (input.max_tokens !== undefined)
+        result.maxTokens = input.max_tokens;
+    if (input.timeout !== undefined)
+        result.timeout = input.timeout;
+    result.onInvalid = enumFromString(OnInvalidOutputPolicy, input.on_invalid);
+    if (input.max_retries !== undefined)
+        result.maxRetries = input.max_retries;
+    if (input.fallback_task !== undefined)
+        result.fallbackTask = input.fallback_task;
+    if (input.max_cost_micros !== undefined)
+        result.maxCostMicros = BigInt(input.max_cost_micros);
+    if (input.max_total_tokens !== undefined)
+        result.maxTotalTokens = BigInt(input.max_total_tokens);
+    return result;
+}
+function notificationTaskConfigInputToProto(input) {
+    const result = create(NotificationTaskConfigSchema);
+    if (input.channel !== undefined)
+        result.channel = input.channel;
+    if (input.recipients !== undefined)
+        result.recipients = input.recipients;
+    if (input.subject !== undefined)
+        result.subject = input.subject;
+    if (input.body !== undefined)
+        result.body = input.body;
+    if (input.template !== undefined)
+        result.template = input.template;
+    if (input.metadata !== undefined)
+        result.metadata = input.metadata;
+    return result;
+}
+function raiseTaskConfigInputToProto(input) {
+    const result = create(RaiseTaskConfigSchema);
+    if (input.error !== undefined)
+        result.error = input.error;
+    if (input.message !== undefined)
+        result.message = input.message;
+    return result;
+}
+function runTaskConfigInputToProto(input) {
+    const result = create(RunTaskConfigSchema);
+    if (input.workflow !== undefined)
+        result.workflow = input.workflow;
+    if (input.input !== undefined)
+        result.input = input.input;
+    return result;
+}
+function setTaskConfigInputToProto(input) {
+    const result = create(SetTaskConfigSchema);
+    if (input.variables !== undefined)
+        result.variables = input.variables;
+    return result;
+}
+function switchCaseInputToProto(input) {
+    const result = create(SwitchCaseSchema);
+    if (input.name !== undefined)
+        result.name = input.name;
+    if (input.when !== undefined)
+        result.when = input.when;
+    if (input.then !== undefined)
+        result.then = input.then;
+    return result;
+}
+function switchTaskConfigInputToProto(input) {
+    const result = create(SwitchTaskConfigSchema);
+    if (input.cases !== undefined)
+        result.cases = input.cases.map(switchCaseInputToProto);
+    return result;
+}
+function transformTaskConfigInputToProto(input) {
+    const result = create(TransformTaskConfigSchema);
+    result.engine = enumFromString(TransformEngine, input.engine);
+    if (input.expression !== undefined)
+        result.expression = input.expression;
+    if (input.input !== undefined)
+        result.input = input.input;
+    return result;
+}
+function catchBlockInputToProto(input) {
+    const result = create(CatchBlockSchema);
+    if (input.as !== undefined)
+        result.as = input.as;
+    if (input.do !== undefined)
+        result.do = input.do.map(workflowTaskInputToProto);
+    if (input.compensate !== undefined)
+        result.compensate = input.compensate;
+    return result;
+}
+function tryTaskConfigInputToProto(input) {
+    const result = create(TryTaskConfigSchema);
+    if (input.try !== undefined)
+        result.try = input.try.map(workflowTaskInputToProto);
+    if (input.catch !== undefined)
+        result.catch = catchBlockInputToProto(input.catch);
+    return result;
+}
+function validationRuleInputToProto(input) {
+    const result = create(ValidationRuleSchema);
+    if (input.name !== undefined)
+        result.name = input.name;
+    if (input.expression !== undefined)
+        result.expression = input.expression;
+    if (input.message !== undefined)
+        result.message = input.message;
+    return result;
+}
+function validateTaskConfigInputToProto(input) {
+    const result = create(ValidateTaskConfigSchema);
+    if (input.input !== undefined)
+        result.input = input.input;
+    if (input.schema !== undefined)
+        result.schema = input.schema;
+    if (input.rules !== undefined)
+        result.rules = input.rules.map(validationRuleInputToProto);
+    result.onFail = enumFromString(ValidationFailPolicy, input.on_fail);
+    if (input.fallback_task !== undefined)
+        result.fallbackTask = input.fallback_task;
+    return result;
+}
+function durationInputToProto(input) {
+    const result = create(DurationSchema);
+    if (input.days !== undefined)
+        result.days = input.days;
+    if (input.hours !== undefined)
+        result.hours = input.hours;
+    if (input.minutes !== undefined)
+        result.minutes = input.minutes;
+    if (input.seconds !== undefined)
+        result.seconds = input.seconds;
+    if (input.milliseconds !== undefined)
+        result.milliseconds = input.milliseconds;
+    return result;
+}
+function waitTaskConfigInputToProto(input) {
+    const result = create(WaitTaskConfigSchema);
+    if (input.duration !== undefined)
+        result.waitType = { case: "duration", value: durationInputToProto(input.duration) };
+    if (input.until !== undefined)
+        result.waitType = { case: "until", value: toTimestamp(input.until) };
+    return result;
+}
+function exportInputToProto(input) {
+    const result = create(ExportSchema);
+    if (input.as !== undefined)
+        result.as = input.as;
+    return result;
+}
+function flowControlInputToProto(input) {
+    const result = create(FlowControlSchema);
+    if (input.then !== undefined)
+        result.then = input.then;
+    return result;
+}
+function workflowTaskInputToProto(input) {
+    const result = create(WorkflowTaskSchema);
+    if (input.name !== undefined)
+        result.name = input.name;
+    result.kind = enumFromString(WorkflowTaskKind, input.kind);
+    if (input.export !== undefined)
+        result.export = exportInputToProto(input.export);
+    if (input.flow !== undefined)
+        result.flow = flowControlInputToProto(input.flow);
+    if (input.compensate !== undefined)
+        result.compensate = input.compensate.map(workflowTaskInputToProto);
+    switch (input.kind) {
+        case "agent_call":
+            if (input.agent_call !== undefined)
+                result.taskConfig = toJson(AgentCallTaskConfigSchema, agentCallTaskConfigInputToProto(input.agent_call));
+            break;
+        case "activity_call":
+            if (input.activity_call !== undefined)
+                result.taskConfig = toJson(CallActivityTaskConfigSchema, callActivityTaskConfigInputToProto(input.activity_call));
+            break;
+        case "emit_event":
+            if (input.emit_event !== undefined)
+                result.taskConfig = toJson(EmitEventTaskConfigSchema, emitEventTaskConfigInputToProto(input.emit_event));
+            break;
+        case "eval":
+            if (input.eval !== undefined)
+                result.taskConfig = toJson(EvalTaskConfigSchema, evalTaskConfigInputToProto(input.eval));
+            break;
+        case "for_each":
+            if (input.for_each !== undefined)
+                result.taskConfig = toJson(ForTaskConfigSchema, forTaskConfigInputToProto(input.for_each));
+            break;
+        case "fork":
+            if (input.fork !== undefined)
+                result.taskConfig = toJson(ForkTaskConfigSchema, forkTaskConfigInputToProto(input.fork));
+            break;
+        case "grpc_call":
+            if (input.grpc_call !== undefined)
+                result.taskConfig = toJson(GrpcCallTaskConfigSchema, grpcCallTaskConfigInputToProto(input.grpc_call));
+            break;
+        case "http_call":
+            if (input.http_call !== undefined)
+                result.taskConfig = toJson(HttpCallTaskConfigSchema, httpCallTaskConfigInputToProto(input.http_call));
+            break;
+        case "human_input":
+            if (input.human_input !== undefined)
+                result.taskConfig = toJson(HumanInputTaskConfigSchema, humanInputTaskConfigInputToProto(input.human_input));
+            break;
+        case "listen":
+            if (input.listen !== undefined)
+                result.taskConfig = toJson(ListenTaskConfigSchema, listenTaskConfigInputToProto(input.listen));
+            break;
+        case "llm_call":
+            if (input.llm_call !== undefined)
+                result.taskConfig = toJson(LlmCallTaskConfigSchema, llmCallTaskConfigInputToProto(input.llm_call));
+            break;
+        case "notification":
+            if (input.notification !== undefined)
+                result.taskConfig = toJson(NotificationTaskConfigSchema, notificationTaskConfigInputToProto(input.notification));
+            break;
+        case "raise_error":
+            if (input.raise_error !== undefined)
+                result.taskConfig = toJson(RaiseTaskConfigSchema, raiseTaskConfigInputToProto(input.raise_error));
+            break;
+        case "run_workflow":
+            if (input.run_workflow !== undefined)
+                result.taskConfig = toJson(RunTaskConfigSchema, runTaskConfigInputToProto(input.run_workflow));
+            break;
+        case "set_vars":
+            if (input.set_vars !== undefined)
+                result.taskConfig = toJson(SetTaskConfigSchema, setTaskConfigInputToProto(input.set_vars));
+            break;
+        case "switch_case":
+            if (input.switch_case !== undefined)
+                result.taskConfig = toJson(SwitchTaskConfigSchema, switchTaskConfigInputToProto(input.switch_case));
+            break;
+        case "transform":
+            if (input.transform !== undefined)
+                result.taskConfig = toJson(TransformTaskConfigSchema, transformTaskConfigInputToProto(input.transform));
+            break;
+        case "try_catch":
+            if (input.try_catch !== undefined)
+                result.taskConfig = toJson(TryTaskConfigSchema, tryTaskConfigInputToProto(input.try_catch));
+            break;
+        case "validate":
+            if (input.validate !== undefined)
+                result.taskConfig = toJson(ValidateTaskConfigSchema, validateTaskConfigInputToProto(input.validate));
+            break;
+        case "wait":
+            if (input.wait !== undefined)
+                result.taskConfig = toJson(WaitTaskConfigSchema, waitTaskConfigInputToProto(input.wait));
+            break;
+        default:
+            if (input.kind !== undefined && input.kind !== "") {
+                throw new Error(`unknown task kind: ${input.kind}`);
+            }
+    }
+    return result;
+}
+function envVarDeclarationInputToProto(input) {
+    const result = create(EnvVarDeclarationSchema);
+    if (input.is_secret !== undefined)
+        result.isSecret = input.is_secret;
+    if (input.description !== undefined)
+        result.description = input.description;
+    if (input.optional !== undefined)
+        result.optional = input.optional;
+    return result;
+}
+function workflowBudgetInputToProto(input) {
+    const result = create(WorkflowBudgetSchema);
+    if (input.max_cost_micros !== undefined)
+        result.maxCostMicros = BigInt(input.max_cost_micros);
+    if (input.max_total_tokens !== undefined)
+        result.maxTotalTokens = BigInt(input.max_total_tokens);
+    if (input.max_duration_seconds !== undefined)
+        result.maxDurationSeconds = input.max_duration_seconds;
+    result.onExceeded = enumFromString(BudgetExceededPolicy, input.on_exceeded);
+    return result;
+}
+//# sourceMappingURL=workflow.js.map