@shipfox/api-agent-access-dto 21.0.0 → 21.2.0

package/dist/schemas/workflow-diagnostics.d.ts

@@ -0,0 +1,862 @@
+import { z } from 'zod';
+/** Smaller per-value allowance used by Agent Access before the common response ceiling. */
+export declare const AGENT_ACCESS_WORKFLOW_DIAGNOSTIC_VALUE_MAX_BYTES: number;
+/** Source is text, but it still needs enough room to be useful in a diagnostic response. */
+export declare const AGENT_ACCESS_WORKFLOW_SOURCE_MAX_BYTES: number;
+export declare const agentAccessWorkflowDiagnosticFieldSchema: z.ZodEnum<{
+    authored_config: "authored_config";
+    condition: "condition";
+    config: "config";
+    error: "error";
+    evaluation_trace: "evaluation_trace";
+    execution_evaluation_trace: "execution_evaluation_trace";
+    execution_outputs: "execution_outputs";
+    gate_result: "gate_result";
+    job_evaluation_trace: "job_evaluation_trace";
+    job_outputs: "job_outputs";
+    output: "output";
+    outputs: "outputs";
+    response: "response";
+    restart_feedback: "restart_feedback";
+    trigger_events: "trigger_events";
+}>;
+export type AgentAccessWorkflowDiagnosticFieldDto = z.infer<typeof agentAccessWorkflowDiagnosticFieldSchema>;
+export declare const agentAccessOversizedFieldSchema: z.ZodObject<{
+    field: z.ZodEnum<{
+        authored_config: "authored_config";
+        condition: "condition";
+        config: "config";
+        error: "error";
+        evaluation_trace: "evaluation_trace";
+        execution_evaluation_trace: "execution_evaluation_trace";
+        execution_outputs: "execution_outputs";
+        gate_result: "gate_result";
+        job_evaluation_trace: "job_evaluation_trace";
+        job_outputs: "job_outputs";
+        output: "output";
+        outputs: "outputs";
+        response: "response";
+        restart_feedback: "restart_feedback";
+        trigger_events: "trigger_events";
+    }>;
+    stored_bytes: z.ZodNumber;
+    reason: z.ZodEnum<{
+        legacy_value_exceeds_inline_limit: "legacy_value_exceeds_inline_limit";
+        value_exceeds_inline_limit: "value_exceeds_inline_limit";
+        value_truncated_at_write_limit: "value_truncated_at_write_limit";
+    }>;
+}, z.core.$strict>;
+export type AgentAccessOversizedFieldDto = z.infer<typeof agentAccessOversizedFieldSchema>;
+export declare const getWorkflowRunSourceInputSchema: z.ZodObject<{
+    run_id: z.ZodString;
+    attempt: z.ZodNumber;
+}, z.core.$strict>;
+export declare const getWorkflowExecutionContextInputSchema: z.ZodObject<{
+    job_id: z.ZodString;
+    execution_id: z.ZodString;
+}, z.core.$strict>;
+export declare const getStepAttemptInputSchema: z.ZodObject<{
+    step_id: z.ZodString;
+    attempt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const listWorkflowRunJobExplanationsInputSchema: z.ZodObject<{
+    run_id: z.ZodString;
+    attempt: z.ZodNumber;
+    limit: z.ZodDefault<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type GetWorkflowRunSourceInputDto = z.output<typeof getWorkflowRunSourceInputSchema>;
+export type GetWorkflowExecutionContextInputDto = z.output<typeof getWorkflowExecutionContextInputSchema>;
+export type GetStepAttemptInputDto = z.output<typeof getStepAttemptInputSchema>;
+export type ListWorkflowRunJobExplanationsInputDto = z.output<typeof listWorkflowRunJobExplanationsInputSchema>;
+export declare const getWorkflowRunSourceResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"available">;
+    workflow_run_id: z.ZodString;
+    workflow_run_attempt: z.ZodNumber;
+    source_snapshot: z.ZodObject<{
+        content: z.ZodString;
+        format: z.ZodLiteral<"yaml">;
+    }, z.core.$strict>;
+    source_snapshot_truncated: z.ZodOptional<z.ZodLiteral<true>>;
+    source_snapshot_total_bytes: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"unavailable">;
+    workflow_run_id: z.ZodString;
+    workflow_run_attempt: z.ZodNumber;
+    reason: z.ZodEnum<{
+        legacy_snapshot_too_large: "legacy_snapshot_too_large";
+        pre_snapshot_run: "pre_snapshot_run";
+        temporary_run: "temporary_run";
+    }>;
+}, z.core.$strict>], "kind">;
+export type GetWorkflowRunSourceResultDto = z.infer<typeof getWorkflowRunSourceResultSchema>;
+export declare const getWorkflowExecutionContextResultSchema: z.ZodObject<{
+    workflow_run_id: z.ZodString;
+    workflow_run_attempt: z.ZodNumber;
+    job_id: z.ZodString;
+    job_execution_id: z.ZodString;
+    job_runner: z.ZodNullable<z.ZodArray<z.ZodString>>;
+    execution_runner: z.ZodNullable<z.ZodArray<z.ZodString>>;
+    job_outputs: z.ZodNullable<z.ZodUnknown>;
+    execution_outputs: z.ZodNullable<z.ZodUnknown>;
+    trigger_events: z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        event: z.ZodString;
+        delivery_id: z.ZodString;
+        received_at: z.ZodString;
+        project: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strict>>;
+        repository: z.ZodNullable<z.ZodString>;
+        ref: z.ZodNullable<z.ZodString>;
+        commit: z.ZodNullable<z.ZodString>;
+        data: z.ZodUnknown;
+    }, z.core.$strict>>;
+    trigger_events_truncated: z.ZodOptional<z.ZodLiteral<true>>;
+    trigger_events_total_count: z.ZodOptional<z.ZodNumber>;
+    job_evaluation_trace: z.ZodNullable<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        expression: z.ZodString;
+        roots: z.ZodArray<z.ZodString>;
+        fill_target: z.ZodString;
+        evaluated_at: z.ZodString;
+        field: z.ZodString;
+        value: z.ZodOptional<z.ZodString>;
+        truncated: z.ZodOptional<z.ZodBoolean>;
+        expr_truncated: z.ZodOptional<z.ZodBoolean>;
+        reference: z.ZodOptional<z.ZodBoolean>;
+        degraded: z.ZodOptional<z.ZodBoolean>;
+        env_key: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        truncated: z.ZodLiteral<true>;
+        dropped: z.ZodNumber;
+    }, z.core.$strict>]>>>;
+    execution_evaluation_trace: z.ZodNullable<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        expression: z.ZodString;
+        roots: z.ZodArray<z.ZodString>;
+        fill_target: z.ZodString;
+        evaluated_at: z.ZodString;
+        field: z.ZodString;
+        value: z.ZodOptional<z.ZodString>;
+        truncated: z.ZodOptional<z.ZodBoolean>;
+        expr_truncated: z.ZodOptional<z.ZodBoolean>;
+        reference: z.ZodOptional<z.ZodBoolean>;
+        degraded: z.ZodOptional<z.ZodBoolean>;
+        env_key: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        truncated: z.ZodLiteral<true>;
+        dropped: z.ZodNumber;
+    }, z.core.$strict>]>>>;
+    condition: z.ZodNullable<z.ZodString>;
+    condition_truncated: z.ZodOptional<z.ZodLiteral<true>>;
+    condition_total_bytes: z.ZodOptional<z.ZodNumber>;
+    oversized_fields: z.ZodArray<z.ZodObject<{
+        field: z.ZodEnum<{
+            authored_config: "authored_config";
+            condition: "condition";
+            config: "config";
+            error: "error";
+            evaluation_trace: "evaluation_trace";
+            execution_evaluation_trace: "execution_evaluation_trace";
+            execution_outputs: "execution_outputs";
+            gate_result: "gate_result";
+            job_evaluation_trace: "job_evaluation_trace";
+            job_outputs: "job_outputs";
+            output: "output";
+            outputs: "outputs";
+            response: "response";
+            restart_feedback: "restart_feedback";
+            trigger_events: "trigger_events";
+        }>;
+        stored_bytes: z.ZodNumber;
+        reason: z.ZodEnum<{
+            legacy_value_exceeds_inline_limit: "legacy_value_exceeds_inline_limit";
+            value_exceeds_inline_limit: "value_exceeds_inline_limit";
+            value_truncated_at_write_limit: "value_truncated_at_write_limit";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type GetWorkflowExecutionContextResultDto = z.infer<typeof getWorkflowExecutionContextResultSchema>;
+export declare const getStepAttemptResultSchema: z.ZodObject<{
+    workflow_run_id: z.ZodString;
+    workflow_run_attempt: z.ZodNumber;
+    job_id: z.ZodString;
+    job_execution_id: z.ZodString;
+    step_id: z.ZodString;
+    step_attempt_id: z.ZodString;
+    attempt: z.ZodNumber;
+    authored_config: z.ZodNullable<z.ZodUnknown>;
+    config: z.ZodNullable<z.ZodUnknown>;
+    session: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        key: z.ZodString;
+        mode: z.ZodEnum<{
+            fork: "fork";
+            resume: "resume";
+        }>;
+        segment: z.ZodNumber;
+    }, z.core.$strict>>;
+    evaluation_trace: z.ZodNullable<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        expression: z.ZodString;
+        roots: z.ZodArray<z.ZodString>;
+        fill_target: z.ZodString;
+        evaluated_at: z.ZodString;
+        field: z.ZodString;
+        value: z.ZodOptional<z.ZodString>;
+        truncated: z.ZodOptional<z.ZodBoolean>;
+        expr_truncated: z.ZodOptional<z.ZodBoolean>;
+        reference: z.ZodOptional<z.ZodBoolean>;
+        degraded: z.ZodOptional<z.ZodBoolean>;
+        env_key: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        truncated: z.ZodLiteral<true>;
+        dropped: z.ZodNumber;
+    }, z.core.$strict>]>>>;
+    output: z.ZodNullable<z.ZodUnknown>;
+    outputs: z.ZodNullable<z.ZodUnknown>;
+    response: z.ZodNullable<z.ZodString>;
+    error: z.ZodNullable<z.ZodObject<{
+        message: z.ZodString;
+        code: z.ZodOptional<z.ZodString>;
+        managed_provider_id: z.ZodOptional<z.ZodString>;
+        exit_code: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        signal: z.ZodOptional<z.ZodString>;
+        reason: z.ZodOptional<z.ZodEnum<{
+            agent_config_invalid: "agent_config_invalid";
+            agent_harness_unavailable: "agent_harness_unavailable";
+            agent_inference_credentials_unavailable: "agent_inference_credentials_unavailable";
+            agent_invocation_failed: "agent_invocation_failed";
+            agent_session_harness_mismatch: "agent_session_harness_mismatch";
+            agent_session_held: "agent_session_held";
+            agent_session_key_invalid: "agent_session_key_invalid";
+            agent_session_unavailable: "agent_session_unavailable";
+            checkout_auth_failed: "checkout_auth_failed";
+            checkout_destination_occupied: "checkout_destination_occupied";
+            checkout_failed: "checkout_failed";
+            checkout_path_invalid: "checkout_path_invalid";
+            checkout_unavailable: "checkout_unavailable";
+            config_unresolvable: "config_unresolvable";
+            diagnostic_too_large: "diagnostic_too_large";
+            execution_payload_too_large: "execution_payload_too_large";
+            git_unavailable: "git_unavailable";
+            invocation_interrupted: "invocation_interrupted";
+            output_invalid: "output_invalid";
+            setup_aborted: "setup_aborted";
+            step_result_too_large: "step_result_too_large";
+            tool_config_invalid: "tool_config_invalid";
+            tool_error: "tool_error";
+            workspace_prep_failed: "workspace_prep_failed";
+        }>>;
+        field: z.ZodOptional<z.ZodString>;
+        source: z.ZodOptional<z.ZodString>;
+        agent_config_issue: z.ZodOptional<z.ZodEnum<{
+            credentials_invalid: "credentials_invalid";
+            model_unavailable: "model_unavailable";
+            provider_not_configured: "provider_not_configured";
+            provider_unsupported: "provider_unsupported";
+            step_config_invalid: "step_config_invalid";
+        }>>;
+        category: z.ZodOptional<z.ZodEnum<{
+            setup: "setup";
+            user: "user";
+        }>>;
+        retryable: z.ZodOptional<z.ZodBoolean>;
+        limit_bytes: z.ZodOptional<z.ZodNumber>;
+        measured_bytes: z.ZodOptional<z.ZodNumber>;
+        overshoot_bytes: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    gate_result: z.ZodNullable<z.ZodObject<{
+        kind: z.ZodEnum<{
+            evaluation_error: "evaluation_error";
+            failed: "failed";
+            none: "none";
+            not_evaluated: "not_evaluated";
+            passed: "passed";
+            uncheckable: "uncheckable";
+            unknown: "unknown";
+        }>;
+        passed: z.ZodOptional<z.ZodBoolean>;
+        source: z.ZodOptional<z.ZodString>;
+        exit_code: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        uncheckable: z.ZodOptional<z.ZodBoolean>;
+        reason: z.ZodOptional<z.ZodString>;
+        data: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strict>>;
+    invocations: z.ZodArray<z.ZodObject<{
+        call_index: z.ZodNumber;
+        started_at: z.ZodString;
+        finished_at: z.ZodOptional<z.ZodString>;
+        outcome: z.ZodOptional<z.ZodString>;
+        error_code: z.ZodOptional<z.ZodString>;
+        duration_ms: z.ZodOptional<z.ZodNumber>;
+        next_due_at: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    restart_feedback: z.ZodNullable<z.ZodString>;
+    restart_feedback_truncated: z.ZodOptional<z.ZodLiteral<true>>;
+    restart_feedback_total_bytes: z.ZodOptional<z.ZodNumber>;
+    response_text_truncated: z.ZodOptional<z.ZodLiteral<true>>;
+    response_text_total_bytes: z.ZodOptional<z.ZodNumber>;
+    oversized_fields: z.ZodArray<z.ZodObject<{
+        field: z.ZodEnum<{
+            authored_config: "authored_config";
+            condition: "condition";
+            config: "config";
+            error: "error";
+            evaluation_trace: "evaluation_trace";
+            execution_evaluation_trace: "execution_evaluation_trace";
+            execution_outputs: "execution_outputs";
+            gate_result: "gate_result";
+            job_evaluation_trace: "job_evaluation_trace";
+            job_outputs: "job_outputs";
+            output: "output";
+            outputs: "outputs";
+            response: "response";
+            restart_feedback: "restart_feedback";
+            trigger_events: "trigger_events";
+        }>;
+        stored_bytes: z.ZodNumber;
+        reason: z.ZodEnum<{
+            legacy_value_exceeds_inline_limit: "legacy_value_exceeds_inline_limit";
+            value_exceeds_inline_limit: "value_exceeds_inline_limit";
+            value_truncated_at_write_limit: "value_truncated_at_write_limit";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type GetStepAttemptResultDto = z.infer<typeof getStepAttemptResultSchema>;
+export declare const listWorkflowRunJobExplanationsResultSchema: z.ZodObject<{
+    workflow_run_id: z.ZodString;
+    workflow_run_attempt: z.ZodNumber;
+    explanations: z.ZodArray<z.ZodObject<{
+        job_id: z.ZodString;
+        job_label: z.ZodString;
+        job_position: z.ZodNumber;
+        status: z.ZodEnum<{
+            failed: "failed";
+            skipped: "skipped";
+        }>;
+        status_reason: z.ZodNullable<z.ZodString>;
+        evaluation_trace: z.ZodNullable<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            expression: z.ZodString;
+            roots: z.ZodArray<z.ZodString>;
+            fill_target: z.ZodString;
+            evaluated_at: z.ZodString;
+            field: z.ZodString;
+            value: z.ZodOptional<z.ZodString>;
+            truncated: z.ZodOptional<z.ZodBoolean>;
+            expr_truncated: z.ZodOptional<z.ZodBoolean>;
+            reference: z.ZodOptional<z.ZodBoolean>;
+            degraded: z.ZodOptional<z.ZodBoolean>;
+            env_key: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            truncated: z.ZodLiteral<true>;
+            dropped: z.ZodNumber;
+        }, z.core.$strict>]>>>;
+    }, z.core.$strict>>;
+    next_cursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type ListWorkflowRunJobExplanationsResultDto = z.infer<typeof listWorkflowRunJobExplanationsResultSchema>;
+export declare const getWorkflowRunSourceInputJsonSchema: {
+    readonly type: 'object';
+    readonly properties: {
+        readonly run_id: {
+            readonly type: 'string';
+            readonly format: 'uuid';
+        };
+        readonly attempt: {
+            readonly type: 'integer';
+            readonly minimum: 1;
+            readonly maximum: 2147483647;
+        };
+    };
+    readonly required: readonly ["run_id", "attempt"];
+    readonly additionalProperties: false;
+};
+export declare const getWorkflowExecutionContextInputJsonSchema: {
+    readonly type: 'object';
+    readonly properties: {
+        readonly job_id: {
+            readonly type: 'string';
+            readonly format: 'uuid';
+        };
+        readonly execution_id: {
+            readonly type: 'string';
+            readonly format: 'uuid';
+        };
+    };
+    readonly required: readonly ["job_id", "execution_id"];
+    readonly additionalProperties: false;
+};
+export declare const getStepAttemptInputJsonSchema: {
+    readonly type: 'object';
+    readonly properties: {
+        readonly step_id: {
+            readonly type: 'string';
+            readonly format: 'uuid';
+        };
+        readonly attempt: {
+            readonly type: 'integer';
+            readonly minimum: 1;
+            readonly maximum: 2147483647;
+        };
+    };
+    readonly required: readonly ["step_id"];
+    readonly additionalProperties: false;
+};
+export declare const listWorkflowRunJobExplanationsInputJsonSchema: {
+    readonly type: 'object';
+    readonly properties: {
+        readonly run_id: {
+            readonly type: 'string';
+            readonly format: 'uuid';
+        };
+        readonly attempt: {
+            readonly type: 'integer';
+            readonly minimum: 1;
+            readonly maximum: 2147483647;
+        };
+        readonly limit: {
+            readonly type: 'integer';
+            readonly minimum: 1;
+            readonly maximum: 100;
+            readonly default: 100;
+        };
+        readonly cursor: {
+            readonly type: 'string';
+            readonly minLength: 1;
+        };
+    };
+    readonly required: readonly ["run_id", "attempt"];
+    readonly additionalProperties: false;
+};
+export declare const getWorkflowRunSourceResultJsonSchema: {
+    readonly type: 'object';
+    readonly properties: {
+        readonly kind: {
+            readonly type: 'string';
+            readonly enum: readonly ["available", "unavailable"];
+        };
+        readonly workflow_run_id: {
+            readonly type: 'string';
+            readonly format: 'uuid';
+        };
+        readonly workflow_run_attempt: {
+            readonly type: 'integer';
+            readonly minimum: 1;
+            readonly maximum: 2147483647;
+        };
+        readonly source_snapshot: {
+            readonly type: 'object';
+            readonly properties: {
+                readonly content: {
+                    readonly type: 'string';
+                    readonly maxLength: number;
+                };
+                readonly format: {
+                    readonly const: 'yaml';
+                };
+            };
+            readonly required: readonly ['content', 'format'];
+            readonly additionalProperties: false;
+        };
+        readonly source_snapshot_truncated: {
+            readonly const: true;
+        };
+        readonly source_snapshot_total_bytes: {
+            readonly type: 'integer';
+            readonly minimum: 0;
+        };
+        readonly reason: {
+            readonly type: 'string';
+            readonly enum: readonly ["temporary_run", "pre_snapshot_run", "legacy_snapshot_too_large"];
+        };
+    };
+    readonly required: readonly ["kind", "workflow_run_id", "workflow_run_attempt"];
+    readonly additionalProperties: false;
+    readonly oneOf: readonly [{
+        readonly properties: {
+            readonly kind: {
+                readonly const: 'available';
+            };
+        };
+        readonly required: readonly ["source_snapshot"];
+        readonly not: {
+            readonly required: readonly ["reason"];
+        };
+    }, {
+        readonly properties: {
+            readonly kind: {
+                readonly const: 'unavailable';
+            };
+        };
+        readonly required: readonly ["reason"];
+        readonly not: {
+            readonly required: readonly ["source_snapshot"];
+        };
+    }];
+};
+export declare const getWorkflowExecutionContextResultJsonSchema: {
+    readonly type: 'object';
+    readonly properties: {
+        readonly workflow_run_id: {
+            readonly type: 'string';
+            readonly format: 'uuid';
+        };
+        readonly workflow_run_attempt: {
+            readonly type: 'integer';
+            readonly minimum: 1;
+            readonly maximum: 2147483647;
+        };
+        readonly job_id: {
+            readonly type: 'string';
+            readonly format: 'uuid';
+        };
+        readonly job_execution_id: {
+            readonly type: 'string';
+            readonly format: 'uuid';
+        };
+        readonly job_runner: {
+            readonly anyOf: readonly [Record<string, unknown>, {
+                readonly type: 'null';
+            }];
+        };
+        readonly execution_runner: {
+            readonly anyOf: readonly [Record<string, unknown>, {
+                readonly type: 'null';
+            }];
+        };
+        readonly job_outputs: {
+            readonly anyOf: readonly [Record<string, unknown>, {
+                readonly type: 'null';
+            }];
+        };
+        readonly execution_outputs: {
+            readonly anyOf: readonly [Record<string, unknown>, {
+                readonly type: 'null';
+            }];
+        };
+        readonly trigger_events: {
+            readonly type: 'array';
+            readonly maxItems: 100;
+            readonly items: {
+                readonly type: 'object';
+                readonly properties: {
+                    readonly source: {
+                        readonly type: 'string';
+                        readonly maxLength: 512;
+                    };
+                    readonly event: {
+                        readonly type: 'string';
+                        readonly maxLength: 512;
+                    };
+                    readonly delivery_id: {
+                        readonly type: 'string';
+                        readonly maxLength: 512;
+                    };
+                    readonly received_at: {
+                        readonly type: 'string';
+                        readonly format: 'date-time';
+                    };
+                    readonly project: {
+                        readonly anyOf: readonly [Record<string, unknown>, {
+                            readonly type: 'null';
+                        }];
+                    };
+                    readonly repository: {
+                        readonly anyOf: readonly [Record<string, unknown>, {
+                            readonly type: 'null';
+                        }];
+                    };
+                    readonly ref: {
+                        readonly anyOf: readonly [Record<string, unknown>, {
+                            readonly type: 'null';
+                        }];
+                    };
+                    readonly commit: {
+                        readonly anyOf: readonly [Record<string, unknown>, {
+                            readonly type: 'null';
+                        }];
+                    };
+                    readonly data: {};
+                };
+                readonly required: readonly ['source', 'event', 'delivery_id', 'received_at', 'project', 'repository', 'ref', 'commit', 'data'];
+                readonly additionalProperties: false;
+            };
+        };
+        readonly trigger_events_truncated: {
+            readonly const: true;
+        };
+        readonly trigger_events_total_count: {
+            readonly type: 'integer';
+            readonly minimum: 0;
+        };
+        readonly job_evaluation_trace: {
+            readonly anyOf: readonly [Record<string, unknown>, {
+                readonly type: 'null';
+            }];
+        };
+        readonly execution_evaluation_trace: {
+            readonly anyOf: readonly [Record<string, unknown>, {
+                readonly type: 'null';
+            }];
+        };
+        readonly condition: {
+            readonly anyOf: readonly [Record<string, unknown>, {
+                readonly type: 'null';
+            }];
+        };
+        readonly condition_truncated: {
+            readonly const: true;
+        };
+        readonly condition_total_bytes: {
+            readonly type: 'integer';
+            readonly minimum: 0;
+        };
+        readonly oversized_fields: {
+            readonly type: 'array';
+            readonly maxItems: 100;
+            readonly items: {
+                readonly type: 'object';
+                readonly properties: {
+                    readonly field: {
+                        readonly type: 'string';
+                        readonly enum: readonly ["authored_config", "config", "evaluation_trace", "output", "outputs", "response", "error", "gate_result", "restart_feedback", "job_outputs", "execution_outputs", "job_evaluation_trace", "execution_evaluation_trace", "condition", "trigger_events"];
+                    };
+                    readonly stored_bytes: {
+                        readonly type: 'integer';
+                        readonly minimum: 0;
+                    };
+                    readonly reason: {
+                        readonly type: 'string';
+                        readonly enum: ("legacy_value_exceeds_inline_limit" | "value_exceeds_inline_limit" | "value_truncated_at_write_limit")[];
+                    };
+                };
+                readonly required: readonly ['field', 'stored_bytes', 'reason'];
+                readonly additionalProperties: false;
+            };
+        };
+    };
+    readonly required: readonly ["workflow_run_id", "workflow_run_attempt", "job_id", "job_execution_id", "job_runner", "execution_runner", "job_outputs", "execution_outputs", "trigger_events", "job_evaluation_trace", "execution_evaluation_trace", "condition", "oversized_fields"];
+    readonly additionalProperties: false;
+};
+export declare const getStepAttemptResultJsonSchema: {
+    readonly type: 'object';
+    readonly properties: {
+        readonly workflow_run_id: {
+            readonly type: 'string';
+            readonly format: 'uuid';
+        };
+        readonly workflow_run_attempt: {
+            readonly type: 'integer';
+            readonly minimum: 1;
+            readonly maximum: 2147483647;
+        };
+        readonly job_id: {
+            readonly type: 'string';
+            readonly format: 'uuid';
+        };
+        readonly job_execution_id: {
+            readonly type: 'string';
+            readonly format: 'uuid';
+        };
+        readonly step_id: {
+            readonly type: 'string';
+            readonly format: 'uuid';
+        };
+        readonly step_attempt_id: {
+            readonly type: 'string';
+            readonly format: 'uuid';
+        };
+        readonly attempt: {
+            readonly type: 'integer';
+            readonly minimum: 1;
+            readonly maximum: 2147483647;
+        };
+        readonly authored_config: {
+            readonly anyOf: readonly [Record<string, unknown>, {
+                readonly type: 'null';
+            }];
+        };
+        readonly config: {
+            readonly anyOf: readonly [Record<string, unknown>, {
+                readonly type: 'null';
+            }];
+        };
+        readonly session: {
+            readonly anyOf: readonly [Record<string, unknown>, {
+                readonly type: 'null';
+            }];
+        };
+        readonly evaluation_trace: {
+            readonly anyOf: readonly [Record<string, unknown>, {
+                readonly type: 'null';
+            }];
+        };
+        readonly output: {
+            readonly anyOf: readonly [Record<string, unknown>, {
+                readonly type: 'null';
+            }];
+        };
+        readonly outputs: {
+            readonly anyOf: readonly [Record<string, unknown>, {
+                readonly type: 'null';
+            }];
+        };
+        readonly response: {
+            readonly anyOf: readonly [Record<string, unknown>, {
+                readonly type: 'null';
+            }];
+        };
+        readonly error: {
+            readonly anyOf: readonly [Record<string, unknown>, {
+                readonly type: 'null';
+            }];
+        };
+        readonly gate_result: {
+            readonly anyOf: readonly [Record<string, unknown>, {
+                readonly type: 'null';
+            }];
+        };
+        readonly invocations: {
+            readonly type: 'array';
+            readonly maxItems: 10;
+            readonly items: {
+                readonly type: 'object';
+                readonly properties: {
+                    readonly call_index: {
+                        readonly type: 'integer';
+                        readonly minimum: 0;
+                    };
+                    readonly started_at: {
+                        readonly type: 'string';
+                        readonly maxLength: 512;
+                    };
+                    readonly finished_at: {
+                        readonly type: 'string';
+                        readonly maxLength: 512;
+                    };
+                    readonly outcome: {
+                        readonly type: 'string';
+                        readonly maxLength: 512;
+                    };
+                    readonly error_code: {
+                        readonly type: 'string';
+                        readonly maxLength: 512;
+                    };
+                    readonly duration_ms: {
+                        readonly type: 'integer';
+                        readonly minimum: 0;
+                    };
+                    readonly next_due_at: {
+                        readonly type: 'string';
+                        readonly maxLength: 512;
+                    };
+                };
+                readonly required: readonly ['call_index', 'started_at'];
+                readonly additionalProperties: false;
+            };
+        };
+        readonly restart_feedback: {
+            readonly anyOf: readonly [Record<string, unknown>, {
+                readonly type: 'null';
+            }];
+        };
+        readonly restart_feedback_truncated: {
+            readonly const: true;
+        };
+        readonly restart_feedback_total_bytes: {
+            readonly type: 'integer';
+            readonly minimum: 0;
+        };
+        readonly response_text_truncated: {
+            readonly const: true;
+        };
+        readonly response_text_total_bytes: {
+            readonly type: 'integer';
+            readonly minimum: 0;
+        };
+        readonly oversized_fields: {
+            readonly type: 'array';
+            readonly maxItems: 100;
+            readonly items: {
+                readonly type: 'object';
+                readonly properties: {
+                    readonly field: {
+                        readonly type: 'string';
+                        readonly enum: readonly ["authored_config", "config", "evaluation_trace", "output", "outputs", "response", "error", "gate_result", "restart_feedback", "job_outputs", "execution_outputs", "job_evaluation_trace", "execution_evaluation_trace", "condition", "trigger_events"];
+                    };
+                    readonly stored_bytes: {
+                        readonly type: 'integer';
+                        readonly minimum: 0;
+                    };
+                    readonly reason: {
+                        readonly type: 'string';
+                        readonly enum: ("legacy_value_exceeds_inline_limit" | "value_exceeds_inline_limit" | "value_truncated_at_write_limit")[];
+                    };
+                };
+                readonly required: readonly ['field', 'stored_bytes', 'reason'];
+                readonly additionalProperties: false;
+            };
+        };
+    };
+    readonly required: readonly ["workflow_run_id", "workflow_run_attempt", "job_id", "job_execution_id", "step_id", "step_attempt_id", "attempt", "authored_config", "config", "session", "evaluation_trace", "output", "outputs", "response", "error", "gate_result", "invocations", "restart_feedback", "oversized_fields"];
+    readonly additionalProperties: false;
+};
+export declare const listWorkflowRunJobExplanationsResultJsonSchema: {
+    readonly type: 'object';
+    readonly properties: {
+        readonly workflow_run_id: {
+            readonly type: 'string';
+            readonly format: 'uuid';
+        };
+        readonly workflow_run_attempt: {
+            readonly type: 'integer';
+            readonly minimum: 1;
+            readonly maximum: 2147483647;
+        };
+        readonly explanations: {
+            readonly type: 'array';
+            readonly maxItems: 100;
+            readonly items: {
+                readonly type: 'object';
+                readonly properties: {
+                    readonly job_id: {
+                        readonly type: 'string';
+                        readonly format: 'uuid';
+                    };
+                    readonly job_label: {
+                        readonly type: 'string';
+                        readonly maxLength: 512;
+                    };
+                    readonly job_position: {
+                        readonly type: 'integer';
+                        readonly minimum: 0;
+                        readonly maximum: 2147483647;
+                    };
+                    readonly status: {
+                        readonly type: 'string';
+                        readonly enum: readonly ["failed", "skipped"];
+                    };
+                    readonly status_reason: {
+                        readonly anyOf: readonly [Record<string, unknown>, {
+                            readonly type: 'null';
+                        }];
+                    };
+                    readonly evaluation_trace: {
+                        readonly anyOf: readonly [Record<string, unknown>, {
+                            readonly type: 'null';
+                        }];
+                    };
+                };
+                readonly required: readonly ['job_id', 'job_label', 'job_position', 'status', 'status_reason', 'evaluation_trace'];
+                readonly additionalProperties: false;
+            };
+        };
+        readonly next_cursor: {
+            readonly anyOf: readonly [Record<string, unknown>, {
+                readonly type: 'null';
+            }];
+        };
+    };
+    readonly required: readonly ["workflow_run_id", "workflow_run_attempt", "explanations", "next_cursor"];
+    readonly additionalProperties: false;
+};
+//# sourceMappingURL=workflow-diagnostics.d.ts.map