@mongodb-js/agent-engine-runner-shared 0.11.3

package/dist/models.d.ts

@@ -0,0 +1,1458 @@
+/**
+ * Shared wire-protocol models for Runner SDK components.
+ *
+ * Defines the API contracts between:
+ * - Orchestration Engine (OE)
+ * - Agent Execution Runtime (AER)
+ * - Tool Executor Pod
+ *
+ * Each Pydantic model in `agent_engine_runner_shared/models.py` maps to:
+ *  - a Zod schema (`FooSchema`) for runtime validation, and
+ *  - the inferred TS type (`Foo = z.infer<typeof FooSchema>`).
+ *
+ * Models with non-trivial methods (`LLMResult`) follow the agent-engine-sdk
+ * pattern of class + separate schema.
+ */
+import { z } from "zod";
+import type { JsonValue } from "@mongodb-js/agent-engine-sdk";
+import { LLMInvocationOptions, LLMResponse, LLMTokenUsage, LLMToolCall, LLMToolSchema, type Message, type ToolCallChunk } from "@mongodb-js/agent-engine-sdk";
+/** Status of an agent execution. */
+export declare const ExecutionStatusSchema: z.ZodEnum<{
+    error: "error";
+    pending: "pending";
+    running: "running";
+    suspended: "suspended";
+    resuming: "resuming";
+    completed: "completed";
+    cancelled: "cancelled";
+}>;
+export type ExecutionStatus = z.infer<typeof ExecutionStatusSchema>;
+export declare const ExecutionStatus: {
+    readonly PENDING: "pending";
+    readonly RUNNING: "running";
+    readonly SUSPENDED: "suspended";
+    readonly RESUMING: "resuming";
+    readonly COMPLETED: "completed";
+    readonly ERROR: "error";
+    readonly CANCELLED: "cancelled";
+};
+/**
+ * Payload returned by an agent tool to trigger human-in-the-loop suspension.
+ *
+ * Agent tools signal a suspend by returning a JSON string containing these
+ * fields. The `__suspend__` flag is stripped before the payload is passed
+ * to the framework's interrupt() handler.
+ *
+ * Example usage in an agent tool:
+ *
+ *     import { suspendPayloadToJson } from '@mongodb-js/agent-engine-runner-shared'
+ *     return suspendPayloadToJson({
+ *       suspend_reason: 'awaiting_human_review',
+ *       suspend_context: { claim_id: 'C-123', task_id: 'T-456' },
+ *     })
+ */
+export declare const SuspendPayloadSchema: z.ZodObject<{
+    suspend_reason: z.ZodString;
+    suspend_context: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type SuspendPayload = z.infer<typeof SuspendPayloadSchema>;
+/**
+ * Serialize a SuspendPayload to the suspend wire marker, and record an
+ * out-of-band suspend request on the current execution frame.
+ *
+ * The Tool Pod honors suspend from that recorded signal — set only here, in
+ * the tool author's own code — not by sniffing tool-result content, so
+ * untrusted data a tool relays can no longer forge a HITL suspend. The marker
+ * string is still returned unchanged for wire/replay compatibility.
+ */
+export declare function suspendPayloadToJson(payload: SuspendPayload): string;
+/**
+ * Result from agent execution when the agent is suspended.
+ *
+ * Contains the suspend payload directly (framework-agnostic) rather than
+ * wrapping framework-specific Interrupt objects. Any framework-specific
+ * state needed to resume (LangGraph checkpoint id, ADK function-call
+ * correlation, etc.) is carried opaquely in `metadata` — the AER never
+ * inspects it; the framework adapter writes it on suspend and reads it back
+ * from `RequestContext.metadata` on resume.
+ */
+export declare const PendingInterruptSchema: z.ZodObject<{
+    id: z.ZodString;
+    value: z.ZodUnknown;
+}, z.core.$strip>;
+export type PendingInterrupt = z.infer<typeof PendingInterruptSchema>;
+export declare const InterruptResultSchema: z.ZodObject<{
+    suspend_payload: z.ZodUnknown;
+    interrupts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        value: z.ZodUnknown;
+    }, z.core.$strip>>>;
+    resume_schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    messages: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodObject<{
+        role: z.ZodEnum<{
+            user: "user";
+            assistant: "assistant";
+            tool: "tool";
+            system: "system";
+        }>;
+        content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodDefault<z.ZodLiteral<"text">>;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodDefault<z.ZodLiteral<"image">>;
+            url: z.ZodString;
+            mime_type: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodDefault<z.ZodLiteral<"document">>;
+            url: z.ZodString;
+            mime_type: z.ZodOptional<z.ZodString>;
+            filename: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>], "type">>]>;
+        tool_calls: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+            args: z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+            arguments: z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+            type: z.ZodOptional<z.ZodString>;
+            index: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodTransform<LLMToolCall, {
+            id?: string | undefined;
+            name?: string | undefined;
+            args?: JsonValue | undefined;
+            arguments?: JsonValue | undefined;
+            type?: string | undefined;
+            index?: number | undefined;
+        }>>>>;
+        tool_call_id: z.ZodOptional<z.ZodString>;
+        is_error: z.ZodOptional<z.ZodBoolean>;
+        name: z.ZodOptional<z.ZodString>;
+        id: z.ZodOptional<z.ZodString>;
+        additional_kwargs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+        response_metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+    }, z.core.$loose>, z.ZodTransform<Message, {
+        [x: string]: unknown;
+        role: "user" | "assistant" | "tool" | "system";
+        content: string | ({
+            type: "text";
+            text: string;
+        } | {
+            type: "image";
+            url: string;
+            mime_type?: string | undefined;
+        } | {
+            type: "document";
+            url: string;
+            mime_type?: string | undefined;
+            filename?: string | undefined;
+        })[];
+        tool_calls?: LLMToolCall[] | undefined;
+        tool_call_id?: string | undefined;
+        is_error?: boolean | undefined;
+        name?: string | undefined;
+        id?: string | undefined;
+        additional_kwargs?: Record<string, JsonValue> | undefined;
+        response_metadata?: Record<string, JsonValue> | undefined;
+    }>>>>;
+}, z.core.$strip>;
+export type InterruptResult = z.infer<typeof InterruptResultSchema>;
+/**
+ * Result from agent execution for normal completion.
+ *
+ * Returned by _execute_via_agent_stream when the agent finishes without
+ * suspend. The caller uses content for the final response and messages
+ * for memory writing.
+ */
+export declare const StreamingResultSchema: z.ZodObject<{
+    content: z.ZodDefault<z.ZodString>;
+    messages: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodObject<{
+        role: z.ZodEnum<{
+            user: "user";
+            assistant: "assistant";
+            tool: "tool";
+            system: "system";
+        }>;
+        content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodDefault<z.ZodLiteral<"text">>;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodDefault<z.ZodLiteral<"image">>;
+            url: z.ZodString;
+            mime_type: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodDefault<z.ZodLiteral<"document">>;
+            url: z.ZodString;
+            mime_type: z.ZodOptional<z.ZodString>;
+            filename: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>], "type">>]>;
+        tool_calls: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+            args: z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+            arguments: z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+            type: z.ZodOptional<z.ZodString>;
+            index: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodTransform<LLMToolCall, {
+            id?: string | undefined;
+            name?: string | undefined;
+            args?: JsonValue | undefined;
+            arguments?: JsonValue | undefined;
+            type?: string | undefined;
+            index?: number | undefined;
+        }>>>>;
+        tool_call_id: z.ZodOptional<z.ZodString>;
+        is_error: z.ZodOptional<z.ZodBoolean>;
+        name: z.ZodOptional<z.ZodString>;
+        id: z.ZodOptional<z.ZodString>;
+        additional_kwargs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+        response_metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+    }, z.core.$loose>, z.ZodTransform<Message, {
+        [x: string]: unknown;
+        role: "user" | "assistant" | "tool" | "system";
+        content: string | ({
+            type: "text";
+            text: string;
+        } | {
+            type: "image";
+            url: string;
+            mime_type?: string | undefined;
+        } | {
+            type: "document";
+            url: string;
+            mime_type?: string | undefined;
+            filename?: string | undefined;
+        })[];
+        tool_calls?: LLMToolCall[] | undefined;
+        tool_call_id?: string | undefined;
+        is_error?: boolean | undefined;
+        name?: string | undefined;
+        id?: string | undefined;
+        additional_kwargs?: Record<string, JsonValue> | undefined;
+        response_metadata?: Record<string, JsonValue> | undefined;
+    }>>>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type StreamingResult = z.infer<typeof StreamingResultSchema>;
+/** Request to invoke the agent (compatible with agent-runtime). */
+export declare const InvokeRequestSchema: z.ZodObject<{
+    message: z.ZodString;
+    session_id: z.ZodOptional<z.ZodString>;
+    org_id: z.ZodOptional<z.ZodString>;
+    user_id: z.ZodOptional<z.ZodString>;
+    workspace_id: z.ZodOptional<z.ZodString>;
+    project_id: z.ZodOptional<z.ZodString>;
+    aer_url: z.ZodOptional<z.ZodString>;
+    tool_url: z.ZodOptional<z.ZodString>;
+    wait: z.ZodDefault<z.ZodBoolean>;
+    custom_headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export type InvokeRequest = z.infer<typeof InvokeRequestSchema>;
+/** Response from invoking the agent (compatible with agent-runtime). */
+export declare const InvokeResponseSchema: z.ZodObject<{
+    result: z.ZodOptional<z.ZodUnknown>;
+    session_id: z.ZodOptional<z.ZodString>;
+    user_id: z.ZodOptional<z.ZodString>;
+    execution_id: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type InvokeResponse = z.infer<typeof InvokeResponseSchema>;
+/** Request to execute an agent in AER. */
+export declare const ExecuteRequestSchema: z.ZodObject<{
+    platform_trace_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    execution_id: z.ZodString;
+    message: z.ZodDefault<z.ZodString>;
+    platform_api_url: z.ZodString;
+    suspend_generation: z.ZodOptional<z.ZodPipe<z.ZodNullable<z.ZodNumber>, z.ZodTransform<number | undefined, number | null>>>;
+    platform_api_owner_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    resume: z.ZodDefault<z.ZodBoolean>;
+    resume_from_step: z.ZodOptional<z.ZodNumber>;
+    resume_data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    org_id: z.ZodOptional<z.ZodString>;
+    user_id: z.ZodOptional<z.ZodString>;
+    session_id: z.ZodOptional<z.ZodString>;
+    workspace_id: z.ZodOptional<z.ZodString>;
+    project_id: z.ZodOptional<z.ZodString>;
+    custom_headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    previous_execution_cancelled: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ExecuteRequest = z.infer<typeof ExecuteRequestSchema>;
+/**
+ * Request to execute a tool (AER → OE for approval).
+ */
+export declare const ToolExecuteRequestSchema: z.ZodObject<{
+    execution_id: z.ZodString;
+    tool_name: z.ZodString;
+    arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    step_number: z.ZodNumber;
+    tool_call_id: z.ZodOptional<z.ZodString>;
+    kind: z.ZodOptional<z.ZodString>;
+    is_local: z.ZodDefault<z.ZodBoolean>;
+    redact_fields: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    provider_type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    scopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    custom_headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    trace_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    span_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type ToolExecuteRequest = z.infer<typeof ToolExecuteRequestSchema>;
+/** Authorization details returned when broker consent is required. */
+export declare const ElicitationInfoSchema: z.ZodObject<{
+    elicitation_id: z.ZodString;
+    authorization_url: z.ZodString;
+    message: z.ZodDefault<z.ZodString>;
+    created: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ElicitationInfo = z.infer<typeof ElicitationInfoSchema>;
+/** Identity of the policy that caused a guardrail block or require_review halt. */
+export declare const GuardrailMetaSchema: z.ZodObject<{
+    guardrail_id: z.ZodString;
+    guardrail_category: z.ZodString;
+}, z.core.$strip>;
+export type GuardrailMeta = z.infer<typeof GuardrailMetaSchema>;
+/**
+ * Assemble `guardrail_meta` from the flat `guardrail_id`/`guardrail_category`
+ * fields the OE wire format sends, so callers work with a single structured
+ * object. Mirrors Python's `_assemble_guardrail_meta` model validator.
+ */
+export declare const ToolExecuteResponseSchema: z.ZodPreprocess<z.ZodObject<{
+    proceed: z.ZodBoolean;
+    cached_result: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
+    route_to: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    elicitation: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        elicitation_id: z.ZodString;
+        authorization_url: z.ZodString;
+        message: z.ZodDefault<z.ZodString>;
+        created: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    status: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    result: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
+    error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    error_code: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    retryable: z.ZodDefault<z.ZodBoolean>;
+    latest_step_number: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    from_cache: z.ZodDefault<z.ZodBoolean>;
+    duration_ms: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    pod_name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    guardrail_meta: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        guardrail_id: z.ZodString;
+        guardrail_category: z.ZodString;
+    }, z.core.$strip>>>;
+    tool_api_error: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        provider_type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        classification: z.ZodString;
+        http_status: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        retryable: z.ZodBoolean;
+        error_code: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>>;
+export type ToolExecuteResponse = z.infer<typeof ToolExecuteResponseSchema>;
+/**
+ * Report tool execution result (AER → OE).
+ */
+export declare const ToolResultRequestSchema: z.ZodObject<{
+    execution_id: z.ZodString;
+    step_number: z.ZodNumber;
+    tool_name: z.ZodString;
+    tool_call_id: z.ZodOptional<z.ZodString>;
+    status: z.ZodString;
+    result: z.ZodOptional<z.ZodUnknown>;
+    error: z.ZodOptional<z.ZodString>;
+    duration_ms: z.ZodNumber;
+    pod_name: z.ZodOptional<z.ZodString>;
+    prompt_tokens: z.ZodOptional<z.ZodNumber>;
+    completion_tokens: z.ZodOptional<z.ZodNumber>;
+    total_tokens: z.ZodOptional<z.ZodNumber>;
+    model: z.ZodOptional<z.ZodString>;
+    workspace_id: z.ZodOptional<z.ZodString>;
+    kind: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    trace_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    span_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    tool_api_error: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        provider_type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        classification: z.ZodString;
+        http_status: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        retryable: z.ZodBoolean;
+        error_code: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type ToolResultRequest = z.infer<typeof ToolResultRequestSchema>;
+export declare const MAX_TOOL_ARGUMENT_BYTES: number;
+/** Delegated credential injected by OE for tool execution. */
+export declare const ToolAuthorizationSchema: z.ZodObject<{
+    token: z.ZodString;
+    expires_at: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>;
+export type ToolAuthorization = z.infer<typeof ToolAuthorizationSchema>;
+/** Request to execute a tool in a Tool Pod. */
+export declare const ToolPodExecuteRequestSchema: z.ZodObject<{
+    platform_trace_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    execution_id: z.ZodString;
+    tool_name: z.ZodString;
+    arguments: z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+    tool_call_id: z.ZodOptional<z.ZodString>;
+    step_number: z.ZodOptional<z.ZodNumber>;
+    session_id: z.ZodString;
+    user_id: z.ZodOptional<z.ZodString>;
+    oe_url: z.ZodOptional<z.ZodString>;
+    oe_owner_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    authorization: z.ZodOptional<z.ZodObject<{
+        token: z.ZodString;
+        expires_at: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strip>>;
+    custom_headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type ToolPodExecuteRequest = z.infer<typeof ToolPodExecuteRequestSchema>;
+/** Response from Tool Pod execution. */
+export declare const ToolPodExecuteResponseSchema: z.ZodObject<{
+    status: z.ZodString;
+    result: z.ZodOptional<z.ZodUnknown>;
+    error: z.ZodOptional<z.ZodString>;
+    pod_name: z.ZodOptional<z.ZodString>;
+    kind: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    oob_suspend_supported: z.ZodOptional<z.ZodBoolean>;
+    tool_api_error: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        provider_type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        classification: z.ZodString;
+        http_status: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        retryable: z.ZodBoolean;
+        error_code: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type ToolPodExecuteResponse = z.infer<typeof ToolPodExecuteResponseSchema>;
+/** Runtime stage where OE is asking the Tool Pod to evaluate guardrails. */
+export declare const GuardrailRuntimeStageSchema: z.ZodEnum<{
+    llm_input: "llm_input";
+    llm_output: "llm_output";
+    tool_input: "tool_input";
+    tool_output: "tool_output";
+}>;
+export type GuardrailRuntimeStage = z.infer<typeof GuardrailRuntimeStageSchema>;
+export declare const GuardrailRuntimeStage: {
+    readonly LLM_INPUT: "llm_input";
+    readonly LLM_OUTPUT: "llm_output";
+    readonly TOOL_INPUT: "tool_input";
+    readonly TOOL_OUTPUT: "tool_output";
+};
+/** Decision returned by the Tool Pod guardrails evaluator. */
+export declare const GuardrailCheckDecisionSchema: z.ZodEnum<{
+    allow: "allow";
+    block: "block";
+    modify: "modify";
+    require_review: "require_review";
+    log_only: "log_only";
+}>;
+export type GuardrailCheckDecision = z.infer<typeof GuardrailCheckDecisionSchema>;
+export declare const GuardrailCheckDecision: {
+    readonly ALLOW: "allow";
+    readonly BLOCK: "block";
+    readonly MODIFY: "modify";
+    readonly REQUIRE_REVIEW: "require_review";
+    readonly LOG_ONLY: "log_only";
+};
+/** OE-selected guardrail policy sent to the Tool Pod for evaluation. */
+export declare const GuardrailRuntimePolicySchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodString;
+    status: z.ZodDefault<z.ZodString>;
+    action: z.ZodString;
+    stage_filter: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+}, z.core.$strip>;
+export type GuardrailRuntimePolicy = z.infer<typeof GuardrailRuntimePolicySchema>;
+/**
+ * Whether `policy` applies at `stage`. Inactive policies never apply; an empty
+ * stage filter applies to all stages; otherwise the stage must match (case- and
+ * whitespace-insensitive). Mirrors `GuardrailRuntimePolicy.applies_to_stage`.
+ */
+export declare function appliesToStage(policy: GuardrailRuntimePolicy, stage: GuardrailRuntimeStage): boolean;
+/**
+ * Resolve the decision a triggered policy requests, from its `action` (falling
+ * back to `config.on_fail`). Mirrors `GuardrailRuntimePolicy.check_decision`.
+ */
+export declare function checkDecision(policy: GuardrailRuntimePolicy): GuardrailCheckDecision;
+/** Runtime content and metadata to evaluate. */
+export declare const GuardrailCheckInputSchema: z.ZodObject<{
+    text: z.ZodString;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+}, z.core.$strip>;
+export type GuardrailCheckInput = z.infer<typeof GuardrailCheckInputSchema>;
+/** Execution context for a guardrail check. */
+export declare const GuardrailCheckContextSchema: z.ZodObject<{
+    org_id: z.ZodString;
+    project_id: z.ZodString;
+    workspace_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    session_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    user_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type GuardrailCheckContext = z.infer<typeof GuardrailCheckContextSchema>;
+/** Request from OE to Tool Pod to evaluate selected guardrail policies. */
+export declare const GuardrailCheckRequestSchema: z.ZodObject<{
+    execution_id: z.ZodString;
+    stage: z.ZodEnum<{
+        llm_input: "llm_input";
+        llm_output: "llm_output";
+        tool_input: "tool_input";
+        tool_output: "tool_output";
+    }>;
+    input: z.ZodObject<{
+        text: z.ZodString;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+    }, z.core.$strip>;
+    context: z.ZodObject<{
+        org_id: z.ZodString;
+        project_id: z.ZodString;
+        workspace_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        session_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        user_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+    policies: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+        status: z.ZodDefault<z.ZodString>;
+        action: z.ZodString;
+        stage_filter: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type GuardrailCheckRequest = z.infer<typeof GuardrailCheckRequestSchema>;
+/** Evidence explaining why a guardrail policy triggered. */
+export declare const GuardrailCheckEvidenceSchema: z.ZodObject<{
+    policy_id: z.ZodString;
+    message: z.ZodDefault<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+}, z.core.$strip>;
+export type GuardrailCheckEvidence = z.infer<typeof GuardrailCheckEvidenceSchema>;
+/** Decision returned by the Tool Pod guardrails evaluator. */
+export declare const GuardrailCheckResponseSchema: z.ZodObject<{
+    decision: z.ZodEnum<{
+        allow: "allow";
+        block: "block";
+        modify: "modify";
+        require_review: "require_review";
+        log_only: "log_only";
+    }>;
+    allowed: z.ZodBoolean;
+    transformed_text: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    triggered_policy_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        policy_id: z.ZodString;
+        message: z.ZodDefault<z.ZodString>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+    }, z.core.$strip>>>;
+    reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+}, z.core.$strip>;
+export type GuardrailCheckResponse = z.infer<typeof GuardrailCheckResponseSchema>;
+/**
+ * Typed invoke_llm arguments forwarded through OE and tool pods.
+ *
+ * Python uses Pydantic aliases:
+ *   - validation alias `stop` ↔ `stop_sequences`, serialization alias `stop`
+ *   - pre-validator renames `kwargs` → `options`
+ *
+ * In Zod we replicate this with a `z.preprocess` that normalizes incoming
+ * payloads into the canonical schema (using `stop_sequences` and
+ * `options`). For outgoing serialization that needs the wire alias `stop`,
+ * use `serializeInvokeLLMRequestArguments()`.
+ */
+export declare const InvokeLLMRequestArgumentsSchema: z.ZodPreprocess<z.ZodObject<{
+    model: z.ZodString;
+    messages: z.ZodArray<z.ZodPipe<z.ZodObject<{
+        role: z.ZodEnum<{
+            user: "user";
+            assistant: "assistant";
+            tool: "tool";
+            system: "system";
+        }>;
+        content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodDefault<z.ZodLiteral<"text">>;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodDefault<z.ZodLiteral<"image">>;
+            url: z.ZodString;
+            mime_type: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodDefault<z.ZodLiteral<"document">>;
+            url: z.ZodString;
+            mime_type: z.ZodOptional<z.ZodString>;
+            filename: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>], "type">>]>;
+        tool_calls: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+            args: z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+            arguments: z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+            type: z.ZodOptional<z.ZodString>;
+            index: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodTransform<LLMToolCall, {
+            id?: string | undefined;
+            name?: string | undefined;
+            args?: JsonValue | undefined;
+            arguments?: JsonValue | undefined;
+            type?: string | undefined;
+            index?: number | undefined;
+        }>>>>;
+        tool_call_id: z.ZodOptional<z.ZodString>;
+        is_error: z.ZodOptional<z.ZodBoolean>;
+        name: z.ZodOptional<z.ZodString>;
+        id: z.ZodOptional<z.ZodString>;
+        additional_kwargs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+        response_metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+    }, z.core.$loose>, z.ZodTransform<Message, {
+        [x: string]: unknown;
+        role: "user" | "assistant" | "tool" | "system";
+        content: string | ({
+            type: "text";
+            text: string;
+        } | {
+            type: "image";
+            url: string;
+            mime_type?: string | undefined;
+        } | {
+            type: "document";
+            url: string;
+            mime_type?: string | undefined;
+            filename?: string | undefined;
+        })[];
+        tool_calls?: LLMToolCall[] | undefined;
+        tool_call_id?: string | undefined;
+        is_error?: boolean | undefined;
+        name?: string | undefined;
+        id?: string | undefined;
+        additional_kwargs?: Record<string, JsonValue> | undefined;
+        response_metadata?: Record<string, JsonValue> | undefined;
+    }>>>;
+    llm_id: z.ZodDefault<z.ZodString>;
+    stop_sequences: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        parameters: z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+        type: z.ZodOptional<z.ZodString>;
+        strict: z.ZodOptional<z.ZodBoolean>;
+        function: z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+    }, z.core.$strip>, z.ZodTransform<LLMToolSchema, {
+        name?: string | undefined;
+        description?: string | undefined;
+        parameters?: JsonValue | undefined;
+        type?: string | undefined;
+        strict?: boolean | undefined;
+        function?: JsonValue | undefined;
+    }>>>>;
+    tool_choice: z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+    options: z.ZodOptional<z.ZodPreprocess<z.ZodPipe<z.ZodObject<{
+        max_tokens: z.ZodOptional<z.ZodNumber>;
+        response_format: z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+        top_p: z.ZodOptional<z.ZodNumber>;
+        top_k: z.ZodOptional<z.ZodNumber>;
+        frequency_penalty: z.ZodOptional<z.ZodNumber>;
+        presence_penalty: z.ZodOptional<z.ZodNumber>;
+        seed: z.ZodOptional<z.ZodNumber>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+        parallel_tool_calls: z.ZodOptional<z.ZodBoolean>;
+        reasoning_effort: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>, z.ZodTransform<LLMInvocationOptions, {
+        [x: string]: unknown;
+        max_tokens?: number | undefined;
+        response_format?: JsonValue | undefined;
+        top_p?: number | undefined;
+        top_k?: number | undefined;
+        frequency_penalty?: number | undefined;
+        presence_penalty?: number | undefined;
+        seed?: number | undefined;
+        timeout?: number | undefined;
+        parallel_tool_calls?: boolean | undefined;
+        reasoning_effort?: string | undefined;
+    }>>>>;
+    stream: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>>;
+export type InvokeLLMRequestArguments = z.infer<typeof InvokeLLMRequestArgumentsSchema>;
+/**
+ * Serialize InvokeLLMRequestArguments to the snake_case wire shape, the
+ * equivalent of Python's `model_dump(by_alias=True)`:
+ *  - `stop_sequences` → `stop` (Pydantic `serialization_alias="stop"`), and
+ *  - each Message is dumped camel→snake via `serializeMessage`.
+ *
+ * Use this when sending to a Python consumer (OE / Tool Pod) that expects the
+ * snake_case wire fields.
+ */
+export declare function serializeInvokeLLMRequestArguments(args: InvokeLLMRequestArguments): Record<string, unknown>;
+/**
+ * Request to invoke LLM on a tool executor pod.
+ *
+ * Python pre-validator `_normalize_flat_payload`: if `arguments` is
+ * missing but `execution_id` is present, treat the remaining keys as
+ * the arguments payload. Same logic replicated via `z.preprocess`.
+ */
+export declare const LLMPodInvokeRequestSchema: z.ZodPreprocess<z.ZodObject<{
+    platform_trace_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    execution_id: z.ZodString;
+    arguments: z.ZodPreprocess<z.ZodObject<{
+        model: z.ZodString;
+        messages: z.ZodArray<z.ZodPipe<z.ZodObject<{
+            role: z.ZodEnum<{
+                user: "user";
+                assistant: "assistant";
+                tool: "tool";
+                system: "system";
+            }>;
+            content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodDefault<z.ZodLiteral<"text">>;
+                text: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodDefault<z.ZodLiteral<"image">>;
+                url: z.ZodString;
+                mime_type: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodDefault<z.ZodLiteral<"document">>;
+                url: z.ZodString;
+                mime_type: z.ZodOptional<z.ZodString>;
+                filename: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>], "type">>]>;
+            tool_calls: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodObject<{
+                id: z.ZodOptional<z.ZodString>;
+                name: z.ZodOptional<z.ZodString>;
+                args: z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+                arguments: z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+                type: z.ZodOptional<z.ZodString>;
+                index: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>, z.ZodTransform<LLMToolCall, {
+                id?: string | undefined;
+                name?: string | undefined;
+                args?: JsonValue | undefined;
+                arguments?: JsonValue | undefined;
+                type?: string | undefined;
+                index?: number | undefined;
+            }>>>>;
+            tool_call_id: z.ZodOptional<z.ZodString>;
+            is_error: z.ZodOptional<z.ZodBoolean>;
+            name: z.ZodOptional<z.ZodString>;
+            id: z.ZodOptional<z.ZodString>;
+            additional_kwargs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+            response_metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+        }, z.core.$loose>, z.ZodTransform<Message, {
+            [x: string]: unknown;
+            role: "user" | "assistant" | "tool" | "system";
+            content: string | ({
+                type: "text";
+                text: string;
+            } | {
+                type: "image";
+                url: string;
+                mime_type?: string | undefined;
+            } | {
+                type: "document";
+                url: string;
+                mime_type?: string | undefined;
+                filename?: string | undefined;
+            })[];
+            tool_calls?: LLMToolCall[] | undefined;
+            tool_call_id?: string | undefined;
+            is_error?: boolean | undefined;
+            name?: string | undefined;
+            id?: string | undefined;
+            additional_kwargs?: Record<string, JsonValue> | undefined;
+            response_metadata?: Record<string, JsonValue> | undefined;
+        }>>>;
+        llm_id: z.ZodDefault<z.ZodString>;
+        stop_sequences: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        tools: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            parameters: z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+            type: z.ZodOptional<z.ZodString>;
+            strict: z.ZodOptional<z.ZodBoolean>;
+            function: z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+        }, z.core.$strip>, z.ZodTransform<LLMToolSchema, {
+            name?: string | undefined;
+            description?: string | undefined;
+            parameters?: JsonValue | undefined;
+            type?: string | undefined;
+            strict?: boolean | undefined;
+            function?: JsonValue | undefined;
+        }>>>>;
+        tool_choice: z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+        options: z.ZodOptional<z.ZodPreprocess<z.ZodPipe<z.ZodObject<{
+            max_tokens: z.ZodOptional<z.ZodNumber>;
+            response_format: z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+            top_p: z.ZodOptional<z.ZodNumber>;
+            top_k: z.ZodOptional<z.ZodNumber>;
+            frequency_penalty: z.ZodOptional<z.ZodNumber>;
+            presence_penalty: z.ZodOptional<z.ZodNumber>;
+            seed: z.ZodOptional<z.ZodNumber>;
+            timeout: z.ZodOptional<z.ZodNumber>;
+            parallel_tool_calls: z.ZodOptional<z.ZodBoolean>;
+            reasoning_effort: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>, z.ZodTransform<LLMInvocationOptions, {
+            [x: string]: unknown;
+            max_tokens?: number | undefined;
+            response_format?: JsonValue | undefined;
+            top_p?: number | undefined;
+            top_k?: number | undefined;
+            frequency_penalty?: number | undefined;
+            presence_penalty?: number | undefined;
+            seed?: number | undefined;
+            timeout?: number | undefined;
+            parallel_tool_calls?: boolean | undefined;
+            reasoning_effort?: string | undefined;
+        }>>>>;
+        stream: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    step_number: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>>;
+export type LLMPodInvokeRequest = z.infer<typeof LLMPodInvokeRequestSchema>;
+/**
+ * Normalized result from an LLM invocation.
+ *
+ * Provides a consistent shape for LLM responses regardless of the
+ * underlying provider (OpenAI, Gemini, Anthropic, etc.). Implemented as
+ * a class to mirror `LLMResponse` in agent-engine-sdk and to host the
+ * `fromResponse` / `toResponse` / `extractUsage` conversion methods.
+ */
+export declare class LLMResult {
+    readonly content: string;
+    readonly toolCalls: LLMToolCall[];
+    readonly usage?: LLMTokenUsage;
+    readonly metadata: Record<string, JsonValue>;
+    readonly id?: string;
+    readonly name?: string;
+    readonly additionalKwargs?: Record<string, JsonValue>;
+    readonly responseMetadata?: Record<string, JsonValue>;
+    constructor(data: {
+        content?: string;
+        toolCalls?: LLMToolCall[];
+        usage?: LLMTokenUsage;
+        metadata?: Record<string, JsonValue>;
+        id?: string;
+        name?: string;
+        additionalKwargs?: Record<string, JsonValue>;
+        responseMetadata?: Record<string, JsonValue>;
+    });
+    /**
+     * Extract a normalized result from any LLM response object.
+     *
+     * Accepts an sdk-core `LLMResponse` directly, or a duck-typed object
+     * (e.g. raw provider response) by falling back to string-coerced
+     * content extraction.
+     */
+    static fromResponse(response: unknown): LLMResult;
+    /**
+     * Extract token usage metadata from any response or chunk.
+     *
+     * Checks (in order): sdk-core `LLMResponse.usage`, `usage_metadata`,
+     * `response_metadata.usage`, `response_metadata.token_usage`,
+     * `usage`, `metadata.usage`.
+     */
+    static extractUsage(response: unknown): LLMTokenUsage | undefined;
+    /** Convert the normalized runner result to sdk-core's LLMResponse shape. */
+    toResponse(): LLMResponse;
+}
+/** Coerce a provider usage blob into LLMTokenUsage, or undefined. */
+export declare function coerceTokenUsage(value: unknown): LLMTokenUsage | undefined;
+/** Merge stream usage field-by-field; incoming non-null fields win. */
+export declare function mergeTokenUsage(existing: LLMTokenUsage | undefined, incoming: unknown): LLMTokenUsage | undefined;
+/** Copy provider metadata into JSON-safe values, or undefined. */
+export declare function jsonSafeMetadata(value: unknown, depth?: number): Record<string, JsonValue> | undefined;
+/** Sum LangChain-style additive usage deltas into a cumulative snapshot. */
+export declare function addTokenUsage(existing: LLMTokenUsage | undefined, incoming: unknown): LLMTokenUsage | undefined;
+/** Fold a stream chunk's usage into a running snapshot.
+ *
+ * Cumulative providers repeat growing totals (`10/1` then `10/2`);
+ * last-wins merge keeps `10/2`. Additive providers zero-fill the
+ * unchanged side (`18/1` then `0/4`); those deltas are summed.
+ */
+export declare function accumulateStreamUsage(existing: LLMTokenUsage | undefined, incoming: unknown): LLMTokenUsage | undefined;
+/** Runtime validation schema for LLMResult wire data. `content` is the only required field. */
+export declare const LLMResultSchema: z.ZodObject<{
+    content: z.ZodDefault<z.ZodString>;
+    tool_calls: z.ZodDefault<z.ZodArray<z.ZodUnknown>>;
+    usage: z.ZodOptional<z.ZodPreprocess<z.ZodPipe<z.ZodObject<{
+        input_tokens: z.ZodOptional<z.ZodNumber>;
+        output_tokens: z.ZodOptional<z.ZodNumber>;
+        prompt_tokens: z.ZodOptional<z.ZodNumber>;
+        completion_tokens: z.ZodOptional<z.ZodNumber>;
+        total_tokens: z.ZodOptional<z.ZodNumber>;
+        model: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodTransform<LLMTokenUsage, {
+        input_tokens?: number | undefined;
+        output_tokens?: number | undefined;
+        prompt_tokens?: number | undefined;
+        completion_tokens?: number | undefined;
+        total_tokens?: number | undefined;
+        model?: string | undefined;
+    }>>>>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    id: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    additional_kwargs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+    response_metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+}, z.core.$loose>;
+/**
+ * Response from LLM invocation on a tool executor pod.
+ *
+ * Python `_sync_usage_with_result` is a model_validator that mutates
+ * `result.usage` ↔ `usage`. TS `LLMResponse.usage` is readonly, so
+ * mutation isn't possible; callers should use
+ * `normalizeLLMPodInvokeResponse()` after parsing to sync the two fields
+ * by constructing a fresh LLMResponse when needed.
+ */
+export declare const LLMPodInvokeResponseSchema: z.ZodObject<{
+    status: z.ZodString;
+    result: z.ZodOptional<z.ZodObject<{
+        content: z.ZodString;
+        tool_calls: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        usage: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        id: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        additional_kwargs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        response_metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$loose>>;
+    error: z.ZodOptional<z.ZodString>;
+    error_code: z.ZodOptional<z.ZodString>;
+    pod_name: z.ZodString;
+    duration_ms: z.ZodNumber;
+    usage: z.ZodOptional<z.ZodPreprocess<z.ZodPipe<z.ZodObject<{
+        input_tokens: z.ZodOptional<z.ZodNumber>;
+        output_tokens: z.ZodOptional<z.ZodNumber>;
+        prompt_tokens: z.ZodOptional<z.ZodNumber>;
+        completion_tokens: z.ZodOptional<z.ZodNumber>;
+        total_tokens: z.ZodOptional<z.ZodNumber>;
+        model: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodTransform<LLMTokenUsage, {
+        input_tokens?: number | undefined;
+        output_tokens?: number | undefined;
+        prompt_tokens?: number | undefined;
+        completion_tokens?: number | undefined;
+        total_tokens?: number | undefined;
+        model?: string | undefined;
+    }>>>>;
+}, z.core.$strip>;
+export type LLMPodInvokeResponse = z.infer<typeof LLMPodInvokeResponseSchema>;
+/**
+ * Sync `usage` and `result.usage` on a parsed LLMPodInvokeResponse,
+ * mirroring Python's `_sync_usage_with_result` model_validator.
+ *
+ * - If `result.usage` is unset and `usage` is present, returns a new
+ *   response whose result carries the top-level usage.
+ * - If `usage` is unset and `result.usage` is present, lifts that
+ *   `result.usage` to the top level.
+ *
+ * Returns the response (possibly with a freshly-built `result`/`usage`).
+ */
+export declare function normalizeLLMPodInvokeResponse(resp: LLMPodInvokeResponse): LLMPodInvokeResponse;
+/** SSE event emitted by a tool pod during invoke_llm streaming. */
+export declare const LLMPodStreamEventSchema: z.ZodObject<{
+    content: z.ZodOptional<z.ZodString>;
+    tool_call_chunks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        args: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodString>;
+        index: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    tool_calls: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    id: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    additional_kwargs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+    response_metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+    done: z.ZodOptional<z.ZodBoolean>;
+    interrupted: z.ZodOptional<z.ZodBoolean>;
+    error: z.ZodOptional<z.ZodString>;
+    error_code: z.ZodOptional<z.ZodString>;
+    retryable: z.ZodOptional<z.ZodBoolean>;
+    retry_after_ms: z.ZodOptional<z.ZodNumber>;
+    pod_name: z.ZodOptional<z.ZodString>;
+    duration_ms: z.ZodOptional<z.ZodNumber>;
+    usage: z.ZodOptional<z.ZodPreprocess<z.ZodPipe<z.ZodObject<{
+        input_tokens: z.ZodOptional<z.ZodNumber>;
+        output_tokens: z.ZodOptional<z.ZodNumber>;
+        prompt_tokens: z.ZodOptional<z.ZodNumber>;
+        completion_tokens: z.ZodOptional<z.ZodNumber>;
+        total_tokens: z.ZodOptional<z.ZodNumber>;
+        model: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodTransform<LLMTokenUsage, {
+        input_tokens?: number | undefined;
+        output_tokens?: number | undefined;
+        prompt_tokens?: number | undefined;
+        completion_tokens?: number | undefined;
+        total_tokens?: number | undefined;
+        model?: string | undefined;
+    }>>>>;
+}, z.core.$strip>;
+export type LLMPodStreamEvent = z.infer<typeof LLMPodStreamEventSchema>;
+/** Callback from AER to OE when execution completes or suspends. */
+export declare const ExecutorCallbackRequestSchema: z.ZodObject<{
+    execution_id: z.ZodString;
+    status: z.ZodString;
+    suspend_generation: z.ZodOptional<z.ZodPipe<z.ZodNullable<z.ZodNumber>, z.ZodTransform<number | undefined, number | null>>>;
+    result: z.ZodOptional<z.ZodUnknown>;
+    error: z.ZodOptional<z.ZodString>;
+    suspend_reason: z.ZodOptional<z.ZodString>;
+    suspend_context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    interrupts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        value: z.ZodUnknown;
+    }, z.core.$strip>>>;
+    resume_schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type ExecutorCallbackRequest = z.infer<typeof ExecutorCallbackRequestSchema>;
+/** Data provided by human reviewer when resuming a suspended execution. */
+export declare const HumanReviewDataSchema: z.ZodObject<{
+    decision: z.ZodString;
+    reviewer_notes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type HumanReviewData = z.infer<typeof HumanReviewDataSchema>;
+/** Request to resume a suspended execution. */
+export declare const AgentResumeRequestSchema: z.ZodObject<{
+    human_review: z.ZodObject<{
+        decision: z.ZodString;
+        reviewer_notes: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    custom_headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export type AgentResumeRequest = z.infer<typeof AgentResumeRequestSchema>;
+/** Response from resuming an execution. */
+export declare const AgentResumeResponseSchema: z.ZodObject<{
+    execution_id: z.ZodString;
+    status: z.ZodString;
+}, z.core.$strip>;
+export type AgentResumeResponse = z.infer<typeof AgentResumeResponseSchema>;
+/** Response for execution status query. */
+export declare const ExecutionStatusResponseSchema: z.ZodObject<{
+    execution_id: z.ZodString;
+    status: z.ZodEnum<{
+        error: "error";
+        pending: "pending";
+        running: "running";
+        suspended: "suspended";
+        resuming: "resuming";
+        completed: "completed";
+        cancelled: "cancelled";
+    }>;
+    result: z.ZodOptional<z.ZodUnknown>;
+    error: z.ZodOptional<z.ZodString>;
+    suspend_reason: z.ZodOptional<z.ZodString>;
+    suspend_context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    created_at: z.ZodCoercedDate<unknown>;
+    updated_at: z.ZodCoercedDate<unknown>;
+}, z.core.$strip>;
+export type ExecutionStatusResponse = z.infer<typeof ExecutionStatusResponseSchema>;
+/** Execution record stored in TenantDB. */
+export declare const ExecutionSchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        error: "error";
+        pending: "pending";
+        running: "running";
+        suspended: "suspended";
+        resuming: "resuming";
+        completed: "completed";
+        cancelled: "cancelled";
+    }>;
+    message: z.ZodString;
+    result: z.ZodOptional<z.ZodUnknown>;
+    error: z.ZodOptional<z.ZodString>;
+    suspend_reason: z.ZodOptional<z.ZodString>;
+    suspend_context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    session_id: z.ZodOptional<z.ZodString>;
+    org_id: z.ZodOptional<z.ZodString>;
+    user_id: z.ZodOptional<z.ZodString>;
+    workspace_id: z.ZodOptional<z.ZodString>;
+    project_id: z.ZodOptional<z.ZodString>;
+    aer_url: z.ZodOptional<z.ZodString>;
+    tool_url: z.ZodOptional<z.ZodString>;
+    created_at: z.ZodDefault<z.ZodCoercedDate<unknown>>;
+    updated_at: z.ZodDefault<z.ZodCoercedDate<unknown>>;
+}, z.core.$strip>;
+export type Execution = z.infer<typeof ExecutionSchema>;
+/**
+ * Normalize a value (Date, ISO string, or null/undefined) to a UTC Date.
+ *
+ * MongoDB stores naive datetimes in UTC; this helper rehydrates them as
+ * proper Date instances so callers don't mix string and Date types.
+ *
+ * Mirrors Python `Execution._ensure_utc`. JS `Date` has no naive/aware
+ * distinction (every Date is internally UTC ms-since-epoch), so the TS
+ * version exercises the same "normalize input to a canonical Date" intent
+ * by coercing ISO strings and passing Date instances through unchanged.
+ */
+export declare function ensureUtc(value: unknown): Date | undefined;
+/**
+ * Convert an Execution to a MongoDB persistence document.
+ *
+ * `updatedAt` defaults to now if omitted.
+ */
+export declare function executionToPersistenceDoc(exec: Execution, updatedAt?: Date): Record<string, unknown>;
+/**
+ * Rehydrate an Execution from a MongoDB document.
+ *
+ * Uses default values for Optional fields so documents created before
+ * new fields were added still deserialize safely.
+ */
+export declare function executionFromPersistenceDoc(doc: Record<string, unknown>): Execution;
+/** Execution step record stored in TenantDB. */
+export declare const ExecutionStepSchema: z.ZodObject<{
+    id: z.ZodString;
+    execution_id: z.ZodString;
+    step_number: z.ZodNumber;
+    tool_name: z.ZodString;
+    arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    status: z.ZodString;
+    result: z.ZodOptional<z.ZodUnknown>;
+    error: z.ZodOptional<z.ZodString>;
+    duration_ms: z.ZodOptional<z.ZodNumber>;
+    timestamp: z.ZodDefault<z.ZodCoercedDate<unknown>>;
+}, z.core.$strip>;
+export type ExecutionStep = z.infer<typeof ExecutionStepSchema>;
+/**
+ * Reconstruct an ExecutionStep from an execution_logs MongoDB document.
+ *
+ * The execution_logs collection stores tool start/result events with
+ * fields: execution_id, step_number, tool, inputs, status, output,
+ * error, duration_ms, timestamp. This maps those fields back to the
+ * ExecutionStep model for step-cache rehydration after OE restart.
+ */
+export declare function executionStepFromLogDoc(doc: Record<string, unknown>): ExecutionStep;
+/** Health status of a component. */
+export declare const HealthStatusSchema: z.ZodEnum<{
+    healthy: "healthy";
+    unhealthy: "unhealthy";
+    degraded: "degraded";
+}>;
+export type HealthStatus = z.infer<typeof HealthStatusSchema>;
+export declare const HealthStatus: {
+    readonly HEALTHY: "healthy";
+    readonly UNHEALTHY: "unhealthy";
+    readonly DEGRADED: "degraded";
+};
+/** Health check response. */
+export declare const HealthResponseSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        healthy: "healthy";
+        unhealthy: "unhealthy";
+        degraded: "degraded";
+    }>;
+    component: z.ZodString;
+    mode: z.ZodString;
+    version: z.ZodDefault<z.ZodString>;
+    details: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type HealthResponse = z.infer<typeof HealthResponseSchema>;
+/** Definition of a registered tool. */
+export declare const ToolDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodDefault<z.ZodString>;
+    is_local: z.ZodDefault<z.ZodBoolean>;
+    provider_type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    scopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type ToolDefinition = z.infer<typeof ToolDefinitionSchema>;
+/**
+ * Response from AER /execute endpoint.
+ *
+ * Returned on both normal completion and HITL suspension.
+ */
+export declare const AERExecuteResponseSchema: z.ZodObject<{
+    status: z.ZodString;
+    result: z.ZodOptional<z.ZodString>;
+    suspend_reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AERExecuteResponse = z.infer<typeof AERExecuteResponseSchema>;
+/** Response from /tools endpoint listing registered tools. */
+export declare const ToolsListResponseSchema: z.ZodObject<{
+    tools: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    count: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ToolsListResponse = z.infer<typeof ToolsListResponseSchema>;
+/**
+ * A chunk of streaming response from the agent.
+ *
+ * Used for real-time streaming of agent responses via SSE or gRPC.
+ */
+export declare const StreamChunkSchema: z.ZodObject<{
+    chunk_type: z.ZodString;
+    content: z.ZodDefault<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    error: z.ZodOptional<z.ZodString>;
+    code: z.ZodOptional<z.ZodString>;
+    tool_name: z.ZodOptional<z.ZodString>;
+    tool_call_id: z.ZodOptional<z.ZodString>;
+    execution_id: z.ZodOptional<z.ZodString>;
+    step_number: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type StreamChunk = z.infer<typeof StreamChunkSchema>;
+/** Request to start an agent execution with streaming response. */
+export declare const AgentStartStreamRequestSchema: z.ZodObject<{
+    message: z.ZodString;
+    session_id: z.ZodOptional<z.ZodString>;
+    org_id: z.ZodOptional<z.ZodString>;
+    user_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AgentStartStreamRequest = z.infer<typeof AgentStartStreamRequestSchema>;
+/** Response for execution logs query (used by API Gateway proxy). */
+export declare const ExecutionLogsQueryResponseSchema: z.ZodObject<{
+    logs: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    count: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type ExecutionLogsQueryResponse = z.infer<typeof ExecutionLogsQueryResponseSchema>;
+/** Response for node executions query (used by API Gateway proxy). */
+export declare const NodeExecutionsQueryResponseSchema: z.ZodObject<{
+    executions: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    count: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type NodeExecutionsQueryResponse = z.infer<typeof NodeExecutionsQueryResponseSchema>;
+/** A single session entry returned by /query/sessions. */
+export declare const SessionInfoSchema: z.ZodObject<{
+    session_id: z.ZodString;
+    last_activity: z.ZodString;
+    created_at: z.ZodString;
+    message_count: z.ZodDefault<z.ZodNumber>;
+    last_message_preview: z.ZodDefault<z.ZodString>;
+    visibility: z.ZodDefault<z.ZodString>;
+    user_id: z.ZodDefault<z.ZodString>;
+    project_id: z.ZodDefault<z.ZodString>;
+    workspace_id: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+export type SessionInfo = z.infer<typeof SessionInfoSchema>;
+/** Response for sessions list query (used by API Gateway proxy). */
+export declare const SessionsQueryResponseSchema: z.ZodObject<{
+    sessions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        session_id: z.ZodString;
+        last_activity: z.ZodString;
+        created_at: z.ZodString;
+        message_count: z.ZodDefault<z.ZodNumber>;
+        last_message_preview: z.ZodDefault<z.ZodString>;
+        visibility: z.ZodDefault<z.ZodString>;
+        user_id: z.ZodDefault<z.ZodString>;
+        project_id: z.ZodDefault<z.ZodString>;
+        workspace_id: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>>;
+    total_count: z.ZodDefault<z.ZodNumber>;
+    offset: z.ZodDefault<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type SessionsQueryResponse = z.infer<typeof SessionsQueryResponseSchema>;
+/** A single message within a session. */
+export declare const SessionMessageSchema: z.ZodObject<{
+    id: z.ZodString;
+    role: z.ZodString;
+    content: z.ZodString;
+    timestamp: z.ZodString;
+    session_id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    tool_calls: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodPipe<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        args: z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+        arguments: z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+        type: z.ZodOptional<z.ZodString>;
+        index: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodTransform<LLMToolCall, {
+        id?: string | undefined;
+        name?: string | undefined;
+        args?: JsonValue | undefined;
+        arguments?: JsonValue | undefined;
+        type?: string | undefined;
+        index?: number | undefined;
+    }>>>>>;
+    tool_call_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type SessionMessage = z.infer<typeof SessionMessageSchema>;
+/** Response for session messages query (used by API Gateway proxy). */
+export declare const SessionMessagesQueryResponseSchema: z.ZodObject<{
+    messages: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        role: z.ZodString;
+        content: z.ZodString;
+        timestamp: z.ZodString;
+        session_id: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        tool_calls: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodPipe<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+            args: z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+            arguments: z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+            type: z.ZodOptional<z.ZodString>;
+            index: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodTransform<LLMToolCall, {
+            id?: string | undefined;
+            name?: string | undefined;
+            args?: JsonValue | undefined;
+            arguments?: JsonValue | undefined;
+            type?: string | undefined;
+            index?: number | undefined;
+        }>>>>>;
+        tool_call_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type SessionMessagesQueryResponse = z.infer<typeof SessionMessagesQueryResponseSchema>;
+/** Aggregate cost metrics for the requested period. */
+export declare const CostSummarySchema: z.ZodObject<{
+    total_cost_usd: z.ZodDefault<z.ZodNumber>;
+    total_tokens: z.ZodDefault<z.ZodNumber>;
+    total_prompt_tokens: z.ZodDefault<z.ZodNumber>;
+    total_completion_tokens: z.ZodDefault<z.ZodNumber>;
+    total_llm_calls: z.ZodDefault<z.ZodNumber>;
+    unpriced_llm_calls: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type CostSummary = z.infer<typeof CostSummarySchema>;
+/** Cost breakdown for a single workspace. */
+export declare const CostByWorkspaceSchema: z.ZodObject<{
+    workspace_id: z.ZodString;
+    total_cost_usd: z.ZodDefault<z.ZodNumber>;
+    total_tokens: z.ZodDefault<z.ZodNumber>;
+    call_count: z.ZodDefault<z.ZodNumber>;
+    percentage: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type CostByWorkspace = z.infer<typeof CostByWorkspaceSchema>;
+/** Cost breakdown for a single model. */
+export declare const CostByModelSchema: z.ZodObject<{
+    model: z.ZodString;
+    total_cost_usd: z.ZodDefault<z.ZodNumber>;
+    total_tokens: z.ZodDefault<z.ZodNumber>;
+    call_count: z.ZodDefault<z.ZodNumber>;
+    percentage: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type CostByModel = z.infer<typeof CostByModelSchema>;
+/** Cost data for a single day. */
+export declare const DailyCostEntrySchema: z.ZodObject<{
+    date: z.ZodString;
+    total_cost_usd: z.ZodDefault<z.ZodNumber>;
+    total_tokens: z.ZodDefault<z.ZodNumber>;
+    call_count: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type DailyCostEntry = z.infer<typeof DailyCostEntrySchema>;
+/** Response for cost dashboard aggregation (used by API Gateway proxy). */
+export declare const CostDashboardResponseSchema: z.ZodObject<{
+    summary: z.ZodDefault<z.ZodObject<{
+        total_cost_usd: z.ZodDefault<z.ZodNumber>;
+        total_tokens: z.ZodDefault<z.ZodNumber>;
+        total_prompt_tokens: z.ZodDefault<z.ZodNumber>;
+        total_completion_tokens: z.ZodDefault<z.ZodNumber>;
+        total_llm_calls: z.ZodDefault<z.ZodNumber>;
+        unpriced_llm_calls: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    by_workspace: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        workspace_id: z.ZodString;
+        total_cost_usd: z.ZodDefault<z.ZodNumber>;
+        total_tokens: z.ZodDefault<z.ZodNumber>;
+        call_count: z.ZodDefault<z.ZodNumber>;
+        percentage: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    by_model: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        model: z.ZodString;
+        total_cost_usd: z.ZodDefault<z.ZodNumber>;
+        total_tokens: z.ZodDefault<z.ZodNumber>;
+        call_count: z.ZodDefault<z.ZodNumber>;
+        percentage: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    daily_trend: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        date: z.ZodString;
+        total_cost_usd: z.ZodDefault<z.ZodNumber>;
+        total_tokens: z.ZodDefault<z.ZodNumber>;
+        call_count: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type CostDashboardResponse = z.infer<typeof CostDashboardResponseSchema>;
+/** An execution document as stored in the platform database. */
+export declare const ExecutionDocumentSchema: z.ZodObject<{
+    execution_id: z.ZodString;
+    status: z.ZodDefault<z.ZodString>;
+    message: z.ZodDefault<z.ZodString>;
+    session_id: z.ZodDefault<z.ZodString>;
+    user_id: z.ZodDefault<z.ZodString>;
+    org_id: z.ZodDefault<z.ZodString>;
+    project_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    workspace_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    result: z.ZodOptional<z.ZodUnknown>;
+    error: z.ZodOptional<z.ZodString>;
+    suspend_reason: z.ZodOptional<z.ZodString>;
+    suspend_context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    created_at: z.ZodOptional<z.ZodString>;
+    updated_at: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ExecutionDocument = z.infer<typeof ExecutionDocumentSchema>;
+/** Response for executions list query (used by API Gateway proxy). */
+export declare const ExecutionsListQueryResponseSchema: z.ZodObject<{
+    success: z.ZodDefault<z.ZodBoolean>;
+    executions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        execution_id: z.ZodString;
+        status: z.ZodDefault<z.ZodString>;
+        message: z.ZodDefault<z.ZodString>;
+        session_id: z.ZodDefault<z.ZodString>;
+        user_id: z.ZodDefault<z.ZodString>;
+        org_id: z.ZodDefault<z.ZodString>;
+        project_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        workspace_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        result: z.ZodOptional<z.ZodUnknown>;
+        error: z.ZodOptional<z.ZodString>;
+        suspend_reason: z.ZodOptional<z.ZodString>;
+        suspend_context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        created_at: z.ZodOptional<z.ZodString>;
+        updated_at: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    count: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type ExecutionsListQueryResponse = z.infer<typeof ExecutionsListQueryResponseSchema>;
+/** Response for single execution detail query (used by API Gateway proxy). */
+export declare const ExecutionDetailQueryResponseSchema: z.ZodObject<{
+    success: z.ZodDefault<z.ZodBoolean>;
+    execution: z.ZodOptional<z.ZodObject<{
+        execution_id: z.ZodString;
+        status: z.ZodDefault<z.ZodString>;
+        message: z.ZodDefault<z.ZodString>;
+        session_id: z.ZodDefault<z.ZodString>;
+        user_id: z.ZodDefault<z.ZodString>;
+        org_id: z.ZodDefault<z.ZodString>;
+        project_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        workspace_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        result: z.ZodOptional<z.ZodUnknown>;
+        error: z.ZodOptional<z.ZodString>;
+        suspend_reason: z.ZodOptional<z.ZodString>;
+        suspend_context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        created_at: z.ZodOptional<z.ZodString>;
+        updated_at: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ExecutionDetailQueryResponse = z.infer<typeof ExecutionDetailQueryResponseSchema>;
+/**
+ * Report node execution event (AER → OE for logging).
+ */
+export declare const NodeExecutionRequestSchema: z.ZodObject<{
+    execution_id: z.ZodString;
+    node_name: z.ZodString;
+    status: z.ZodString;
+    timestamp: z.ZodCoercedDate<unknown>;
+    run_id: z.ZodString;
+    parent_run_id: z.ZodOptional<z.ZodString>;
+    session_id: z.ZodOptional<z.ZodString>;
+    user_id: z.ZodOptional<z.ZodString>;
+    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    error: z.ZodOptional<z.ZodString>;
+    duration_ms: z.ZodOptional<z.ZodNumber>;
+    org_id: z.ZodOptional<z.ZodString>;
+    project_id: z.ZodOptional<z.ZodString>;
+    trace_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    span_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type NodeExecutionRequest = z.infer<typeof NodeExecutionRequestSchema>;
+export type { Message, ToolCallChunk, JsonValue };
+export { LLMResponse, LLMTokenUsage, LLMToolCall, LLMToolSchema, LLMInvocationOptions, };
+//# sourceMappingURL=models.d.ts.map