@rynx-ai/runtime 0.1.0 → 0.1.10-beta.2

package/dist/codex-app-server/client.js

@@ -1,38 +1,977 @@
-import { randomUUID } from "node:crypto";
-import { CodexAppServerTransport, } from "./transport.js";
+import { createHash } from "node:crypto";
+import { CodexAppServerTransport, NO_SERVER_RESPONSE, } from "./transport.js";
+import { boundInteractionRequest, INTERACTION_LIMITS, redactInteractionResolution, validateInteractionResolution, } from "../interactions.js";
 const DEFAULT_CLIENT_INFO = {
     name: "lark-agent-bridge",
     title: "lark-agent-bridge",
     version: "0.1.0",
 };
-/** Falls back to the auto policy this long after an interactive approval is
- *  surfaced with no user answer (5 min). */
-const APPROVAL_TIMEOUT_MS = 300_000;
+class InteractionRequestBoundsError extends Error {
+}
+class UnsupportedInteractionSchemaError extends Error {
+}
+const PERMISSION_SUMMARY_BYTES = INTERACTION_LIMITS.descriptionBytes;
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function stringValue(value) {
+    return typeof value === "string" && value ? value : undefined;
+}
+function boundedText(value, max = 8_000) {
+    const text = stringValue(value);
+    if (!text)
+        return undefined;
+    return text.length <= max ? text : `${text.slice(0, max)}\n…`;
+}
+function commandText(value) {
+    if (Array.isArray(value)) {
+        const parts = value.filter((part) => typeof part === "string");
+        return boundedText(parts.join(" "));
+    }
+    return boundedText(value);
+}
+function legacyPatchPreview(fileChanges) {
+    const chunks = [];
+    for (const [path, change] of Object.entries(fileChanges)) {
+        const detail = change.type === "update" ? change.unified_diff : change.content;
+        chunks.push(`${path} (${change.type})\n${detail}`);
+    }
+    return boundedText(chunks.join("\n\n"));
+}
+function requestIdKey(value) {
+    return `${typeof value}:${String(value)}`;
+}
+function codexInteractionId(method, requestId, params) {
+    const record = asRecord(params);
+    const identity = JSON.stringify([
+        method,
+        requestIdKey(requestId),
+        stringValue(record?.threadId) ?? stringValue(record?.conversationId) ?? "",
+        stringValue(record?.turnId) ?? "",
+        stringValue(record?.itemId) ??
+            stringValue(record?.callId) ??
+            stringValue(record?.approvalId) ??
+            stringValue(record?.elicitationId) ??
+            "",
+    ]);
+    return `codex_${createHash("sha256").update(identity).digest("hex").slice(0, 32)}`;
+}
+function permissionActions() {
+    return [
+        { id: "accept", label: "Allow once", style: "primary", requiresAnswers: false },
+        {
+            id: "accept_session",
+            label: "Allow, and don’t ask again for this session",
+            requiresAnswers: false,
+        },
+        { id: "decline", label: "Deny", style: "danger", requiresAnswers: false },
+        { id: "cancel", label: "Cancel", requiresAnswers: false },
+    ];
+}
+function exactJsonSummary(label, value) {
+    if (value === undefined || value === null)
+        return undefined;
+    const serialized = JSON.stringify(value);
+    if (serialized === undefined)
+        return undefined;
+    const result = `${label}: ${serialized}`;
+    if (Buffer.byteLength(result, "utf8") > PERMISSION_SUMMARY_BYTES) {
+        throw new InteractionRequestBoundsError(`${label} exceeds the presentation limit`);
+    }
+    return result;
+}
+function joinedSummary(parts) {
+    const present = parts.filter((part) => Boolean(part));
+    if (present.length === 0)
+        return undefined;
+    const result = present.join(" · ");
+    if (Buffer.byteLength(result, "utf8") > PERMISSION_SUMMARY_BYTES) {
+        throw new InteractionRequestBoundsError("permission summary exceeds the presentation limit");
+    }
+    return result;
+}
+function commandApprovalSummary(input) {
+    return joinedSummary([
+        exactJsonSummary("Network target", input.networkApprovalContext),
+        exactJsonSummary("Command actions", input.commandActions),
+        exactJsonSummary("Additional permissions", input.additionalPermissions),
+        exactJsonSummary("Exec policy amendment", input.proposedExecpolicyAmendment),
+        exactJsonSummary("Network policy amendments", input.proposedNetworkPolicyAmendments),
+        exactJsonSummary("Available decisions", input.availableDecisions),
+    ]);
+}
+function commandDecisionActions(input) {
+    const advertised = input.availableDecisions;
+    const decisions = advertised == null
+        ? ["accept", "acceptForSession", "decline", "cancel"]
+        : advertised;
+    if (!Array.isArray(decisions) || decisions.length === 0) {
+        throw new UnsupportedInteractionSchemaError("command approval has no available decisions");
+    }
+    const seen = new Set();
+    return decisions.map((rawDecision, index) => {
+        let action;
+        let decision;
+        if (typeof rawDecision === "string") {
+            decision = rawDecision;
+            action = {
+                accept: {
+                    id: "accept",
+                    label: "Allow once",
+                    style: "primary",
+                    requiresAnswers: false,
+                },
+                acceptForSession: {
+                    id: "accept_session",
+                    label: "Allow, and don’t ask again for this session",
+                    requiresAnswers: false,
+                },
+                decline: {
+                    id: "decline",
+                    label: "Deny",
+                    style: "danger",
+                    requiresAnswers: false,
+                },
+                cancel: { id: "cancel", label: "Cancel", requiresAnswers: false },
+            }[rawDecision];
+            if (!action) {
+                throw new UnsupportedInteractionSchemaError(`unsupported command approval decision: ${String(rawDecision)}`);
+            }
+        }
+        else {
+            const record = asRecord(rawDecision);
+            const execPolicy = asRecord(record?.acceptWithExecpolicyAmendment);
+            const execAmendment = execPolicy?.execpolicy_amendment;
+            const networkPolicy = asRecord(record?.applyNetworkPolicyAmendment);
+            const networkAmendment = asRecord(networkPolicy?.network_policy_amendment);
+            if (record && Object.keys(record).length === 1 &&
+                execPolicy && Object.keys(execPolicy).length === 1 &&
+                Array.isArray(execAmendment) &&
+                execAmendment.every((value) => typeof value === "string")) {
+                decision = rawDecision;
+                action = {
+                    id: `accept_execpolicy_amendment_${index}`,
+                    label: "Allow, and don’t ask again for this command rule",
+                    requiresAnswers: false,
+                };
+            }
+            else if (record && Object.keys(record).length === 1 &&
+                networkPolicy && Object.keys(networkPolicy).length === 1 &&
+                networkAmendment && Object.keys(networkAmendment).length === 2 &&
+                typeof networkAmendment.host === "string" && networkAmendment.host.length > 0 &&
+                (networkAmendment.action === "allow" || networkAmendment.action === "deny")) {
+                decision = rawDecision;
+                action = {
+                    id: `apply_network_policy_amendment_${index}`,
+                    label: networkAmendment.action === "allow"
+                        ? `Allow, and don’t ask again for ${networkAmendment.host}`
+                        : `Deny ${networkAmendment.host}`,
+                    requiresAnswers: false,
+                    ...(networkAmendment.action === "allow" ? { style: "primary" } : {}),
+                };
+            }
+            else {
+                throw new UnsupportedInteractionSchemaError(`unsupported command approval decision at index ${index}`);
+            }
+        }
+        if (seen.has(action.id)) {
+            throw new UnsupportedInteractionSchemaError(`duplicate command approval decision: ${action.id}`);
+        }
+        seen.add(action.id);
+        return { action, decision };
+    });
+}
+function assertOnlyKeys(value, allowed, scope) {
+    const allowedSet = new Set(allowed);
+    const unsupported = Object.keys(value).find((key) => !allowedSet.has(key));
+    if (unsupported) {
+        throw new UnsupportedInteractionSchemaError(`${scope} uses unsupported keyword: ${unsupported}`);
+    }
+}
+function optionalFiniteNumber(value, name) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new UnsupportedInteractionSchemaError(`${name} must be a finite number`);
+    }
+    return value;
+}
+function optionalNonNegativeInteger(value, name) {
+    const parsed = optionalFiniteNumber(value, name);
+    if (parsed !== undefined && (!Number.isInteger(parsed) || parsed < 0)) {
+        throw new UnsupportedInteractionSchemaError(`${name} must be a non-negative integer`);
+    }
+    return parsed;
+}
+function schemaDescription(description, constraints) {
+    const values = [description, ...constraints].filter((value) => Boolean(value));
+    return values.length > 0 ? values.join(" ") : undefined;
+}
+function titledOptions(value, scope) {
+    if (!Array.isArray(value) || value.length === 0) {
+        throw new UnsupportedInteractionSchemaError(`${scope} must contain at least one option`);
+    }
+    if (value.length > INTERACTION_LIMITS.optionsPerField) {
+        throw new InteractionRequestBoundsError(`${scope} has too many options`);
+    }
+    const seen = new Set();
+    return value.map((raw, index) => {
+        const option = asRecord(raw);
+        const optionValue = option?.const;
+        const title = option?.title;
+        if (!option || Object.keys(option).some((key) => key !== "const" && key !== "title") ||
+            typeof optionValue !== "string" || !optionValue || typeof title !== "string" || !title) {
+            throw new UnsupportedInteractionSchemaError(`${scope}[${index}] is not a titled string option`);
+        }
+        if (seen.has(optionValue)) {
+            throw new UnsupportedInteractionSchemaError(`${scope} contains duplicate option values`);
+        }
+        seen.add(optionValue);
+        return { value: optionValue, label: title };
+    });
+}
+function enumOptions(values, labels, scope) {
+    if (!Array.isArray(values) || values.length === 0 ||
+        !values.every((value) => typeof value === "string" && value.length > 0)) {
+        throw new UnsupportedInteractionSchemaError(`${scope} must be a non-empty string enum`);
+    }
+    if (values.length > INTERACTION_LIMITS.optionsPerField) {
+        throw new InteractionRequestBoundsError(`${scope} has too many options`);
+    }
+    if (labels !== undefined &&
+        (!Array.isArray(labels) || labels.length !== values.length ||
+            !labels.every((label) => typeof label === "string" && label.length > 0))) {
+        throw new UnsupportedInteractionSchemaError(`${scope} enumNames must match enum`);
+    }
+    const seen = new Set();
+    return values.map((value, index) => {
+        if (seen.has(value)) {
+            throw new UnsupportedInteractionSchemaError(`${scope} contains duplicate option values`);
+        }
+        seen.add(value);
+        return { value, label: Array.isArray(labels) ? labels[index] : value };
+    });
+}
+function hasOwn(value, key) {
+    return Object.prototype.hasOwnProperty.call(value, key);
+}
+function stringConstraints(property, scope, ErrorType = Error) {
+    const minLength = optionalNonNegativeInteger(property.minLength, `${scope}.minLength`);
+    const maxLength = optionalNonNegativeInteger(property.maxLength, `${scope}.maxLength`);
+    if (minLength !== undefined && maxLength !== undefined && minLength > maxLength) {
+        throw new ErrorType(`${scope} has minLength greater than maxLength`);
+    }
+    const format = property.format;
+    if (format !== undefined && format !== "email" && format !== "uri" &&
+        format !== "date" && format !== "date-time") {
+        throw new ErrorType(`${scope} uses unsupported string format: ${String(format)}`);
+    }
+    return {
+        ...(minLength !== undefined ? { minLength } : {}),
+        ...(maxLength !== undefined ? { maxLength } : {}),
+        ...(typeof format === "string" ? { format } : {}),
+    };
+}
+function validateStringValue(value, property, scope, ErrorType = Error) {
+    const { minLength, maxLength, format } = stringConstraints(property, scope, ErrorType);
+    const length = [...value].length;
+    if (minLength !== undefined && length < minLength) {
+        throw new ErrorType(`${scope} must contain at least ${minLength} characters`);
+    }
+    if (maxLength !== undefined && length > maxLength) {
+        throw new ErrorType(`${scope} must contain at most ${maxLength} characters`);
+    }
+    if (format === undefined)
+        return;
+    let valid = false;
+    if (format === "email") {
+        valid = /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
+    }
+    else if (format === "uri") {
+        try {
+            valid = Boolean(new URL(value).protocol);
+        }
+        catch {
+            valid = false;
+        }
+    }
+    else if (format === "date") {
+        const timestamp = Date.parse(`${value}T00:00:00.000Z`);
+        valid = /^\d{4}-\d{2}-\d{2}$/.test(value) && Number.isFinite(timestamp) &&
+            new Date(timestamp).toISOString().slice(0, 10) === value;
+    }
+    else if (format === "date-time") {
+        valid = value.includes("T") && Number.isFinite(Date.parse(value));
+    }
+    if (!valid)
+        throw new ErrorType(`${scope} is not a valid ${format}`);
+}
+function mcpFields(schemaValue) {
+    const schema = asRecord(schemaValue);
+    if (!schema || schema.type !== "object") {
+        throw new UnsupportedInteractionSchemaError("MCP form schema must be an object schema");
+    }
+    assertOnlyKeys(schema, ["$schema", "type", "properties", "required"], "MCP form schema");
+    if (schema.$schema !== undefined && typeof schema.$schema !== "string") {
+        throw new UnsupportedInteractionSchemaError("MCP form $schema must be a string");
+    }
+    const properties = asRecord(schema?.properties);
+    if (!properties) {
+        throw new UnsupportedInteractionSchemaError("MCP form properties must be an object");
+    }
+    if (Object.keys(properties).length > INTERACTION_LIMITS.fields) {
+        throw new InteractionRequestBoundsError("MCP form has too many fields");
+    }
+    const requiredValues = schema.required ?? [];
+    if (!Array.isArray(requiredValues) || !requiredValues.every((value) => typeof value === "string")) {
+        throw new UnsupportedInteractionSchemaError("MCP form required must be a string array");
+    }
+    const required = new Set();
+    for (const id of requiredValues) {
+        if (!id || required.has(id) || !hasOwn(properties, id)) {
+            throw new UnsupportedInteractionSchemaError(`MCP form has invalid required field: ${id}`);
+        }
+        required.add(id);
+    }
+    const fields = [];
+    for (const [id, raw] of Object.entries(properties)) {
+        const property = asRecord(raw);
+        if (!property) {
+            throw new UnsupportedInteractionSchemaError(`MCP field ${id} must be an object schema`);
+        }
+        const label = stringValue(property.title) ?? id;
+        if (property.title !== undefined && !stringValue(property.title)) {
+            throw new UnsupportedInteractionSchemaError(`MCP field ${id} has an invalid title`);
+        }
+        const rawDescription = property.description;
+        if (rawDescription !== undefined && typeof rawDescription !== "string") {
+            throw new UnsupportedInteractionSchemaError(`MCP field ${id} has an invalid description`);
+        }
+        const description = rawDescription;
+        const requiredWithoutDefault = required.has(id) && !hasOwn(property, "default");
+        if (property.type === "string" && hasOwn(property, "oneOf")) {
+            assertOnlyKeys(property, ["type", "title", "description", "oneOf", "default"], `MCP field ${id}`);
+            const options = titledOptions(property.oneOf, `MCP field ${id}.oneOf`);
+            if (hasOwn(property, "default") &&
+                (typeof property.default !== "string" || !options.some((option) => option.value === property.default))) {
+                throw new UnsupportedInteractionSchemaError(`MCP field ${id} has an invalid default`);
+            }
+            fields.push({
+                id,
+                type: "select",
+                label,
+                options,
+                ...(description ? { description } : {}),
+                ...(requiredWithoutDefault ? { required: true } : {}),
+            });
+            continue;
+        }
+        if (property.type === "string" && hasOwn(property, "enum")) {
+            assertOnlyKeys(property, ["type", "title", "description", "enum", "enumNames", "default"], `MCP field ${id}`);
+            const options = enumOptions(property.enum, property.enumNames, `MCP field ${id}.enum`);
+            if (hasOwn(property, "default") &&
+                (typeof property.default !== "string" || !options.some((option) => option.value === property.default))) {
+                throw new UnsupportedInteractionSchemaError(`MCP field ${id} has an invalid default`);
+            }
+            fields.push({
+                id,
+                type: "select",
+                label,
+                options,
+                ...(description ? { description } : {}),
+                ...(requiredWithoutDefault ? { required: true } : {}),
+            });
+            continue;
+        }
+        if (property.type === "array") {
+            assertOnlyKeys(property, ["type", "title", "description", "minItems", "maxItems", "items", "default"], `MCP field ${id}`);
+            const items = asRecord(property.items);
+            if (!items) {
+                throw new UnsupportedInteractionSchemaError(`MCP field ${id}.items must be an enum schema`);
+            }
+            let options;
+            if (hasOwn(items, "anyOf")) {
+                assertOnlyKeys(items, ["anyOf"], `MCP field ${id}.items`);
+                options = titledOptions(items.anyOf, `MCP field ${id}.items.anyOf`);
+            }
+            else {
+                assertOnlyKeys(items, ["type", "enum"], `MCP field ${id}.items`);
+                if (items.type !== "string") {
+                    throw new UnsupportedInteractionSchemaError(`MCP field ${id}.items must contain strings`);
+                }
+                options = enumOptions(items.enum, undefined, `MCP field ${id}.items.enum`);
+            }
+            const minItems = optionalNonNegativeInteger(property.minItems, `MCP field ${id}.minItems`);
+            const maxItems = optionalNonNegativeInteger(property.maxItems, `MCP field ${id}.maxItems`);
+            if (minItems !== undefined && maxItems !== undefined && minItems > maxItems) {
+                throw new UnsupportedInteractionSchemaError(`MCP field ${id} has minItems greater than maxItems`);
+            }
+            if (minItems !== undefined && minItems > options.length) {
+                throw new UnsupportedInteractionSchemaError(`MCP field ${id} cannot satisfy minItems`);
+            }
+            if (hasOwn(property, "default")) {
+                if (!Array.isArray(property.default) ||
+                    !property.default.every((value) => typeof value === "string" && options.some((option) => option.value === value)) ||
+                    new Set(property.default).size !== property.default.length ||
+                    (minItems !== undefined && property.default.length < minItems) ||
+                    (maxItems !== undefined && property.default.length > maxItems)) {
+                    throw new UnsupportedInteractionSchemaError(`MCP field ${id} has an invalid default`);
+                }
+            }
+            const constraints = [
+                minItems !== undefined ? `Select at least ${minItems}.` : undefined,
+                maxItems !== undefined ? `Select at most ${maxItems}.` : undefined,
+                hasOwn(property, "default") ? `Default: ${property.default.join(", ")}.` : undefined,
+            ].filter((value) => Boolean(value));
+            fields.push({
+                id,
+                type: "select",
+                label,
+                options,
+                multiple: true,
+                ...(schemaDescription(description, constraints)
+                    ? { description: schemaDescription(description, constraints) }
+                    : {}),
+                ...(requiredWithoutDefault ? { required: true } : {}),
+            });
+            continue;
+        }
+        if (property.type === "boolean") {
+            assertOnlyKeys(property, ["type", "title", "description", "default"], `MCP field ${id}`);
+            if (hasOwn(property, "default") && typeof property.default !== "boolean") {
+                throw new UnsupportedInteractionSchemaError(`MCP field ${id} has an invalid default`);
+            }
+            const constraints = hasOwn(property, "default") ? [`Default: ${String(property.default)}.`] : [];
+            fields.push({
+                id,
+                type: "select",
+                label,
+                options: [
+                    { value: "true", label: "True" },
+                    { value: "false", label: "False" },
+                ],
+                ...(schemaDescription(description, constraints)
+                    ? { description: schemaDescription(description, constraints) }
+                    : {}),
+                ...(requiredWithoutDefault ? { required: true } : {}),
+            });
+            continue;
+        }
+        if (property.type === "number" || property.type === "integer") {
+            assertOnlyKeys(property, ["type", "title", "description", "minimum", "maximum", "default"], `MCP field ${id}`);
+            const minimum = optionalFiniteNumber(property.minimum, `MCP field ${id}.minimum`);
+            const maximum = optionalFiniteNumber(property.maximum, `MCP field ${id}.maximum`);
+            if (minimum !== undefined && maximum !== undefined && minimum > maximum) {
+                throw new UnsupportedInteractionSchemaError(`MCP field ${id} has minimum greater than maximum`);
+            }
+            if (hasOwn(property, "default")) {
+                if (typeof property.default !== "number" || !Number.isFinite(property.default) ||
+                    (property.type === "integer" && !Number.isInteger(property.default)) ||
+                    (minimum !== undefined && property.default < minimum) ||
+                    (maximum !== undefined && property.default > maximum)) {
+                    throw new UnsupportedInteractionSchemaError(`MCP field ${id} has an invalid default`);
+                }
+            }
+            const constraints = [
+                property.type === "integer" ? "Enter an integer." : "Enter a number.",
+                minimum !== undefined ? `Minimum: ${minimum}.` : undefined,
+                maximum !== undefined ? `Maximum: ${maximum}.` : undefined,
+                hasOwn(property, "default") ? `Default: ${String(property.default)}.` : undefined,
+            ].filter((value) => Boolean(value));
+            fields.push({
+                id,
+                type: "text",
+                label,
+                ...(schemaDescription(description, constraints)
+                    ? { description: schemaDescription(description, constraints) }
+                    : {}),
+                ...(requiredWithoutDefault ? { required: true } : {}),
+                ...(hasOwn(property, "default") ? { placeholder: String(property.default) } : {}),
+            });
+            continue;
+        }
+        if (property.type === "string") {
+            assertOnlyKeys(property, ["type", "title", "description", "minLength", "maxLength", "format", "default"], `MCP field ${id}`);
+            if (hasOwn(property, "default") && typeof property.default !== "string") {
+                throw new UnsupportedInteractionSchemaError(`MCP field ${id} has an invalid default`);
+            }
+            if (hasOwn(property, "default")) {
+                validateStringValue(property.default, property, `MCP field ${id}`, UnsupportedInteractionSchemaError);
+            }
+            else {
+                stringConstraints(property, `MCP field ${id}`, UnsupportedInteractionSchemaError);
+            }
+            const minLength = optionalNonNegativeInteger(property.minLength, `MCP field ${id}.minLength`);
+            const maxLength = optionalNonNegativeInteger(property.maxLength, `MCP field ${id}.maxLength`);
+            const constraints = [
+                minLength !== undefined ? `Minimum length: ${minLength}.` : undefined,
+                maxLength !== undefined ? `Maximum length: ${maxLength}.` : undefined,
+                property.format !== undefined ? `Format: ${String(property.format)}.` : undefined,
+                hasOwn(property, "default") ? `Default: ${String(property.default)}.` : undefined,
+            ].filter((value) => Boolean(value));
+            fields.push({
+                id,
+                type: "text",
+                label,
+                ...(schemaDescription(description, constraints)
+                    ? { description: schemaDescription(description, constraints) }
+                    : {}),
+                ...(requiredWithoutDefault ? { required: true } : {}),
+                ...(hasOwn(property, "default") ? { placeholder: property.default } : {}),
+            });
+            continue;
+        }
+        throw new UnsupportedInteractionSchemaError(`MCP field ${id} uses unsupported type: ${String(property.type)}`);
+    }
+    return fields;
+}
+function buildCodexInteraction(method, params, nativeRequestId) {
+    const p = asRecord(params) ?? {};
+    const interactionId = codexInteractionId(method, nativeRequestId, params);
+    const turnId = stringValue(p.turnId);
+    const base = {
+        interactionId,
+        createdAt: Date.now(),
+    };
+    let request;
+    switch (method) {
+        case "item/tool/requestUserInput": {
+            const input = params;
+            const questions = Array.isArray(input.questions) ? input.questions : [];
+            const fields = questions.map((question) => {
+                const options = Array.isArray(question.options) ? question.options : [];
+                if (options.length > 0) {
+                    return {
+                        id: question.id,
+                        type: "select",
+                        label: question.question,
+                        description: question.header || undefined,
+                        required: true,
+                        ...(question.multiSelect ? { multiple: true } : {}),
+                        allowOther: question.isOther,
+                        options: options.map((option) => ({
+                            value: option.label,
+                            label: option.label,
+                            ...(option.description ? { description: option.description } : {}),
+                        })),
+                    };
+                }
+                return {
+                    id: question.id,
+                    type: "text",
+                    label: question.question,
+                    description: question.header || undefined,
+                    required: true,
+                    ...(question.isSecret ? { secret: true } : {}),
+                };
+            });
+            request = {
+                ...base,
+                kind: "question",
+                title: questions.length === 1 && questions[0]?.header
+                    ? questions[0].header
+                    : "Input required",
+                fields,
+                actions: [{ id: "submit", label: "Submit", style: "primary", requiresAnswers: true }],
+            };
+            break;
+        }
+        case "mcpServer/elicitation/request": {
+            const input = params;
+            const urlDescription = input.mode === "url" ? `${input.message}\n${input.url}` : input.message;
+            request = {
+                ...base,
+                kind: "form",
+                title: `${input.serverName || "MCP server"} requests input`,
+                description: urlDescription,
+                fields: input.mode === "url" ? [] : mcpFields(input.requestedSchema),
+                actions: [
+                    {
+                        id: "accept",
+                        label: "Continue",
+                        style: "primary",
+                        requiresAnswers: input.mode !== "url",
+                    },
+                    { id: "decline", label: "Decline", style: "danger", requiresAnswers: false },
+                    { id: "cancel", label: "Cancel", requiresAnswers: false },
+                ],
+            };
+            break;
+        }
+        case "item/permissions/requestApproval": {
+            const input = params;
+            const permissionSummary = exactJsonSummary("Requested permissions", input.permissions);
+            request = {
+                ...base,
+                kind: "permission",
+                title: "Additional permissions required",
+                description: input.reason ?? undefined,
+                fields: [],
+                actions: [
+                    { id: "grant_turn", label: "Allow all for turn", style: "primary", requiresAnswers: false },
+                    {
+                        id: "grant_session",
+                        label: "Allow, and don’t ask again for this session",
+                        requiresAnswers: false,
+                    },
+                    { id: "decline", label: "Deny", style: "danger", requiresAnswers: false },
+                    { id: "cancel", label: "Cancel", requiresAnswers: false },
+                ],
+                context: {
+                    toolName: "permissions",
+                    ...(input.cwd ? { cwd: input.cwd } : {}),
+                    ...(permissionSummary ? { summary: permissionSummary } : {}),
+                },
+            };
+            break;
+        }
+        case "item/fileChange/requestApproval": {
+            const input = params;
+            request = {
+                ...base,
+                kind: "permission",
+                title: input.grantRoot ? `Write access under ${input.grantRoot}` : "Approve file changes",
+                description: boundedText(input.reason),
+                fields: [],
+                actions: permissionActions(),
+                context: {
+                    toolName: "file_change",
+                    ...(input.grantRoot ? { summary: `Write access under ${input.grantRoot}` } : {}),
+                },
+            };
+            break;
+        }
+        case "applyPatchApproval": {
+            const input = params;
+            const diff = legacyPatchPreview(input.fileChanges ?? {});
+            request = {
+                ...base,
+                kind: "permission",
+                title: input.grantRoot ? `Write access under ${input.grantRoot}` : "Approve file changes",
+                description: boundedText(input.reason),
+                fields: [],
+                actions: permissionActions(),
+                context: {
+                    toolName: "file_change",
+                    ...(input.grantRoot ? { summary: `Write access under ${input.grantRoot}` } : {}),
+                    ...(diff ? { diff } : {}),
+                },
+            };
+            break;
+        }
+        case "item/commandExecution/requestApproval": {
+            const input = params;
+            const command = commandText(input.command);
+            const reason = boundedText(input.reason);
+            const summary = commandApprovalSummary(input);
+            request = {
+                ...base,
+                kind: "permission",
+                title: input.networkApprovalContext && !command
+                    ? `Approve network access to ${input.networkApprovalContext.host}`
+                    : "Approve command",
+                description: reason,
+                fields: [],
+                actions: commandDecisionActions(input).map((entry) => entry.action),
+                context: {
+                    toolName: "command_execution",
+                    ...(command ? { command } : {}),
+                    ...(input.cwd ? { cwd: input.cwd } : {}),
+                    ...(summary ? { summary } : {}),
+                },
+            };
+            break;
+        }
+        case "execCommandApproval": {
+            const input = params;
+            const command = commandText(input.command);
+            const reason = boundedText(input.reason);
+            request = {
+                ...base,
+                kind: "permission",
+                title: "Approve command",
+                description: reason,
+                fields: [],
+                actions: permissionActions(),
+                context: {
+                    toolName: "command_execution",
+                    ...(command ? { command } : {}),
+                    ...(input.cwd ? { cwd: input.cwd } : {}),
+                    ...(reason ? { summary: reason } : {}),
+                },
+            };
+            break;
+        }
+    }
+    const bounded = boundInteractionRequest(request);
+    if (!bounded.ok)
+        throw new InteractionRequestBoundsError(bounded.reason);
+    return { request: bounded.request, ...(turnId ? { turnId } : {}) };
+}
+function mcpContent(params, answers) {
+    if (params.mode === "url")
+        return {};
+    // Re-validate the native schema at resolution time. It remains untrusted
+    // provider input even though the same object was validated for rendering.
+    mcpFields(params.requestedSchema);
+    const schema = asRecord(params.requestedSchema);
+    const properties = asRecord(schema.properties);
+    const content = Object.create(null);
+    for (const [id, rawProperty] of Object.entries(properties)) {
+        const property = asRecord(rawProperty);
+        const answer = answers[id];
+        const value = answer === undefined && hasOwn(property, "default")
+            ? property.default
+            : answer;
+        if (value === undefined)
+            continue;
+        if (property.type === "boolean") {
+            if (value !== "true" && value !== "false" && typeof value !== "boolean") {
+                throw new Error(`MCP field ${id} must be true or false`);
+            }
+            content[id] = typeof value === "boolean" ? value : value === "true";
+            continue;
+        }
+        if (property.type === "number" || property.type === "integer") {
+            const number = typeof value === "number"
+                ? value
+                : typeof value === "string" && value.trim().length > 0
+                    ? Number(value)
+                    : Number.NaN;
+            if (!Number.isFinite(number))
+                throw new Error(`MCP field ${id} must be a finite number`);
+            if (property.type === "integer" && !Number.isInteger(number)) {
+                throw new Error(`MCP field ${id} must be an integer`);
+            }
+            const minimum = optionalFiniteNumber(property.minimum, `MCP field ${id}.minimum`);
+            const maximum = optionalFiniteNumber(property.maximum, `MCP field ${id}.maximum`);
+            if (minimum !== undefined && number < minimum) {
+                throw new Error(`MCP field ${id} must be at least ${minimum}`);
+            }
+            if (maximum !== undefined && number > maximum) {
+                throw new Error(`MCP field ${id} must be at most ${maximum}`);
+            }
+            content[id] = number;
+            continue;
+        }
+        if (property.type === "array") {
+            if (!Array.isArray(value) || !value.every((entry) => typeof entry === "string")) {
+                throw new Error(`MCP field ${id} must be a string array`);
+            }
+            if (new Set(value).size !== value.length) {
+                throw new Error(`MCP field ${id} must not contain duplicate selections`);
+            }
+            const items = asRecord(property.items);
+            const options = hasOwn(items, "anyOf")
+                ? titledOptions(items.anyOf, `MCP field ${id}.items.anyOf`)
+                : enumOptions(items.enum, undefined, `MCP field ${id}.items.enum`);
+            if (value.some((entry) => !options.some((option) => option.value === entry))) {
+                throw new Error(`MCP field ${id} contains an unsupported selection`);
+            }
+            const minItems = optionalNonNegativeInteger(property.minItems, `MCP field ${id}.minItems`);
+            const maxItems = optionalNonNegativeInteger(property.maxItems, `MCP field ${id}.maxItems`);
+            if (minItems !== undefined && value.length < minItems) {
+                throw new Error(`MCP field ${id} requires at least ${minItems} selections`);
+            }
+            if (maxItems !== undefined && value.length > maxItems) {
+                throw new Error(`MCP field ${id} allows at most ${maxItems} selections`);
+            }
+            content[id] = [...value];
+            continue;
+        }
+        if (property.type === "string") {
+            if (typeof value !== "string")
+                throw new Error(`MCP field ${id} must be a string`);
+            if (hasOwn(property, "oneOf")) {
+                const options = titledOptions(property.oneOf, `MCP field ${id}.oneOf`);
+                if (!options.some((option) => option.value === value)) {
+                    throw new Error(`MCP field ${id} contains an unsupported selection`);
+                }
+            }
+            else if (hasOwn(property, "enum")) {
+                const options = enumOptions(property.enum, property.enumNames, `MCP field ${id}.enum`);
+                if (!options.some((option) => option.value === value)) {
+                    throw new Error(`MCP field ${id} contains an unsupported selection`);
+                }
+            }
+            else {
+                validateStringValue(value, property, `MCP field ${id}`);
+            }
+            content[id] = value;
+            continue;
+        }
+        throw new Error(`MCP field ${id} uses an unsupported schema`);
+    }
+    return content;
+}
+function buildNativeInteractionResponse(pending, resolution) {
+    const invalid = validateInteractionResolution(pending.request, resolution);
+    if (invalid)
+        throw new Error(invalid);
+    const answers = resolution.answers ?? {};
+    switch (pending.method) {
+        case "item/tool/requestUserInput": {
+            const response = { answers: {} };
+            for (const [id, value] of Object.entries(answers)) {
+                response.answers[id] = { answers: Array.isArray(value) ? value : [value] };
+            }
+            return response;
+        }
+        case "mcpServer/elicitation/request": {
+            const action = resolution.actionId;
+            if (action !== "accept" && action !== "decline" && action !== "cancel") {
+                throw new Error(`unsupported MCP action: ${action}`);
+            }
+            const response = {
+                action,
+                content: action === "accept"
+                    ? mcpContent(pending.params, answers)
+                    : null,
+                _meta: null,
+            };
+            return response;
+        }
+        case "item/permissions/requestApproval": {
+            const input = pending.params;
+            const granted = resolution.actionId === "grant_turn" || resolution.actionId === "grant_session";
+            const permissions = {};
+            if (granted && input.permissions.network)
+                permissions.network = input.permissions.network;
+            if (granted && input.permissions.fileSystem)
+                permissions.fileSystem = input.permissions.fileSystem;
+            const response = {
+                permissions,
+                scope: resolution.actionId === "grant_session" ? "session" : "turn",
+            };
+            return response;
+        }
+        case "execCommandApproval":
+        case "applyPatchApproval": {
+            const response = {
+                decision: {
+                    accept: "approved",
+                    accept_session: "approved_for_session",
+                    decline: "denied",
+                    cancel: "abort",
+                }[resolution.actionId],
+            };
+            return response;
+        }
+        case "item/commandExecution/requestApproval": {
+            const input = pending.params;
+            const selected = commandDecisionActions(input).find((entry) => entry.action.id === resolution.actionId);
+            if (!selected)
+                throw new Error(`unsupported approval action: ${resolution.actionId}`);
+            const response = { decision: selected.decision };
+            return response;
+        }
+        case "item/fileChange/requestApproval": {
+            const decision = resolution.actionId === "accept_session"
+                ? "acceptForSession"
+                : resolution.actionId;
+            if (decision !== "accept" && decision !== "acceptForSession" && decision !== "decline" && decision !== "cancel") {
+                throw new Error(`unsupported approval action: ${resolution.actionId}`);
+            }
+            return { decision };
+        }
+    }
+}
+function automaticCommandDecision(params, desired) {
+    const entries = commandDecisionActions(params);
+    const simple = new Map(entries
+        .filter((entry) => typeof entry.decision === "string")
+        .map((entry) => [entry.decision, entry.decision]));
+    const preferences = desired === "acceptForSession"
+        ? ["acceptForSession", "accept", "cancel", "decline"]
+        : desired === "accept"
+            ? ["accept", "acceptForSession", "cancel", "decline"]
+            : desired === "decline"
+                ? ["decline", "cancel"]
+                : ["cancel", "decline"];
+    for (const preference of preferences) {
+        const decision = simple.get(preference);
+        if (decision)
+            return decision;
+    }
+    throw new UnsupportedInteractionSchemaError("command approval does not advertise a compatible automatic decision");
+}
+function buildAutomaticResponse(method, params, decision) {
+    switch (method) {
+        case "item/tool/requestUserInput":
+            return { answers: {} };
+        case "mcpServer/elicitation/request":
+            return {
+                action: "cancel",
+                content: null,
+                _meta: null,
+            };
+        case "item/permissions/requestApproval": {
+            const input = params;
+            const permissions = {};
+            if (decision === "acceptForSession") {
+                if (input.permissions.network)
+                    permissions.network = input.permissions.network;
+                if (input.permissions.fileSystem)
+                    permissions.fileSystem = input.permissions.fileSystem;
+            }
+            return {
+                permissions,
+                scope: decision === "acceptForSession" ? "session" : "turn",
+            };
+        }
+        case "execCommandApproval":
+        case "applyPatchApproval": {
+            const response = {
+                decision: decision === "acceptForSession"
+                    ? "approved_for_session"
+                    : decision === "accept"
+                        ? "approved"
+                        : decision === "decline"
+                            ? "denied"
+                            : "abort",
+            };
+            return response;
+        }
+        case "item/commandExecution/requestApproval":
+            return {
+                decision: automaticCommandDecision(params, decision),
+            };
+        case "item/fileChange/requestApproval":
+            return { decision };
+    }
+}
+const MAX_SETTLED_INTERACTIONS = 512;
 export class CodexAppServerClient {
     transport;
     logger;
     clientInfo;
     approvalDecisionPolicy;
-    interactiveApprovals;
     channel;
     notificationSubscribers = new Set();
-    approvalListener = null;
-    pendingApprovals = new Map();
+    interactionListener = null;
+    connectionListener = null;
+    connectionState = "disconnected";
+    pendingInteractions = new Map();
+    settledInteractions = new Set();
     initializeResponse = null;
-    constructor({ spawner, channel, logger = defaultLogger, clientInfo = DEFAULT_CLIENT_INFO, approvalDecisionPolicy = "auto-approve-session", interactiveApprovals = false, }) {
+    constructor({ spawner, channel, logger = defaultLogger, clientInfo = DEFAULT_CLIENT_INFO, approvalDecisionPolicy = "auto-approve-session", }) {
         this.logger = logger;
         this.clientInfo = clientInfo;
         this.approvalDecisionPolicy = approvalDecisionPolicy;
-        this.interactiveApprovals = interactiveApprovals;
         this.channel = channel ?? null;
         this.transport = new CodexAppServerTransport({
             ...(channel ? { channel } : { spawner }),
             logger,
             onNotification: (method, params) => this.dispatchNotification(method, params),
-            onServerRequest: (method, params) => this.handleServerRequest(method, params),
+            onServerRequest: (method, params, requestId) => this.handleServerRequest(method, params, requestId),
+            onServerRequestResponseDelivery: (requestId, result) => this.handleServerRequestResponseDelivery(requestId, result),
         });
         this.transport.on("exit", () => {
             this.initializeResponse = null;
+            this.cancelPendingInteractions("app_server_disconnected");
+            this.setConnectionState("disconnected");
         });
     }
     /**
@@ -55,6 +994,7 @@ export class CodexAppServerClient {
             capabilities: { experimentalApi: true },
         });
         this.initializeResponse = response;
+        this.setConnectionState("connected");
         return response;
     }
     async getAuthStatus(params = {}) {
@@ -148,6 +1088,20 @@ export class CodexAppServerClient {
         await this.transport.stop();
     }
     dispatchNotification(method, params) {
+        if (method === "serverRequest/resolved") {
+            const p = asRecord(params);
+            const nativeRequestId = p?.requestId;
+            if (typeof nativeRequestId === "string" || typeof nativeRequestId === "number") {
+                this.resolveByProvider(nativeRequestId, stringValue(p?.threadId));
+            }
+        }
+        else if (method === "turn/completed") {
+            const p = asRecord(params);
+            const turn = asRecord(p?.turn);
+            const turnId = stringValue(turn?.id) ?? stringValue(p?.turnId);
+            if (turnId)
+                this.cancelPendingInteractions("turn_completed", turnId);
+        }
         for (const listener of this.notificationSubscribers) {
             try {
                 listener(method, params);
@@ -161,19 +1115,16 @@ export class CodexAppServerClient {
             }
         }
     }
-    async handleServerRequest(method, params) {
+    async handleServerRequest(method, params, requestId) {
         switch (method) {
             case "item/commandExecution/requestApproval":
             case "execCommandApproval":
-                return this.handleApproval("exec", params);
             case "item/fileChange/requestApproval":
             case "applyPatchApproval":
-                return this.handleApproval("patch", params);
             case "item/tool/requestUserInput":
             case "mcpServer/elicitation/request":
-                return this.respondNotSupported(method);
             case "item/permissions/requestApproval":
-                return { decision: this.declineDecisionForApprovals() };
+                return this.handleInteraction(method, params, requestId);
             case "account/chatgptAuthTokens/refresh":
                 // Codex asks the host to refresh tokens; without an attached UI the
                 // best we can do is decline, surfacing the auth error to the caller
@@ -188,66 +1139,96 @@ export class CodexAppServerClient {
         }
     }
     /**
-     * Register the listener that surfaces interactive approval requests. Set by
-     * the executor for the duration of a run so requests reach its event stream
-     * (and thus the web / Lark approval card).
+     * Register the provider-neutral interaction listener. A request is inserted
+     * into the pending map before the listener is invoked, so a synchronous
+     * resolver still wins correctly.
      */
-    setApprovalRequestListener(listener) {
-        this.approvalListener = listener;
+    setInteractionListener(listener) {
+        this.interactionListener = listener;
     }
-    /**
-     * Deliver a user's decision for a pending interactive approval. Returns false
-     * if the approval id is unknown (already resolved, timed out, or auto-decided).
-     */
-    resolveApproval(approvalId, decision) {
-        const pending = this.pendingApprovals.get(approvalId);
+    /** Observe the underlying app-server connection independently from any one
+     * interaction. A disconnected client that never received the duplicate
+     * native request still has to count as unavailable during host failover. */
+    setConnectionListener(listener) {
+        this.connectionListener = listener;
+        listener?.(this.connectionState);
+    }
+    setConnectionState(state) {
+        if (this.connectionState === state)
+            return;
+        this.connectionState = state;
+        this.connectionListener?.(state);
+    }
+    resolveInteraction(interactionId, resolution) {
+        const pending = this.pendingInteractions.get(interactionId);
         if (!pending) {
-            return false;
+            return this.settledInteractions.has(interactionId)
+                ? { disposition: "already_resolved" }
+                : { disposition: "not_found" };
         }
-        clearTimeout(pending.timer);
-        this.pendingApprovals.delete(approvalId);
-        pending.resolve(decision);
-        return true;
+        if (pending.submission)
+            return { disposition: "already_resolved" };
+        let nativeResponse;
+        try {
+            nativeResponse = buildNativeInteractionResponse(pending, resolution);
+        }
+        catch (error) {
+            return {
+                disposition: "invalid",
+                message: error instanceof Error ? error.message : String(error),
+            };
+        }
+        pending.submission = {
+            resolution: redactInteractionResolution(pending.request, resolution),
+        };
+        pending.resolve(nativeResponse);
+        return { disposition: "applied" };
     }
-    /**
-     * Interactive approval path: surface the request and block the codex
-     * server-request until the user decides (or the timeout falls back to the
-     * auto policy). When interactive approvals are off, decide immediately.
-     */
-    async handleApproval(kind, params) {
-        const listener = this.approvalListener;
-        if (!this.interactiveApprovals || !listener) {
-            return kind === "exec"
-                ? this.respondCommandApproval(params)
-                : this.respondFileChangeApproval(params);
-        }
-        const approvalId = randomUUID();
-        const request = { approvalId, kind };
-        const p = params;
-        if (typeof p.command === "string")
-            request.command = p.command;
-        if (typeof p.cwd === "string")
-            request.cwd = p.cwd;
-        if (typeof p.diff === "string")
-            request.diff = p.diff;
+    /** Cancel every pending request owned by this connection without replying. */
+    cancelInteractions(reason = "client_stopped") {
+        this.cancelPendingInteractions(reason);
+    }
+    async handleInteraction(method, params, nativeRequestId) {
+        let adapted;
         try {
-            listener(request);
+            adapted = buildCodexInteraction(method, params, nativeRequestId);
         }
         catch (error) {
-            this.logger.log({
-                event: "client.approval_listener_failed",
-                error: error instanceof Error ? error.message : String(error),
-            });
+            if (error instanceof InteractionRequestBoundsError ||
+                error instanceof UnsupportedInteractionSchemaError) {
+                this.logger.log({
+                    event: "client.interaction_request_rejected",
+                    method,
+                    reason: error.message,
+                });
+                return buildAutomaticResponse(method, params, "cancel");
+            }
+            throw error;
+        }
+        const listener = this.interactionListener;
+        // Provider policy decides whether an approval request exists. Once it does,
+        // an installed generic listener must see it; only standalone/no-listener
+        // clients use the automatic fallback.
+        if (!listener) {
+            return buildAutomaticResponse(method, params, this.autoApprovalDecision());
         }
-        const decision = await new Promise((resolve) => {
-            const timer = setTimeout(() => {
-                this.pendingApprovals.delete(approvalId);
-                resolve(this.autoApprovalDecision());
-            }, APPROVAL_TIMEOUT_MS);
-            timer.unref?.();
-            this.pendingApprovals.set(approvalId, { resolve, timer });
+        return new Promise((resolve) => {
+            const pending = {
+                method,
+                nativeRequestId,
+                params,
+                request: adapted.request,
+                ...(adapted.turnId ? { turnId: adapted.turnId } : {}),
+                resolve,
+            };
+            // Register before notifying: the listener is allowed to answer inline.
+            this.pendingInteractions.set(adapted.request.interactionId, pending);
+            this.emitInteraction({
+                type: "requested",
+                request: adapted.request,
+                ...(adapted.turnId ? { turnId: adapted.turnId } : {}),
+            });
         });
-        return { decision };
     }
     autoApprovalDecision() {
         switch (this.approvalDecisionPolicy) {
@@ -260,45 +1241,94 @@ export class CodexAppServerClient {
                 return "cancel";
         }
     }
-    respondCommandApproval(_params) {
-        switch (this.approvalDecisionPolicy) {
-            case "auto-approve-session":
-                return { decision: "acceptForSession" };
-            case "auto-decline":
-                return { decision: "decline" };
-            case "auto-cancel":
-            default:
-                return { decision: "cancel" };
+    resolveByProvider(nativeRequestId, threadId) {
+        for (const [interactionId, pending] of this.pendingInteractions) {
+            const pendingParams = asRecord(pending.params);
+            const pendingThreadId = stringValue(pendingParams?.threadId) ??
+                stringValue(pendingParams?.conversationId);
+            if (requestIdKey(pending.nativeRequestId) !== requestIdKey(nativeRequestId) ||
+                (threadId && pendingThreadId && threadId !== pendingThreadId)) {
+                continue;
+            }
+            this.pendingInteractions.delete(interactionId);
+            this.rememberSettled(interactionId);
+            if (pending.submission) {
+                this.emitInteraction({
+                    type: "resolved",
+                    interactionId,
+                    resolution: pending.submission.resolution,
+                    ...(pending.turnId ? { turnId: pending.turnId } : {}),
+                });
+            }
+            else {
+                // This connection never submitted a response, so another app-server
+                // client resolved the request. Do not reply to the stale native request.
+                pending.resolve(NO_SERVER_RESPONSE);
+                this.emitInteraction({
+                    type: "cancelled",
+                    interactionId,
+                    reason: "resolved_by_another_client",
+                    ...(pending.turnId ? { turnId: pending.turnId } : {}),
+                });
+            }
+            return;
         }
     }
-    respondFileChangeApproval(_params) {
-        switch (this.approvalDecisionPolicy) {
-            case "auto-approve-session":
-                return { decision: "acceptForSession" };
-            case "auto-decline":
-                return { decision: "decline" };
-            case "auto-cancel":
-            default:
-                return { decision: "cancel" };
+    handleServerRequestResponseDelivery(nativeRequestId, result) {
+        for (const [interactionId, pending] of this.pendingInteractions) {
+            if (requestIdKey(pending.nativeRequestId) !== requestIdKey(nativeRequestId))
+                continue;
+            if (!pending.submission)
+                return;
+            if (result.delivered)
+                return;
+            this.pendingInteractions.delete(interactionId);
+            this.rememberSettled(interactionId);
+            this.emitInteraction({
+                type: "cancelled",
+                interactionId,
+                reason: "response_write_failed",
+                ...(pending.turnId ? { turnId: pending.turnId } : {}),
+            });
+            return;
         }
     }
-    declineDecisionForApprovals() {
-        switch (this.approvalDecisionPolicy) {
-            case "auto-approve-session":
-                return "accept";
-            case "auto-decline":
-                return "decline";
-            case "auto-cancel":
-            default:
-                return "cancel";
+    cancelPendingInteractions(reason, turnId) {
+        for (const [interactionId, pending] of [...this.pendingInteractions]) {
+            // Some provider requests omit turnId (notably MCP URL/form variants).
+            // Codex has one active Turn per thread, so an unknown correlation must be
+            // cancelled by its completion instead of leaking forever.
+            if (turnId && pending.turnId && pending.turnId !== turnId)
+                continue;
+            this.pendingInteractions.delete(interactionId);
+            this.rememberSettled(interactionId);
+            pending.resolve(NO_SERVER_RESPONSE);
+            this.emitInteraction({
+                type: "cancelled",
+                interactionId,
+                reason,
+                ...(pending.turnId ? { turnId: pending.turnId } : {}),
+            });
         }
     }
-    respondNotSupported(method) {
-        this.logger.log({
-            event: "client.server_request_unsupported",
-            method,
-        });
-        return null;
+    emitInteraction(event) {
+        try {
+            this.interactionListener?.(event);
+        }
+        catch (error) {
+            this.logger.log({
+                event: "client.interaction_listener_failed",
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    rememberSettled(interactionId) {
+        this.settledInteractions.add(interactionId);
+        if (this.settledInteractions.size <= MAX_SETTLED_INTERACTIONS)
+            return;
+        const oldest = this.settledInteractions.values().next().value;
+        if (oldest)
+            this.settledInteractions.delete(oldest);
     }
 }
 /**
@@ -330,6 +1360,11 @@ export function buildSandboxPolicy(options) {
 export function buildTextUserInput(message) {
     return [{ type: "text", text: message, text_elements: [] }];
 }
+export function buildRuntimeUserInput(input) {
+    return input.content.map((part) => part.type === "text"
+        ? { type: "text", text: part.text, text_elements: [] }
+        : { type: "localImage", path: part.path });
+}
 const defaultLogger = {
     log(entry) {
         console.log(JSON.stringify({