@superdurable/dex-agents 0.0.0-stage → 0.2.0

package/dist/src/agent-session-codecs.js

@@ -0,0 +1,689 @@
+// Copyright (c) 2026 Super Durable, Inc.
+//
+// Licensed under the Sustainable Use License 1.0.
+// You may not use this file except in compliance with the License.
+// See the LICENSE file in the repository root.
+//
+// SPDX-License-Identifier: LicenseRef-Sustainable-Use-1.0
+import { jsonCodec } from "@superdurable/dex";
+// Wire values are snake_case JSON shared with the Python core; TypeScript values are camelCase.
+const agentSessionStatuses = [
+    "waiting_for_user_message",
+    "running_model",
+    "running_tools",
+    "compacting_context",
+];
+const agentMessageRoles = ["user", "assistant", "tool"];
+const toolEffects = [
+    "read",
+    "idempotent_write",
+    "non_idempotent_write",
+    "unclassified",
+];
+const agentToolCallStatuses = [
+    "awaiting_approval",
+    "approved",
+    "awaiting_answer",
+    "waiting_for_timer",
+    "waiting_for_task",
+    "rejected",
+    "succeeded",
+    "failed",
+    "outcome_unknown",
+];
+const agentInterruptKinds = ["tool_approval", "question"];
+const interactionModes = ["chat", "planning", "executing"];
+const planStatuses = ["draft", "active", "completed", "cleared"];
+const planTaskStatuses = ["pending", "in_progress", "completed"];
+const toolCallCancellationReasons = ["steered", "turn_cancelled"];
+const turnControlKinds = ["steer", "cancel_turn"];
+const questionResolutions = ["answered", "declined", "deadline_passed"];
+class WireRecordReader {
+    typeName;
+    record;
+    constructor(value, typeName) {
+        this.typeName = typeName;
+        if (typeof value !== "object" || value === null || Array.isArray(value)) {
+            throw new TypeError(`${typeName} must be a JSON object`);
+        }
+        this.record = value;
+    }
+    readString(field) {
+        const value = this.record[field];
+        if (typeof value !== "string") {
+            throw new TypeError(`${this.typeName}.${field} must be a string`);
+        }
+        return value;
+    }
+    readNullableString(field) {
+        const value = this.record[field];
+        if (value === undefined || value === null) {
+            return null;
+        }
+        if (typeof value !== "string") {
+            throw new TypeError(`${this.typeName}.${field} must be a string or null`);
+        }
+        return value;
+    }
+    readInteger(field) {
+        const value = this.record[field];
+        if (typeof value !== "number" || !Number.isSafeInteger(value)) {
+            throw new TypeError(`${this.typeName}.${field} must be an integer`);
+        }
+        return value;
+    }
+    readIntegerOrDefault(field, defaultValue) {
+        const value = this.record[field];
+        return value === undefined || value === null ? defaultValue : this.readInteger(field);
+    }
+    readNullableInteger(field) {
+        const value = this.record[field];
+        if (value === undefined || value === null) {
+            return null;
+        }
+        return this.readInteger(field);
+    }
+    readBooleanOrDefault(field, defaultValue) {
+        const value = this.record[field];
+        return value === undefined || value === null ? defaultValue : this.readBoolean(field);
+    }
+    readStringArrayOrEmpty(field) {
+        const value = this.record[field];
+        if (value === undefined || value === null) {
+            return [];
+        }
+        if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) {
+            throw new TypeError(`${this.typeName}.${field} must be an array of strings`);
+        }
+        return value;
+    }
+    readArrayOrEmpty(field) {
+        const value = this.record[field];
+        return value === undefined || value === null ? [] : this.readArray(field);
+    }
+    readBoolean(field) {
+        const value = this.record[field];
+        if (typeof value !== "boolean") {
+            throw new TypeError(`${this.typeName}.${field} must be a boolean`);
+        }
+        return value;
+    }
+    readEnumOrDefault(field, allowed, defaultValue) {
+        const value = this.record[field];
+        return value === undefined || value === null ? defaultValue : this.readEnum(field, allowed);
+    }
+    readNullableEnum(field, allowed) {
+        const value = this.record[field];
+        return value === undefined || value === null ? null : this.readEnum(field, allowed);
+    }
+    readEnum(field, allowed) {
+        const value = this.readString(field);
+        if (!allowed.includes(value)) {
+            throw new TypeError(`${this.typeName}.${field} has unknown value ${value}`);
+        }
+        return value;
+    }
+    readArray(field) {
+        const value = this.record[field];
+        if (!Array.isArray(value)) {
+            throw new TypeError(`${this.typeName}.${field} must be an array`);
+        }
+        return value;
+    }
+    readObject(field) {
+        return this.record[field];
+    }
+}
+export function encodeAgentSessionStartInput(value) {
+    return { initial_message: value.initialMessage, session_settings: value.sessionSettings ?? null };
+}
+export function decodeAgentSessionStartInput(value) {
+    if (value === null || value === undefined) {
+        return { initialMessage: null, sessionSettings: null };
+    }
+    const reader = new WireRecordReader(value, "AgentSessionStartInput");
+    const sessionSettings = reader.readObject("session_settings");
+    return {
+        initialMessage: reader.readNullableString("initial_message"),
+        // Kept as sent: StartAgentSession refuses a value that is not an object, failing the session at once.
+        sessionSettings: sessionSettings == null ? null : sessionSettings,
+    };
+}
+export function encodeSessionSettings(value) {
+    return value;
+}
+export function decodeSessionSettings(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new TypeError("SessionSettings must be a JSON object");
+    }
+    return value;
+}
+export function encodeUpdateSessionSettingsRequest(value) {
+    return { session_settings: value.sessionSettings };
+}
+export function decodeUpdateSessionSettingsRequest(value) {
+    const reader = new WireRecordReader(value, "UpdateSessionSettingsRequest");
+    const sessionSettings = reader.readObject("session_settings");
+    // Kept as sent: the RPC returns false for null or a value that is not an object.
+    return { sessionSettings: sessionSettings == null ? null : sessionSettings };
+}
+export function encodeTurnSessionSettings(value) {
+    return { turn_id: value.turnId, session_settings: value.sessionSettings };
+}
+export function decodeTurnSessionSettings(value) {
+    const reader = new WireRecordReader(value, "TurnSessionSettings");
+    return {
+        turnId: reader.readString("turn_id"),
+        sessionSettings: decodeSessionSettings(reader.readObject("session_settings")),
+    };
+}
+export function encodeAgentState(value) {
+    return {
+        status: value.status,
+        turn_count: value.turnCount,
+        active_turn_id: value.activeTurnId,
+        next_message_sequence: value.nextMessageSequence,
+        last_turn_error: value.lastTurnError,
+        interaction_mode: value.interactionMode ?? "chat",
+        accepts_turn_control: value.acceptsTurnControl ?? false,
+    };
+}
+export function decodeAgentState(value) {
+    const reader = new WireRecordReader(value, "AgentState");
+    const interactionMode = reader.readEnumOrDefault("interaction_mode", interactionModes, "chat");
+    const acceptsTurnControl = reader.readBooleanOrDefault("accepts_turn_control", false);
+    return {
+        status: reader.readEnum("status", agentSessionStatuses),
+        turnCount: reader.readInteger("turn_count"),
+        activeTurnId: reader.readNullableString("active_turn_id"),
+        nextMessageSequence: reader.readInteger("next_message_sequence"),
+        lastTurnError: reader.readNullableString("last_turn_error"),
+        // Fields that plans added are omitted at their defaults, so a session without plans decodes to its 0.1.0 shape.
+        ...(interactionMode === "chat" ? {} : { interactionMode }),
+        ...(acceptsTurnControl ? { acceptsTurnControl } : {}),
+    };
+}
+export function encodeAgentMessage(value) {
+    return {
+        sequence: value.sequence,
+        turn_id: value.turnId,
+        role: value.role,
+        text: value.text,
+        tool_call_id: value.toolCallId,
+        tool_name: value.toolName,
+        tool_arguments: value.toolArguments,
+        tool_output: value.toolOutput,
+        framework_item: value.frameworkItem,
+        created_at: value.createdAt,
+    };
+}
+export function decodeAgentMessage(value) {
+    const reader = new WireRecordReader(value, "AgentMessage");
+    return {
+        sequence: reader.readInteger("sequence"),
+        turnId: reader.readString("turn_id"),
+        role: reader.readEnum("role", agentMessageRoles),
+        text: reader.readNullableString("text"),
+        toolCallId: reader.readNullableString("tool_call_id"),
+        toolName: reader.readNullableString("tool_name"),
+        toolArguments: reader.readNullableString("tool_arguments"),
+        toolOutput: reader.readNullableString("tool_output"),
+        frameworkItem: reader.readString("framework_item"),
+        createdAt: reader.readString("created_at"),
+    };
+}
+export function encodeAgentToolCall(value) {
+    return {
+        tool_call_id: value.toolCallId,
+        turn_id: value.turnId,
+        tool_name: value.toolName,
+        arguments: value.arguments,
+        effect: value.effect,
+        requires_approval: value.requiresApproval,
+        status: value.status,
+        output: value.output,
+        error: value.error,
+        rejection_message: value.rejectionMessage,
+        deferral_order: value.deferralOrder,
+        tool_source_reference: value.toolSourceReference ?? null,
+        trace_context: value.traceContext ?? null,
+        wait_until: value.waitUntil,
+        input_continuation: value.inputContinuation,
+        input_answers: value.inputAnswers.map(encodeQuestionAnswer),
+        input_question: value.inputQuestion,
+        input_choices: [...value.inputChoices],
+        input_allows_free_text: value.inputAllowsFreeText,
+        cancellation_reason: value.cancellationReason ?? null,
+        task_id: value.taskId ?? null,
+        task_poll_interval_seconds: value.taskPollIntervalSeconds ?? null,
+        task_answer_pending: value.taskAnswerPending ?? false,
+    };
+}
+export function decodeAgentToolCall(value) {
+    const reader = new WireRecordReader(value, "AgentToolCall");
+    const traceContext = reader.readNullableString("trace_context");
+    const toolCall = {
+        toolCallId: reader.readString("tool_call_id"),
+        turnId: reader.readString("turn_id"),
+        toolName: reader.readString("tool_name"),
+        arguments: reader.readString("arguments"),
+        effect: reader.readEnum("effect", toolEffects),
+        requiresApproval: reader.readBoolean("requires_approval"),
+        status: reader.readEnum("status", agentToolCallStatuses),
+        output: reader.readNullableString("output"),
+        error: reader.readNullableString("error"),
+        rejectionMessage: reader.readNullableString("rejection_message"),
+        deferralOrder: reader.readIntegerOrDefault("deferral_order", 0),
+        waitUntil: reader.readNullableString("wait_until"),
+        inputContinuation: reader.readNullableString("input_continuation"),
+        inputAnswers: reader.readArrayOrEmpty("input_answers").map(decodeQuestionAnswer),
+        inputQuestion: reader.readNullableString("input_question"),
+        inputChoices: reader.readStringArrayOrEmpty("input_choices"),
+        inputAllowsFreeText: reader.readBooleanOrDefault("input_allows_free_text", true),
+        cancellationReason: reader.readNullableEnum("cancellation_reason", toolCallCancellationReasons),
+        taskId: reader.readNullableString("task_id"),
+        taskPollIntervalSeconds: reader.readNullableInteger("task_poll_interval_seconds"),
+        taskAnswerPending: reader.readBooleanOrDefault("task_answer_pending", false),
+        ...(traceContext === null ? {} : { traceContext }),
+    };
+    const toolSourceReference = reader.readNullableString("tool_source_reference");
+    return toolSourceReference === null ? toolCall : { ...toolCall, toolSourceReference };
+}
+export function encodeQuestionAnswer(value) {
+    return {
+        interrupt_id: value.interruptId,
+        question: value.question,
+        answer: value.answer,
+        resolution: value.resolution ?? "answered",
+    };
+}
+export function decodeQuestionAnswer(value) {
+    const reader = new WireRecordReader(value, "QuestionAnswer");
+    return {
+        interruptId: reader.readString("interrupt_id"),
+        question: reader.readString("question"),
+        answer: reader.readString("answer"),
+        resolution: reader.readNullableString("resolution") === null ? "answered" : reader.readEnum("resolution", questionResolutions),
+    };
+}
+export function encodeAgentInterrupt(value) {
+    return {
+        interrupt_id: value.interruptId,
+        kind: value.kind,
+        tool_call_id: value.toolCallId,
+        tool_name: value.toolName,
+        arguments: value.arguments,
+        created_at: value.createdAt,
+        deadline: value.deadline,
+        question: value.question ?? null,
+        choices: [...(value.choices ?? [])],
+        allows_free_text: value.allowsFreeText ?? true,
+    };
+}
+export function decodeAgentInterrupt(value) {
+    const reader = new WireRecordReader(value, "AgentInterrupt");
+    return {
+        interruptId: reader.readString("interrupt_id"),
+        kind: reader.readEnum("kind", agentInterruptKinds),
+        toolCallId: reader.readString("tool_call_id"),
+        toolName: reader.readString("tool_name"),
+        arguments: reader.readString("arguments"),
+        createdAt: reader.readString("created_at"),
+        deadline: reader.readNullableString("deadline"),
+        question: reader.readNullableString("question"),
+        choices: reader.readStringArrayOrEmpty("choices"),
+        allowsFreeText: reader.readBooleanOrDefault("allows_free_text", true),
+    };
+}
+export function encodeAgentInterruptResolution(value) {
+    return { approved: value.approved, rejection_message: value.rejectionMessage, answer: value.answer ?? null };
+}
+export function decodeAgentInterruptResolution(value) {
+    const reader = new WireRecordReader(value, "AgentInterruptResolution");
+    return {
+        approved: reader.readBoolean("approved"),
+        rejectionMessage: reader.readNullableString("rejection_message"),
+        answer: reader.readNullableString("answer"),
+    };
+}
+export function encodeAnswerQuestionRequest(value) {
+    return { interrupt_id: value.interruptId, answer: value.answer };
+}
+export function decodeAnswerQuestionRequest(value) {
+    const reader = new WireRecordReader(value, "AnswerQuestionRequest");
+    return { interruptId: reader.readString("interrupt_id"), answer: reader.readString("answer") };
+}
+export function encodeAgentUsage(value) {
+    return {
+        model_calls: value.modelCalls,
+        input_tokens: value.inputTokens,
+        output_tokens: value.outputTokens,
+        cached_input_tokens: value.cachedInputTokens,
+        reasoning_tokens: value.reasoningTokens,
+    };
+}
+export function decodeAgentUsage(value) {
+    const reader = new WireRecordReader(value, "AgentUsage");
+    return {
+        modelCalls: reader.readInteger("model_calls"),
+        inputTokens: reader.readInteger("input_tokens"),
+        outputTokens: reader.readInteger("output_tokens"),
+        cachedInputTokens: reader.readInteger("cached_input_tokens"),
+        reasoningTokens: reader.readInteger("reasoning_tokens"),
+    };
+}
+export function encodeAgentUserMessage(value) {
+    return { text: value.text, plan_mode: value.planMode ?? false };
+}
+export function decodeAgentUserMessage(value) {
+    const reader = new WireRecordReader(value, "AgentUserMessage");
+    const planMode = reader.readBooleanOrDefault("plan_mode", false);
+    return { text: reader.readString("text"), ...(planMode ? { planMode } : {}) };
+}
+export function encodeAgentPlan(value) {
+    return {
+        revision: value.revision,
+        status: value.status,
+        tasks: value.tasks.map(encodeAgentPlanTask),
+        updated_at: value.updatedAt,
+    };
+}
+export function decodeAgentPlan(value) {
+    const reader = new WireRecordReader(value, "AgentPlan");
+    return {
+        revision: reader.readInteger("revision"),
+        status: reader.readEnum("status", planStatuses),
+        tasks: reader.readArrayOrEmpty("tasks").map(decodeAgentPlanTask),
+        updatedAt: reader.readString("updated_at"),
+    };
+}
+export function encodeAgentPlanTask(value) {
+    return { content: value.content, status: value.status };
+}
+export function decodeAgentPlanTask(value) {
+    const reader = new WireRecordReader(value, "AgentPlanTask");
+    return { content: reader.readString("content"), status: reader.readEnum("status", planTaskStatuses) };
+}
+export function encodePlanRevisionRequest(value) {
+    return { revision: value.revision };
+}
+export function decodePlanRevisionRequest(value) {
+    const reader = new WireRecordReader(value, "PlanExecutionRequest");
+    return { revision: reader.readInteger("revision") };
+}
+export function encodePendingUserMessage(value) {
+    return { message_id: value.messageId, message: encodeAgentUserMessage(value.message) };
+}
+export function decodePendingUserMessage(value) {
+    const reader = new WireRecordReader(value, "PendingUserMessage");
+    return { messageId: reader.readString("message_id"), message: decodeAgentUserMessage(reader.readObject("message")) };
+}
+export function encodeSteerUserMessageRequest(value) {
+    return { message_id: value.messageId, text: value.text };
+}
+export function decodeSteerUserMessageRequest(value) {
+    const reader = new WireRecordReader(value, "SteerUserMessageRequest");
+    return { messageId: reader.readNullableString("message_id"), text: reader.readNullableString("text") };
+}
+export function encodeDeleteQueuedMessageRequest(value) {
+    return { message_id: value.messageId };
+}
+export function decodeDeleteQueuedMessageRequest(value) {
+    const reader = new WireRecordReader(value, "DeleteQueuedMessageRequest");
+    return { messageId: reader.readString("message_id") };
+}
+export function encodeCancelTurnRequest(value) {
+    return { turn_id: value.turnId };
+}
+export function decodeCancelTurnRequest(value) {
+    if (value === null || value === undefined) {
+        return { turnId: null };
+    }
+    const reader = new WireRecordReader(value, "CancelTurnRequest");
+    return { turnId: reader.readNullableString("turn_id") };
+}
+export function encodeTurnControlRequest(value) {
+    return { kind: value.kind };
+}
+export function decodeTurnControlRequest(value) {
+    const reader = new WireRecordReader(value, "TurnControlRequest");
+    return { kind: reader.readEnum("kind", turnControlKinds) };
+}
+export function encodeTurnCancellationRequest(value) {
+    return { turn_id: value.turnId, requested_at: value.requestedAt };
+}
+export function decodeTurnCancellationRequest(value) {
+    const reader = new WireRecordReader(value, "TurnCancellationRequest");
+    return { turnId: reader.readString("turn_id"), requestedAt: reader.readString("requested_at") };
+}
+export function encodeToolCallCancellation(value) {
+    return { reason: value.reason };
+}
+export function decodeToolCallCancellation(value) {
+    const reader = new WireRecordReader(value, "ToolCallCancellation");
+    return { reason: reader.readEnum("reason", toolCallCancellationReasons) };
+}
+export function encodeToolCallCompleted(value) {
+    return { tool_call_id: value.toolCallId };
+}
+export function decodeToolCallCompleted(value) {
+    const reader = new WireRecordReader(value, "ToolCallCompleted");
+    return { toolCallId: reader.readString("tool_call_id") };
+}
+export function encodeAgentEvent(value) {
+    return {
+        type: value.type,
+        turn_id: value.turnId,
+        attempt: value.attempt,
+        step_execution_id: value.stepExecutionId,
+        payload: value.payload,
+    };
+}
+export function decodeAgentEvent(value) {
+    const reader = new WireRecordReader(value, "AgentEvent");
+    return {
+        type: reader.readString("type"),
+        turnId: reader.readNullableString("turn_id"),
+        attempt: reader.readInteger("attempt"),
+        stepExecutionId: reader.readNullableString("step_execution_id") ?? "",
+        payload: reader.readString("payload"),
+    };
+}
+export function encodeResolveInterruptInput(value) {
+    return {
+        interrupt_id: value.interruptId,
+        approved: value.approved,
+        rejection_message: value.rejectionMessage,
+    };
+}
+export function decodeResolveInterruptInput(value) {
+    const reader = new WireRecordReader(value, "ResolveInterruptInput");
+    return {
+        interruptId: reader.readString("interrupt_id"),
+        approved: reader.readBoolean("approved"),
+        rejectionMessage: reader.readNullableString("rejection_message"),
+    };
+}
+export function encodeContextSummary(value) {
+    return {
+        generation: value.generation,
+        first_sequence: value.firstSequence,
+        last_sequence: value.lastSequence,
+        text: value.text,
+        created_at: value.createdAt,
+    };
+}
+export function decodeContextSummary(value) {
+    const reader = new WireRecordReader(value, "ContextSummary");
+    return {
+        generation: reader.readInteger("generation"),
+        firstSequence: reader.readInteger("first_sequence"),
+        lastSequence: reader.readInteger("last_sequence"),
+        text: reader.readString("text"),
+        createdAt: reader.readString("created_at"),
+    };
+}
+export function encodeAgentMessageChunk(value) {
+    return { messages: value.messages.map(encodeAgentMessage) };
+}
+export function decodeAgentMessageChunk(value) {
+    const reader = new WireRecordReader(value, "AgentMessageChunk");
+    return { messages: reader.readArray("messages").map(decodeAgentMessage) };
+}
+export function encodeAgentMessageChunkRange(value) {
+    return { first_sequence: value.firstSequence, last_sequence: value.lastSequence };
+}
+export function decodeAgentMessageChunkRange(value) {
+    const reader = new WireRecordReader(value, "AgentMessageChunkRange");
+    return {
+        firstSequence: reader.readInteger("first_sequence"),
+        lastSequence: reader.readInteger("last_sequence"),
+    };
+}
+export function encodeAgentMessageIndex(value) {
+    return {
+        chunks: value.chunks.map(encodeAgentMessageChunkRange),
+        first_sequence: value.firstSequence,
+        window_first_sequence: value.windowFirstSequence,
+    };
+}
+export function decodeAgentMessageIndex(value) {
+    const reader = new WireRecordReader(value, "AgentMessageIndex");
+    return {
+        chunks: reader.readArray("chunks").map(decodeAgentMessageChunkRange),
+        firstSequence: reader.readInteger("first_sequence"),
+        windowFirstSequence: reader.readInteger("window_first_sequence"),
+    };
+}
+export function encodeTurnReplySequence(value) {
+    return { turn_id: value.turnId, sequence: value.sequence };
+}
+export function decodeTurnReplySequence(value) {
+    const reader = new WireRecordReader(value, "TurnReplySequence");
+    return { turnId: reader.readString("turn_id"), sequence: reader.readInteger("sequence") };
+}
+export function encodeCompactContextInput(value) {
+    return { through_sequence: value.throughSequence };
+}
+export function decodeCompactContextInput(value) {
+    const reader = new WireRecordReader(value, "CompactContextInput");
+    return { throughSequence: reader.readInteger("through_sequence") };
+}
+export function encodeAgentSnapshot(value) {
+    return {
+        state: value.state === null ? null : encodeAgentState(value.state),
+        messages: value.messages.map(encodeAgentMessage),
+        pending_interrupts: value.pendingInterrupts.map(encodeAgentInterrupt),
+        tool_calls: value.toolCalls.map(encodeAgentToolCall),
+        usage: encodeAgentUsage(value.usage),
+        queued_message_count: value.queuedMessageCount,
+        plan: value.plan == null ? null : encodeAgentPlan(value.plan),
+        queued_messages: (value.queuedMessages ?? []).map(encodePendingUserMessage),
+        steered_messages: (value.steeredMessages ?? []).map(encodePendingUserMessage),
+        context_summary: value.contextSummary === undefined || value.contextSummary === null
+            ? null
+            : encodeContextSummary(value.contextSummary),
+        session_settings: value.sessionSettings ?? null,
+    };
+}
+export function decodeAgentSnapshot(value) {
+    const reader = new WireRecordReader(value, "AgentSnapshot");
+    return {
+        state: reader.readObject("state") == null ? null : decodeAgentState(reader.readObject("state")),
+        messages: reader.readArray("messages").map(decodeAgentMessage),
+        pendingInterrupts: reader.readArray("pending_interrupts").map(decodeAgentInterrupt),
+        toolCalls: reader.readArray("tool_calls").map(decodeAgentToolCall),
+        usage: decodeAgentUsage(reader.readObject("usage")),
+        queuedMessageCount: reader.readIntegerOrDefault("queued_message_count", 0),
+        ...(reader.readObject("plan") == null ? {} : { plan: decodeAgentPlan(reader.readObject("plan")) }),
+        queuedMessages: reader.readArrayOrEmpty("queued_messages").map(decodePendingUserMessage),
+        steeredMessages: reader.readArrayOrEmpty("steered_messages").map(decodePendingUserMessage),
+        contextSummary: reader.readObject("context_summary") == null
+            ? null
+            : decodeContextSummary(reader.readObject("context_summary")),
+        sessionSettings: reader.readObject("session_settings") == null
+            ? null
+            : decodeSessionSettings(reader.readObject("session_settings")),
+    };
+}
+export function encodeListAgentMessagesInput(value) {
+    return { before_sequence: value.beforeSequence, limit: value.limit };
+}
+export function decodeListAgentMessagesInput(value) {
+    const reader = new WireRecordReader(value, "ListAgentMessagesInput");
+    return {
+        beforeSequence: reader.readNullableInteger("before_sequence"),
+        limit: reader.readIntegerOrDefault("limit", 50),
+    };
+}
+export function encodeAgentMessagesPage(value) {
+    return {
+        messages: value.messages.map(encodeAgentMessage),
+        next_before_sequence: value.nextBeforeSequence,
+        deleted_before_sequence: value.deletedBeforeSequence ?? null,
+    };
+}
+export function decodeAgentMessagesPage(value) {
+    const reader = new WireRecordReader(value, "AgentMessagesPage");
+    return {
+        messages: reader.readArray("messages").map(decodeAgentMessage),
+        nextBeforeSequence: reader.readNullableInteger("next_before_sequence"),
+        deletedBeforeSequence: reader.readNullableInteger("deleted_before_sequence"),
+    };
+}
+function snakeCaseJsonCodec(typeName, encode, decode) {
+    return jsonCodec({ typeName, encode, decode });
+}
+export const agentSessionStartInputCodec = snakeCaseJsonCodec("AgentSessionStartInput", encodeAgentSessionStartInput, decodeAgentSessionStartInput);
+export const agentStateCodec = snakeCaseJsonCodec("AgentState", encodeAgentState, decodeAgentState);
+export const agentMessageCodec = snakeCaseJsonCodec("AgentMessage", encodeAgentMessage, decodeAgentMessage);
+export const agentToolCallCodec = snakeCaseJsonCodec("AgentToolCall", encodeAgentToolCall, decodeAgentToolCall);
+export const agentInterruptListCodec = snakeCaseJsonCodec("AgentInterruptList", (value) => value.map(encodeAgentInterrupt), (value) => {
+    if (!Array.isArray(value)) {
+        throw new TypeError("PendingInterrupts must be a JSON array");
+    }
+    return value.map(decodeAgentInterrupt);
+});
+export const agentInterruptResolutionCodec = snakeCaseJsonCodec("AgentInterruptResolution", encodeAgentInterruptResolution, decodeAgentInterruptResolution);
+export const agentUsageCodec = snakeCaseJsonCodec("AgentUsage", encodeAgentUsage, decodeAgentUsage);
+export const agentUserMessageCodec = snakeCaseJsonCodec("AgentUserMessage", encodeAgentUserMessage, decodeAgentUserMessage);
+export const agentPlanCodec = snakeCaseJsonCodec("AgentPlan", encodeAgentPlan, decodeAgentPlan);
+export const planExecutionRequestCodec = snakeCaseJsonCodec("PlanExecutionRequest", encodePlanRevisionRequest, decodePlanRevisionRequest);
+export const executePlanRequestCodec = snakeCaseJsonCodec("ExecutePlanRequest", encodePlanRevisionRequest, decodePlanRevisionRequest);
+export const toolCallCompletedCodec = snakeCaseJsonCodec("ToolCallCompleted", encodeToolCallCompleted, decodeToolCallCompleted);
+export const agentEventCodec = snakeCaseJsonCodec("AgentEvent", encodeAgentEvent, decodeAgentEvent);
+export const resolveInterruptInputCodec = snakeCaseJsonCodec("ResolveInterruptInput", encodeResolveInterruptInput, decodeResolveInterruptInput);
+export const answerQuestionRequestCodec = snakeCaseJsonCodec("AnswerQuestionRequest", encodeAnswerQuestionRequest, decodeAnswerQuestionRequest);
+export const steerUserMessageRequestCodec = snakeCaseJsonCodec("SteerUserMessageRequest", encodeSteerUserMessageRequest, decodeSteerUserMessageRequest);
+export const deleteQueuedMessageRequestCodec = snakeCaseJsonCodec("DeleteQueuedMessageRequest", encodeDeleteQueuedMessageRequest, decodeDeleteQueuedMessageRequest);
+export const cancelTurnRequestCodec = snakeCaseJsonCodec("CancelTurnRequest", encodeCancelTurnRequest, decodeCancelTurnRequest);
+export const turnControlRequestCodec = snakeCaseJsonCodec("TurnControlRequest", encodeTurnControlRequest, decodeTurnControlRequest);
+export const turnCancellationRequestCodec = snakeCaseJsonCodec("TurnCancellationRequest", encodeTurnCancellationRequest, decodeTurnCancellationRequest);
+export const toolCallCancellationCodec = snakeCaseJsonCodec("ToolCallCancellation", encodeToolCallCancellation, decodeToolCallCancellation);
+export const agentSnapshotCodec = snakeCaseJsonCodec("AgentSnapshot", encodeAgentSnapshot, decodeAgentSnapshot);
+export const listAgentMessagesInputCodec = snakeCaseJsonCodec("ListAgentMessagesInput", encodeListAgentMessagesInput, decodeListAgentMessagesInput);
+export const agentMessagesPageCodec = snakeCaseJsonCodec("AgentMessagesPage", encodeAgentMessagesPage, decodeAgentMessagesPage);
+export const sessionSettingsCodec = snakeCaseJsonCodec("SessionSettings", encodeSessionSettings, decodeSessionSettings);
+export const turnSessionSettingsCodec = snakeCaseJsonCodec("TurnSessionSettings", encodeTurnSessionSettings, decodeTurnSessionSettings);
+export const updateSessionSettingsRequestCodec = snakeCaseJsonCodec("UpdateSessionSettingsRequest", encodeUpdateSessionSettingsRequest, decodeUpdateSessionSettingsRequest);
+export const agentMessageChunkCodec = snakeCaseJsonCodec("AgentMessageChunk", encodeAgentMessageChunk, decodeAgentMessageChunk);
+export const agentMessageIndexCodec = snakeCaseJsonCodec("AgentMessageIndex", encodeAgentMessageIndex, decodeAgentMessageIndex);
+export const turnReplySequenceCodec = snakeCaseJsonCodec("TurnReplySequence", encodeTurnReplySequence, decodeTurnReplySequence);
+export const contextSummaryCodec = snakeCaseJsonCodec("ContextSummary", encodeContextSummary, decodeContextSummary);
+/** Input of `CompactContext` and `RecordTurnFailure`: a `CompactContextInput`, or `RunModel`'s JSON `null` as `undefined`. */
+export const turnFailureRouteInputCodec = {
+    typeName: "TurnFailureRouteInput",
+    wireKind: "json",
+    encode: (value) => ({
+        kind: "json",
+        data: value === undefined ? "null" : JSON.stringify(encodeCompactContextInput(value)),
+    }),
+    decode: (value) => {
+        if (value.kind !== "json") {
+            throw new TypeError(`TurnFailureRouteInput requires JSON, got ${value.kind}`);
+        }
+        const parsed = JSON.parse(String(value.data));
+        return parsed === null ? undefined : decodeCompactContextInput(parsed);
+    },
+};
+//# sourceMappingURL=agent-session-codecs.js.map