@meistrari/chat-nuxt 4.9.0 → 4.10.0-rc.1

package/dist/runtime/types/schemas/integrations/agent-events.d.ts

@@ -0,0 +1,901 @@
+import { z } from 'zod';
+/**
+ * Agent events: client-side mirror of the agent-api v5 events-v1 contract (`packages/models` in
+ * meistrari/agent-api). Responses are parsed as loose objects so a field the API adds
+ * later never breaks the chat; requests keep the API's own limits so a bad payload is
+ * refused here, before it travels.
+ */
+export declare const v5Limits: {
+    readonly messageTextChars: 200000;
+    readonly inputTextChars: 800000;
+    readonly userEventBytes: 1048576;
+    readonly inlinePayloadBytes: 16384;
+    readonly eventsPerRequest: 32;
+    readonly idempotencyKeyChars: 200;
+    readonly turnIdChars: 200;
+    readonly attributionChars: 200;
+    readonly eventPage: {
+        readonly default: 100;
+        readonly max: 500;
+    };
+    readonly artifactPage: {
+        readonly default: 100;
+        readonly max: 100;
+    };
+    readonly sessionList: 100;
+    readonly turnList: 500;
+    readonly agentList: 100;
+    readonly draftTextChars: 65536;
+    readonly streamHeartbeatMs: 15000;
+};
+/** Every code a v5 route answers in `{ error }`, with its HTTP status. */
+export declare const v5ErrorStatus: {
+    readonly invalid_request: 400;
+    readonly invalid_vault_reference: 400;
+    readonly input_payload_required: 400;
+    readonly invalid_tool_result_answers: 400;
+    readonly cursor_not_found: 400;
+    readonly invalid_event_limit: 400;
+    readonly invalid_artifact_limit: 400;
+    readonly invalid_user_event_batch: 400;
+    readonly provider_harness_mismatch: 400;
+    readonly insufficient_role: 403;
+    readonly agent_publication_forbidden: 403;
+    readonly session_not_found: 404;
+    readonly agent_not_found: 404;
+    readonly snapshot_not_found: 404;
+    readonly event_not_found: 404;
+    readonly message_not_found: 404;
+    readonly turn_not_found: 404;
+    readonly artifact_not_found: 404;
+    readonly repository_not_found: 404;
+    readonly commit_not_found: 404;
+    readonly content_unavailable: 404;
+    readonly idempotency_conflict: 409;
+    readonly agent_not_published: 409;
+    readonly snapshot_not_ready: 409;
+    readonly snapshot_protected: 409;
+    readonly snapshot_build_in_progress: 409;
+    readonly session_closed: 409;
+    readonly turn_not_running: 409;
+    readonly user_event_already_dispatched: 409;
+    readonly invalid_tool_result: 409;
+    readonly repository_ambiguous: 409;
+    readonly user_event_too_large: 413;
+    readonly request_too_large: 413;
+    readonly payload_not_offloaded: 413;
+    readonly agent_config_invalid: 422;
+    readonly model_not_on_provider: 422;
+    readonly internal_error: 500;
+    readonly session_vault_unavailable: 503;
+    readonly detached_delivery_unavailable: 503;
+    readonly content_storage_unavailable: 503;
+    readonly artifact_storage_unavailable: 503;
+    readonly snapshot_publishing_unavailable: 503;
+};
+export type V5ErrorCode = keyof typeof v5ErrorStatus;
+export declare const v5ErrorBodySchema: z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>;
+export declare const v5EventIdSchema: z.ZodString;
+export declare const v5TurnIdSchema: z.ZodString;
+export declare const v5HarnessSchema: z.ZodEnum<{
+    claude: "claude";
+    lightweight: "lightweight";
+    codex: "codex";
+}>;
+export declare const v5SessionStatusSchema: z.ZodEnum<{
+    running: "running";
+    failed: "failed";
+    ready: "ready";
+    initializing: "initializing";
+    paused: "paused";
+    detached: "detached";
+    closing: "closing";
+    closed: "closed";
+}>;
+export declare const v5UserEventStatusSchema: z.ZodEnum<{
+    running: "running";
+    completed: "completed";
+    failed: "failed";
+    cancelled: "cancelled";
+    queued: "queued";
+    dispatched: "dispatched";
+    received: "received";
+    uncertain: "uncertain";
+}>;
+export declare const v5UserEventTypeSchema: z.ZodEnum<{
+    input: "input";
+    "tool-result": "tool-result";
+    "message-queue": "message-queue";
+    "message-steer": "message-steer";
+    cancel: "cancel";
+}>;
+export declare const VAULT_REFERENCE_PREFIX = "vault://";
+export declare function isVaultReference(payload: string): boolean;
+export declare const v5VaultReferenceSchema: z.ZodString;
+/** A user event as the client sends it: a message, a steer, an input, a cancel or an answer. */
+export declare const v5UserEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"message-queue">;
+    payload: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"message-steer">;
+    turnId: z.ZodString;
+    payload: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"input">;
+    name: z.ZodOptional<z.ZodString>;
+    payload: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"cancel">;
+    turnId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"tool-result">;
+    toolCallId: z.ZodString;
+    payload: z.ZodString;
+}, z.core.$strict>], "type">;
+export type V5UserEvent = z.infer<typeof v5UserEventSchema>;
+export declare const v5EventsRequestSchema: z.ZodObject<{
+    events: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"message-queue">;
+        payload: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"message-steer">;
+        turnId: z.ZodString;
+        payload: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"input">;
+        name: z.ZodOptional<z.ZodString>;
+        payload: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"cancel">;
+        turnId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"tool-result">;
+        toolCallId: z.ZodString;
+        payload: z.ZodString;
+    }, z.core.$strict>], "type">>;
+}, z.core.$strict>;
+export type V5EventsRequest = z.infer<typeof v5EventsRequestSchema>;
+export declare const v5EventReceiptSchema: z.ZodObject<{
+    eventId: z.ZodString;
+    type: z.ZodEnum<{
+        input: "input";
+        "tool-result": "tool-result";
+        "message-queue": "message-queue";
+        "message-steer": "message-steer";
+        cancel: "cancel";
+    }>;
+    messageId: z.ZodOptional<z.ZodString>;
+    sessionId: z.ZodString;
+    turnId: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        running: "running";
+        completed: "completed";
+        failed: "failed";
+        cancelled: "cancelled";
+        queued: "queued";
+        dispatched: "dispatched";
+        received: "received";
+        uncertain: "uncertain";
+    }>;
+}, z.core.$loose>;
+export type V5EventReceipt = z.infer<typeof v5EventReceiptSchema>;
+export declare const v5EventsReceiptSchema: z.ZodObject<{
+    events: z.ZodArray<z.ZodObject<{
+        eventId: z.ZodString;
+        type: z.ZodEnum<{
+            input: "input";
+            "tool-result": "tool-result";
+            "message-queue": "message-queue";
+            "message-steer": "message-steer";
+            cancel: "cancel";
+        }>;
+        messageId: z.ZodOptional<z.ZodString>;
+        sessionId: z.ZodString;
+        turnId: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<{
+            running: "running";
+            completed: "completed";
+            failed: "failed";
+            cancelled: "cancelled";
+            queued: "queued";
+            dispatched: "dispatched";
+            received: "received";
+            uncertain: "uncertain";
+        }>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+/**
+ * Hints of the stored event types the chat reads. Unknown types still parse (the type is an open
+ * string); `parseV5EventHint` gives the typed hint for the ones listed here.
+ */
+export declare const v5EventHintSchemas: {
+    readonly 'session.initializing': z.ZodObject<{
+        executionMode: z.ZodOptional<z.ZodEnum<{
+            chat: "chat";
+            sync: "sync";
+            async: "async";
+        }>>;
+        resumed: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$loose>;
+    readonly 'session.ready': z.ZodObject<{
+        resumed: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$loose>;
+    readonly 'session.suspending': z.ZodObject<{}, z.core.$loose>;
+    readonly 'session.paused': z.ZodObject<{}, z.core.$loose>;
+    readonly 'session.closing': z.ZodObject<{}, z.core.$loose>;
+    readonly 'session.closed': z.ZodObject<{}, z.core.$loose>;
+    readonly 'session.failed': z.ZodObject<{
+        error: z.ZodString;
+    }, z.core.$loose>;
+    readonly 'user_event.admitted': z.ZodObject<{
+        eventId: z.ZodString;
+        inputType: z.ZodEnum<{
+            input: "input";
+            "tool-result": "tool-result";
+            "message-queue": "message-queue";
+            "message-steer": "message-steer";
+            cancel: "cancel";
+        }>;
+        status: z.ZodLiteral<"queued">;
+    }, z.core.$loose>;
+    readonly 'user_event.received': z.ZodObject<{
+        eventId: z.ZodOptional<z.ZodString>;
+        status: z.ZodLiteral<"received">;
+    }, z.core.$loose>;
+    readonly 'user_event.completed': z.ZodObject<{
+        eventId: z.ZodOptional<z.ZodString>;
+        status: z.ZodLiteral<"completed">;
+    }, z.core.$loose>;
+    readonly 'user_event.failed': z.ZodObject<{
+        eventId: z.ZodOptional<z.ZodString>;
+        status: z.ZodLiteral<"failed">;
+        error: z.ZodOptional<z.ZodString>;
+        errorCode: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+    readonly 'user_event.cancelled': z.ZodObject<{
+        eventId: z.ZodOptional<z.ZodString>;
+        status: z.ZodLiteral<"cancelled">;
+    }, z.core.$loose>;
+    readonly 'user_event.uncertain': z.ZodObject<{
+        eventId: z.ZodOptional<z.ZodString>;
+        status: z.ZodLiteral<"uncertain">;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+    readonly message: z.ZodObject<{
+        mode: z.ZodEnum<{
+            queue: "queue";
+            steer: "steer";
+            answer: "answer";
+        }>;
+        status: z.ZodLiteral<"running">;
+        inputSnapshot: z.ZodNumber;
+        model: z.ZodString;
+        reasoningEffort: z.ZodNullable<z.ZodString>;
+    }, z.core.$loose>;
+    readonly 'message.pending': z.ZodObject<{
+        status: z.ZodEnum<{
+            running: "running";
+            completed: "completed";
+            failed: "failed";
+            cancelled: "cancelled";
+            queued: "queued";
+            dispatched: "dispatched";
+            received: "received";
+            uncertain: "uncertain";
+        }>;
+    }, z.core.$loose>;
+    readonly input: z.ZodObject<{
+        eventId: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+    }, z.core.$loose>;
+    readonly 'assistant.text': z.ZodObject<{
+        stepId: z.ZodString;
+        partIndex: z.ZodNumber;
+        partCount: z.ZodNumber;
+    }, z.core.$loose>;
+    readonly step: z.ZodObject<{
+        title: z.ZodString;
+        status: z.ZodString;
+        step: z.ZodObject<{
+            kind: z.ZodOptional<z.ZodEnum<{
+                message: "message";
+                reasoning: "reasoning";
+                tool: "tool";
+            }>>;
+            toolName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            status: z.ZodOptional<z.ZodString>;
+            preview: z.ZodOptional<z.ZodString>;
+            startedAt: z.ZodOptional<z.ZodString>;
+            endedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$loose>;
+    }, z.core.$loose>;
+    readonly usage: z.ZodObject<{
+        provider: z.ZodOptional<z.ZodString>;
+        usageScope: z.ZodString;
+    }, z.core.$loose>;
+    readonly 'user_input.requested': z.ZodObject<{
+        requestId: z.ZodString;
+        questionCount: z.ZodNumber;
+        contentOmitted: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$loose>;
+    readonly 'user_input.resolved': z.ZodObject<{
+        requestId: z.ZodString;
+        userEventId: z.ZodString;
+    }, z.core.$loose>;
+    readonly 'turn.completed': z.ZodObject<{
+        status: z.ZodLiteral<"completed">;
+    }, z.core.$loose>;
+    readonly 'turn.failed': z.ZodObject<{
+        status: z.ZodLiteral<"failed">;
+        error: z.ZodOptional<z.ZodString>;
+        reason: z.ZodOptional<z.ZodString>;
+        errorCode: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+    readonly 'turn.cancelled': z.ZodObject<{
+        status: z.ZodLiteral<"cancelled">;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+    readonly 'turn.uncertain': z.ZodObject<{
+        status: z.ZodLiteral<"uncertain">;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+    readonly 'artifact.published': z.ZodObject<{
+        artifactId: z.ZodString;
+        filename: z.ZodString;
+        byteSize: z.ZodNumber;
+        sha256: z.ZodString;
+        kind: z.ZodEnum<{
+            file: "file";
+            result: "result";
+        }>;
+        validationError: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+};
+export type V5KnownEventType = keyof typeof v5EventHintSchemas;
+export type V5EventHint<T extends V5KnownEventType> = z.infer<typeof v5EventHintSchemas[T]>;
+export declare function isKnownV5EventType(type: string): type is V5KnownEventType;
+/** The typed hint of a known event, or `null` when the type is unknown or the hint does not match. */
+export declare function parseV5EventHint<T extends V5KnownEventType>(type: T, hint: unknown): V5EventHint<T> | null;
+/** The question an agent asked (`user_input.requested`), as its event text decodes. */
+export declare const v5UserInputRequestSchema: z.ZodObject<{
+    prompt: z.ZodOptional<z.ZodString>;
+    questions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        type: z.ZodEnum<{
+            text: "text";
+            single_select: "single_select";
+        }>;
+        placeholder: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            value: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export type V5UserInputRequest = z.infer<typeof v5UserInputRequestSchema>;
+export declare const v5SessionEventSchema: z.ZodObject<{
+    eventId: z.ZodString;
+    sessionId: z.ZodString;
+    type: z.ZodString;
+    turnId: z.ZodNullable<z.ZodString>;
+    messageId: z.ZodNullable<z.ZodString>;
+    toolCallId: z.ZodNullable<z.ZodString>;
+    occurredAt: z.ZodString;
+    hint: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    text: z.ZodNullable<z.ZodString>;
+    partIndex: z.ZodNullable<z.ZodNumber>;
+    partCount: z.ZodNullable<z.ZodNumber>;
+    payloadVaultStatus: z.ZodEnum<{
+        pending: "pending";
+        none: "none";
+        published: "published";
+    }>;
+    receipt: z.ZodOptional<z.ZodObject<{
+        eventId: z.ZodString;
+        type: z.ZodEnum<{
+            input: "input";
+            "tool-result": "tool-result";
+            "message-queue": "message-queue";
+            "message-steer": "message-steer";
+            cancel: "cancel";
+        }>;
+        messageId: z.ZodOptional<z.ZodString>;
+        sessionId: z.ZodString;
+        turnId: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<{
+            running: "running";
+            completed: "completed";
+            failed: "failed";
+            cancelled: "cancelled";
+            queued: "queued";
+            dispatched: "dispatched";
+            received: "received";
+            uncertain: "uncertain";
+        }>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export type V5SessionEvent = z.infer<typeof v5SessionEventSchema>;
+/** Transient cumulative text of one step, relayed live without an id; never advances the cursor. */
+export declare const v5EventDraftSchema: z.ZodObject<{
+    kind: z.ZodDefault<z.ZodEnum<{
+        message: "message";
+        reasoning: "reasoning";
+    }>>;
+    messageId: z.ZodString;
+    turnId: z.ZodString;
+    afterEventId: z.ZodString;
+    sourceId: z.ZodString;
+    stepId: z.ZodString;
+    generation: z.ZodNumber;
+    revision: z.ZodNumber;
+    text: z.ZodString;
+}, z.core.$loose>;
+export type V5EventDraft = z.infer<typeof v5EventDraftSchema>;
+export declare const v5EventPageSchema: z.ZodObject<{
+    events: z.ZodArray<z.ZodObject<{
+        eventId: z.ZodString;
+        sessionId: z.ZodString;
+        type: z.ZodString;
+        turnId: z.ZodNullable<z.ZodString>;
+        messageId: z.ZodNullable<z.ZodString>;
+        toolCallId: z.ZodNullable<z.ZodString>;
+        occurredAt: z.ZodString;
+        hint: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        text: z.ZodNullable<z.ZodString>;
+        partIndex: z.ZodNullable<z.ZodNumber>;
+        partCount: z.ZodNullable<z.ZodNumber>;
+        payloadVaultStatus: z.ZodEnum<{
+            pending: "pending";
+            none: "none";
+            published: "published";
+        }>;
+        receipt: z.ZodOptional<z.ZodObject<{
+            eventId: z.ZodString;
+            type: z.ZodEnum<{
+                input: "input";
+                "tool-result": "tool-result";
+                "message-queue": "message-queue";
+                "message-steer": "message-steer";
+                cancel: "cancel";
+            }>;
+            messageId: z.ZodOptional<z.ZodString>;
+            sessionId: z.ZodString;
+            turnId: z.ZodNullable<z.ZodString>;
+            status: z.ZodEnum<{
+                running: "running";
+                completed: "completed";
+                failed: "failed";
+                cancelled: "cancelled";
+                queued: "queued";
+                dispatched: "dispatched";
+                received: "received";
+                uncertain: "uncertain";
+            }>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+    hasMore: z.ZodBoolean;
+}, z.core.$loose>;
+export type V5EventPage = z.infer<typeof v5EventPageSchema>;
+export declare const v5EventQuerySchema: z.ZodObject<{
+    after: z.ZodOptional<z.ZodString>;
+    before: z.ZodOptional<z.ZodString>;
+    messageId: z.ZodOptional<z.ZodString>;
+    turnId: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type V5EventQuery = z.infer<typeof v5EventQuerySchema>;
+/** One frame of the live event stream: a stored event (with its id), a draft, or a heartbeat. */
+export declare const v5EventStreamFrameSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"event">;
+    event: z.ZodObject<{
+        eventId: z.ZodString;
+        sessionId: z.ZodString;
+        type: z.ZodString;
+        turnId: z.ZodNullable<z.ZodString>;
+        messageId: z.ZodNullable<z.ZodString>;
+        toolCallId: z.ZodNullable<z.ZodString>;
+        occurredAt: z.ZodString;
+        hint: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        text: z.ZodNullable<z.ZodString>;
+        partIndex: z.ZodNullable<z.ZodNumber>;
+        partCount: z.ZodNullable<z.ZodNumber>;
+        payloadVaultStatus: z.ZodEnum<{
+            pending: "pending";
+            none: "none";
+            published: "published";
+        }>;
+        receipt: z.ZodOptional<z.ZodObject<{
+            eventId: z.ZodString;
+            type: z.ZodEnum<{
+                input: "input";
+                "tool-result": "tool-result";
+                "message-queue": "message-queue";
+                "message-steer": "message-steer";
+                cancel: "cancel";
+            }>;
+            messageId: z.ZodOptional<z.ZodString>;
+            sessionId: z.ZodString;
+            turnId: z.ZodNullable<z.ZodString>;
+            status: z.ZodEnum<{
+                running: "running";
+                completed: "completed";
+                failed: "failed";
+                cancelled: "cancelled";
+                queued: "queued";
+                dispatched: "dispatched";
+                received: "received";
+                uncertain: "uncertain";
+            }>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"draft">;
+    draft: z.ZodObject<{
+        kind: z.ZodDefault<z.ZodEnum<{
+            message: "message";
+            reasoning: "reasoning";
+        }>>;
+        messageId: z.ZodString;
+        turnId: z.ZodString;
+        afterEventId: z.ZodString;
+        sourceId: z.ZodString;
+        stepId: z.ZodString;
+        generation: z.ZodNumber;
+        revision: z.ZodNumber;
+        text: z.ZodString;
+    }, z.core.$loose>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"heartbeat">;
+}, z.core.$strip>], "kind">;
+export type V5EventStreamFrame = z.infer<typeof v5EventStreamFrameSchema>;
+export declare const v5SessionSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    agentId: z.ZodString;
+    snapshotId: z.ZodString;
+    harness: z.ZodEnum<{
+        claude: "claude";
+        lightweight: "lightweight";
+        codex: "codex";
+    }>;
+    status: z.ZodEnum<{
+        running: "running";
+        failed: "failed";
+        ready: "ready";
+        initializing: "initializing";
+        paused: "paused";
+        detached: "detached";
+        closing: "closing";
+        closed: "closed";
+    }>;
+    executionMode: z.ZodEnum<{
+        chat: "chat";
+        sync: "sync";
+        async: "async";
+    }>;
+    runtime: z.ZodObject<{
+        state: z.ZodString;
+    }, z.core.$loose>;
+    configuration: z.ZodObject<{
+        harness: z.ZodEnum<{
+            claude: "claude";
+            lightweight: "lightweight";
+            codex: "codex";
+        }>;
+        model: z.ZodOptional<z.ZodString>;
+        provider: z.ZodOptional<z.ZodString>;
+        effort: z.ZodOptional<z.ZodString>;
+        commitSha: z.ZodString;
+        repository: z.ZodString;
+    }, z.core.$loose>;
+    effectiveModelSettings: z.ZodNullable<z.ZodObject<{
+        model: z.ZodString;
+        reasoningEffort: z.ZodNullable<z.ZodString>;
+    }, z.core.$loose>>;
+    createdAt: z.ZodString;
+}, z.core.$loose>;
+export type V5Session = z.infer<typeof v5SessionSchema>;
+export declare const v5SessionListSchema: z.ZodObject<{
+    sessions: z.ZodArray<z.ZodObject<{
+        sessionId: z.ZodString;
+        agentId: z.ZodString;
+        snapshotId: z.ZodString;
+        harness: z.ZodEnum<{
+            claude: "claude";
+            lightweight: "lightweight";
+            codex: "codex";
+        }>;
+        status: z.ZodEnum<{
+            running: "running";
+            failed: "failed";
+            ready: "ready";
+            initializing: "initializing";
+            paused: "paused";
+            detached: "detached";
+            closing: "closing";
+            closed: "closed";
+        }>;
+        executionMode: z.ZodEnum<{
+            chat: "chat";
+            sync: "sync";
+            async: "async";
+        }>;
+        runtime: z.ZodObject<{
+            state: z.ZodString;
+        }, z.core.$loose>;
+        configuration: z.ZodObject<{
+            harness: z.ZodEnum<{
+                claude: "claude";
+                lightweight: "lightweight";
+                codex: "codex";
+            }>;
+            model: z.ZodOptional<z.ZodString>;
+            provider: z.ZodOptional<z.ZodString>;
+            effort: z.ZodOptional<z.ZodString>;
+            commitSha: z.ZodString;
+            repository: z.ZodString;
+        }, z.core.$loose>;
+        effectiveModelSettings: z.ZodNullable<z.ZodObject<{
+            model: z.ZodString;
+            reasoningEffort: z.ZodNullable<z.ZodString>;
+        }, z.core.$loose>>;
+        createdAt: z.ZodString;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+/** Creation admits the session and its first queued messages and inputs in one idempotent request. */
+export declare const v5SessionCreateSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    snapshotId: z.ZodOptional<z.ZodString>;
+    commitHash: z.ZodOptional<z.ZodString>;
+    executionMode: z.ZodOptional<z.ZodEnum<{
+        chat: "chat";
+        sync: "sync";
+        async: "async";
+    }>>;
+    events: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"message-queue">;
+        payload: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"message-steer">;
+        turnId: z.ZodString;
+        payload: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"input">;
+        name: z.ZodOptional<z.ZodString>;
+        payload: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"cancel">;
+        turnId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"tool-result">;
+        toolCallId: z.ZodString;
+        payload: z.ZodString;
+    }, z.core.$strict>], "type">>>;
+    telaAgentId: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export type V5SessionCreate = z.infer<typeof v5SessionCreateSchema>;
+export declare const v5SessionCreationReceiptSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    snapshotId: z.ZodString;
+    status: z.ZodEnum<{
+        running: "running";
+        failed: "failed";
+        ready: "ready";
+        initializing: "initializing";
+        paused: "paused";
+        detached: "detached";
+        closing: "closing";
+        closed: "closed";
+    }>;
+    events: z.ZodArray<z.ZodObject<{
+        eventId: z.ZodString;
+        type: z.ZodEnum<{
+            input: "input";
+            "tool-result": "tool-result";
+            "message-queue": "message-queue";
+            "message-steer": "message-steer";
+            cancel: "cancel";
+        }>;
+        messageId: z.ZodOptional<z.ZodString>;
+        sessionId: z.ZodString;
+        turnId: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<{
+            running: "running";
+            completed: "completed";
+            failed: "failed";
+            cancelled: "cancelled";
+            queued: "queued";
+            dispatched: "dispatched";
+            received: "received";
+            uncertain: "uncertain";
+        }>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export type V5SessionCreationReceipt = z.infer<typeof v5SessionCreationReceiptSchema>;
+export declare const v5SessionClosureReceiptSchema: z.ZodObject<{
+    status: z.ZodLiteral<"closing">;
+}, z.core.$loose>;
+export declare const v5AgentSnapshotSchema: z.ZodObject<{
+    snapshotId: z.ZodString;
+    commitSha: z.ZodString;
+    purpose: z.ZodEnum<{
+        publication: "publication";
+        iteration: "iteration";
+    }>;
+    status: z.ZodEnum<{
+        failed: "failed";
+        ready: "ready";
+        building: "building";
+        superseded: "superseded";
+        unbuilt: "unbuilt";
+    }>;
+    readyAt: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+}, z.core.$loose>;
+export type V5AgentSnapshot = z.infer<typeof v5AgentSnapshotSchema>;
+/** A catalog agent; `repository` is `organization/repository`, the same coordinates Tela knows. */
+export declare const v5AgentSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    repository: z.ZodString;
+    defaultBranch: z.ZodString;
+    publishedSnapshotId: z.ZodNullable<z.ZodString>;
+    publishedCommitSha: z.ZodNullable<z.ZodString>;
+    harness: z.ZodNullable<z.ZodEnum<{
+        claude: "claude";
+        lightweight: "lightweight";
+        codex: "codex";
+    }>>;
+    model: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$loose>;
+export type V5Agent = z.infer<typeof v5AgentSchema>;
+export declare const v5AgentDetailSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    repository: z.ZodString;
+    defaultBranch: z.ZodString;
+    publishedSnapshotId: z.ZodNullable<z.ZodString>;
+    publishedCommitSha: z.ZodNullable<z.ZodString>;
+    harness: z.ZodNullable<z.ZodEnum<{
+        claude: "claude";
+        lightweight: "lightweight";
+        codex: "codex";
+    }>>;
+    model: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    snapshots: z.ZodArray<z.ZodObject<{
+        snapshotId: z.ZodString;
+        commitSha: z.ZodString;
+        purpose: z.ZodEnum<{
+            publication: "publication";
+            iteration: "iteration";
+        }>;
+        status: z.ZodEnum<{
+            failed: "failed";
+            ready: "ready";
+            building: "building";
+            superseded: "superseded";
+            unbuilt: "unbuilt";
+        }>;
+        readyAt: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodString;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export type V5AgentDetail = z.infer<typeof v5AgentDetailSchema>;
+export declare const v5AgentListSchema: z.ZodObject<{
+    agents: z.ZodArray<z.ZodObject<{
+        agentId: z.ZodString;
+        repository: z.ZodString;
+        defaultBranch: z.ZodString;
+        publishedSnapshotId: z.ZodNullable<z.ZodString>;
+        publishedCommitSha: z.ZodNullable<z.ZodString>;
+        harness: z.ZodNullable<z.ZodEnum<{
+            claude: "claude";
+            lightweight: "lightweight";
+            codex: "codex";
+        }>>;
+        model: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export declare const v5SnapshotPublishSchema: z.ZodObject<{
+    organizationName: z.ZodString;
+    repository: z.ZodString;
+    commit: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const v5SnapshotPublicationSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    snapshot: z.ZodObject<{
+        snapshotId: z.ZodString;
+        commitSha: z.ZodString;
+        purpose: z.ZodEnum<{
+            publication: "publication";
+            iteration: "iteration";
+        }>;
+        status: z.ZodEnum<{
+            failed: "failed";
+            ready: "ready";
+            building: "building";
+            superseded: "superseded";
+            unbuilt: "unbuilt";
+        }>;
+        readyAt: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodString;
+        error: z.ZodNullable<z.ZodString>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export type V5SnapshotPublication = z.infer<typeof v5SnapshotPublicationSchema>;
+export declare const v5TurnSchema: z.ZodObject<{
+    turnId: z.ZodString;
+    status: z.ZodEnum<{
+        running: "running";
+        completed: "completed";
+        failed: "failed";
+        cancelled: "cancelled";
+        uncertain: "uncertain";
+    }>;
+    usage: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    error: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+    completedAt: z.ZodNullable<z.ZodString>;
+}, z.core.$loose>;
+export type V5Turn = z.infer<typeof v5TurnSchema>;
+export declare const v5TurnListSchema: z.ZodObject<{
+    turns: z.ZodArray<z.ZodObject<{
+        turnId: z.ZodString;
+        status: z.ZodEnum<{
+            running: "running";
+            completed: "completed";
+            failed: "failed";
+            cancelled: "cancelled";
+            uncertain: "uncertain";
+        }>;
+        usage: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        error: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodString;
+        completedAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export declare const v5ArtifactIdSchema: z.ZodString;
+export declare const v5ArtifactSchema: z.ZodObject<{
+    artifactId: z.ZodString;
+    turnId: z.ZodString;
+    filename: z.ZodString;
+    byteSize: z.ZodNumber;
+    sha256: z.ZodString;
+    eventId: z.ZodString;
+    messageId: z.ZodString;
+    stepId: z.ZodNullable<z.ZodString>;
+    mediaType: z.ZodString;
+}, z.core.$loose>;
+export type V5Artifact = z.infer<typeof v5ArtifactSchema>;
+export declare const v5ArtifactPageSchema: z.ZodObject<{
+    artifacts: z.ZodArray<z.ZodObject<{
+        artifactId: z.ZodString;
+        turnId: z.ZodString;
+        filename: z.ZodString;
+        byteSize: z.ZodNumber;
+        sha256: z.ZodString;
+        eventId: z.ZodString;
+        messageId: z.ZodString;
+        stepId: z.ZodNullable<z.ZodString>;
+        mediaType: z.ZodString;
+    }, z.core.$loose>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+    hasMore: z.ZodBoolean;
+}, z.core.$loose>;
+export declare const v5ArtifactQuerySchema: z.ZodObject<{
+    after: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type V5ArtifactQuery = z.infer<typeof v5ArtifactQuerySchema>;