@agent-native/core 0.56.1 → 0.58.0

package/dist/client/chat/runtime.js

@@ -1,2 +1,935 @@
-export {};
+import { agentNativePath } from "../api-path.js";
+import { settleInterruptedToolCalls, } from "../sse-event-processor.js";
+const DEFAULT_RUNTIME_CAPABILITIES = {
+    messages: {
+        streaming: true,
+        history: true,
+        structuredContent: true,
+        attachments: true,
+    },
+    tools: {
+        events: true,
+        hostTools: true,
+        resultStreaming: true,
+        mcpApps: true,
+    },
+    sessions: {
+        create: true,
+        restore: true,
+        persistent: true,
+    },
+    cancellation: {
+        abortSignal: true,
+        explicitCancel: true,
+    },
+    models: {
+        selectable: true,
+        reasoningEffort: true,
+    },
+    artifacts: {
+        files: true,
+        links: true,
+        progress: true,
+    },
+};
+function mergeCapabilities(overrides) {
+    return {
+        ...DEFAULT_RUNTIME_CAPABILITIES,
+        ...overrides,
+        messages: {
+            ...DEFAULT_RUNTIME_CAPABILITIES.messages,
+            ...overrides?.messages,
+        },
+        tools: {
+            ...DEFAULT_RUNTIME_CAPABILITIES.tools,
+            ...overrides?.tools,
+            events: overrides?.tools?.events ?? DEFAULT_RUNTIME_CAPABILITIES.tools.events,
+        },
+        sessions: {
+            ...DEFAULT_RUNTIME_CAPABILITIES.sessions,
+            ...overrides?.sessions,
+            create: overrides?.sessions?.create ??
+                DEFAULT_RUNTIME_CAPABILITIES.sessions.create,
+        },
+        cancellation: {
+            ...DEFAULT_RUNTIME_CAPABILITIES.cancellation,
+            ...overrides?.cancellation,
+        },
+        models: { ...DEFAULT_RUNTIME_CAPABILITIES.models, ...overrides?.models },
+        artifacts: {
+            ...DEFAULT_RUNTIME_CAPABILITIES.artifacts,
+            ...overrides?.artifacts,
+        },
+    };
+}
+function createRuntimeId(prefix) {
+    if (typeof crypto !== "undefined" &&
+        typeof crypto.randomUUID === "function") {
+        return `${prefix}-${crypto.randomUUID()}`;
+    }
+    return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function createAbortController(signal) {
+    const controller = new AbortController();
+    if (!signal)
+        return { controller, cleanup: () => { } };
+    if (signal.aborted)
+        controller.abort();
+    const abort = () => controller.abort();
+    signal.addEventListener("abort", abort, { once: true });
+    return {
+        controller,
+        cleanup: () => signal.removeEventListener("abort", abort),
+    };
+}
+async function resolveHeaders(headers, input) {
+    const resolved = typeof headers === "function" ? await headers(input) : headers;
+    return new Headers(resolved);
+}
+function normalizeEndpoint(value) {
+    return typeof value === "string" ? value : value.toString();
+}
+function isRuntimeEvent(value) {
+    return (!!value &&
+        typeof value === "object" &&
+        typeof value.type === "string");
+}
+function parseJsonEvent(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed === "[DONE]")
+        return null;
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return null;
+    }
+}
+async function* readJsonEventStream(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let pendingSseData = [];
+    const flushSseData = function* () {
+        if (pendingSseData.length === 0)
+            return;
+        const parsed = parseJsonEvent(pendingSseData.join("\n"));
+        pendingSseData = [];
+        if (parsed)
+            yield parsed;
+    };
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split(/\r?\n/);
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+                if (line.startsWith("data:")) {
+                    pendingSseData.push(line.slice(5).trimStart());
+                    continue;
+                }
+                if (line.trim() === "") {
+                    yield* flushSseData();
+                    continue;
+                }
+                const parsed = parseJsonEvent(line);
+                if (parsed)
+                    yield parsed;
+            }
+        }
+        if (buffer.trim()) {
+            const parsed = parseJsonEvent(buffer);
+            if (parsed)
+                yield parsed;
+        }
+        yield* flushSseData();
+    }
+    finally {
+        try {
+            reader.releaseLock();
+        }
+        catch {
+            // Some browser runtimes consider a cancelled stream locked for a tick.
+        }
+    }
+}
+function textResponseEvents(text, sessionId, turnId) {
+    const message = {
+        id: createRuntimeId("message"),
+        role: "assistant",
+        content: [],
+    };
+    return [
+        { type: "message-start", sessionId, turnId, message },
+        ...(text
+            ? [
+                {
+                    type: "message-delta",
+                    sessionId,
+                    turnId,
+                    messageId: message.id,
+                    delta: { type: "text", text },
+                },
+            ]
+            : []),
+        { type: "message-done", sessionId, turnId, message },
+        { type: "done", sessionId, turnId, reason: "complete" },
+    ];
+}
+async function* eventsFromJsonResponse(value, sessionId, turnId) {
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            if (isRuntimeEvent(item))
+                yield item;
+        }
+        return;
+    }
+    if (!value || typeof value !== "object")
+        return;
+    const record = value;
+    if (Array.isArray(record.events)) {
+        for (const item of record.events) {
+            if (isRuntimeEvent(item))
+                yield item;
+        }
+        return;
+    }
+    const text = typeof record.message === "string"
+        ? record.message
+        : typeof record.text === "string"
+            ? record.text
+            : "";
+    if (text) {
+        for (const event of textResponseEvents(text, sessionId, turnId)) {
+            yield event;
+        }
+    }
+}
+function defaultMapHttpRuntimeEvent(event, _context) {
+    if (!isRuntimeEvent(event))
+        return null;
+    return event;
+}
+function normalizeMappedEvents(mapped) {
+    if (!mapped)
+        return [];
+    return Array.isArray(mapped)
+        ? mapped
+        : [mapped];
+}
+async function* streamResponseEvents(response, input) {
+    const context = {
+        sessionId: input.sessionId,
+        turnId: input.turnId,
+        runId: input.runId,
+    };
+    const contentType = response.headers.get("content-type") ?? "";
+    if (response.body && !contentType.includes("application/json")) {
+        for await (const raw of readJsonEventStream(response.body)) {
+            for (const event of normalizeMappedEvents(input.mapEvent(raw, context))) {
+                yield event;
+            }
+        }
+        return;
+    }
+    const json = await response.json().catch(() => null);
+    for await (const event of eventsFromJsonResponse(json, input.sessionId, input.turnId)) {
+        for (const mapped of normalizeMappedEvents(input.mapEvent(event, context))) {
+            yield mapped;
+        }
+    }
+}
+function defaultHttpRuntimeRequest(input) {
+    return {
+        sessionId: input.session.id,
+        threadId: input.session.threadId,
+        turnId: input.turnId,
+        prompt: input.turn.prompt,
+        messages: input.turn.messages,
+        attachments: input.turn.attachments,
+        tools: input.turn.tools,
+        model: input.turn.model,
+        reasoningEffort: input.turn.reasoningEffort,
+        temperature: input.turn.temperature,
+        providerOptions: input.turn.providerOptions,
+        metadata: input.turn.metadata,
+    };
+}
+async function readErrorText(response) {
+    const text = await response.text().catch(() => "");
+    if (!text)
+        return `HTTP ${response.status}`;
+    try {
+        const parsed = JSON.parse(text);
+        if (typeof parsed.error === "string")
+            return parsed.error;
+        if (typeof parsed.message === "string")
+            return parsed.message;
+    }
+    catch {
+        // Keep raw text.
+    }
+    return text.slice(0, 500);
+}
+export function createHttpAgentChatRuntime(options) {
+    const fetchImpl = options.fetch ?? fetch;
+    const capabilities = mergeCapabilities(options.capabilities);
+    const runtimeId = options.id ?? "external:http";
+    const mapEvent = options.mapEvent ??
+        defaultMapHttpRuntimeEvent;
+    const createSessionObject = (input) => {
+        const sessionId = input?.id ?? input?.threadId ?? createRuntimeId("session");
+        const summary = {
+            id: sessionId,
+            runtimeId,
+            threadId: input?.threadId,
+            title: input?.title,
+            status: "idle",
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+            metadata: input?.metadata,
+        };
+        const startTurn = async (turn) => {
+            const turnId = createRuntimeId("turn");
+            const { controller, cleanup } = createAbortController(turn.abortSignal);
+            const endpoint = typeof options.endpoint === "function"
+                ? options.endpoint({ session: summary, turn })
+                : options.endpoint;
+            const headers = await resolveHeaders(options.headers, {
+                sessionId,
+                turnId,
+            });
+            if (!headers.has("Content-Type"))
+                headers.set("Content-Type", "application/json");
+            const response = await fetchImpl(normalizeEndpoint(endpoint), {
+                method: options.method ?? "POST",
+                headers,
+                credentials: options.credentials,
+                body: JSON.stringify(options.mapRequest
+                    ? options.mapRequest({ session: summary, turn, turnId })
+                    : defaultHttpRuntimeRequest({ session: summary, turn, turnId })),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                cleanup();
+                throw new Error(await readErrorText(response));
+            }
+            const runId = response.headers.get("X-Run-Id") ?? undefined;
+            const events = (async function* () {
+                try {
+                    yield* streamResponseEvents(response, {
+                        sessionId,
+                        turnId,
+                        runId,
+                        mapEvent,
+                    });
+                }
+                finally {
+                    cleanup();
+                }
+            })();
+            return {
+                id: turnId,
+                sessionId,
+                runId,
+                events,
+                cancel: async (cancelInput) => {
+                    controller.abort();
+                    if (!options.cancelEndpoint)
+                        return { status: "cancelled" };
+                    const endpoint = typeof options.cancelEndpoint === "function"
+                        ? options.cancelEndpoint({
+                            ...cancelInput,
+                            sessionId,
+                            turnId,
+                            runId,
+                        })
+                        : options.cancelEndpoint;
+                    if (!endpoint)
+                        return { status: "unsupported" };
+                    const cancelHeaders = await resolveHeaders(options.headers, {
+                        sessionId,
+                        turnId,
+                    });
+                    if (!cancelHeaders.has("Content-Type")) {
+                        cancelHeaders.set("Content-Type", "application/json");
+                    }
+                    const cancelResponse = await fetchImpl(normalizeEndpoint(endpoint), {
+                        method: "POST",
+                        headers: cancelHeaders,
+                        credentials: options.credentials,
+                        body: JSON.stringify({
+                            sessionId,
+                            turnId,
+                            runId,
+                            reason: cancelInput?.reason ?? "user",
+                            metadata: cancelInput?.metadata,
+                        }),
+                        signal: cancelInput?.abortSignal,
+                    });
+                    return cancelResponse.ok
+                        ? { status: "cancelled" }
+                        : {
+                            status: "unsupported",
+                            message: await readErrorText(cancelResponse),
+                        };
+                },
+            };
+        };
+        return {
+            id: sessionId,
+            runtimeId,
+            threadId: input?.threadId,
+            capabilities,
+            sendMessage: startTurn,
+            startTurn,
+            snapshot: () => ({
+                ...summary,
+                status: "idle",
+                updatedAt: new Date().toISOString(),
+                messages: input?.messages,
+                resumeState: input?.resumeState,
+            }),
+            dispose: () => undefined,
+        };
+    };
+    const runtime = {
+        id: runtimeId,
+        kind: options.kind ?? "external-agent",
+        label: options.label ?? "External agent",
+        description: options.description,
+        capabilities,
+        createSession: createSessionObject,
+        restoreSession: (snapshot) => createSessionObject({
+            id: snapshot.id,
+            threadId: snapshot.threadId,
+            title: snapshot.title,
+            messages: snapshot.messages,
+            resumeState: snapshot.resumeState,
+            metadata: snapshot.metadata,
+        }),
+        sendMessage: async (input) => {
+            const session = createSessionObject({
+                id: input.sessionId,
+                threadId: input.sessionId,
+                metadata: input.metadata,
+            });
+            return session.startTurn(input);
+        },
+        subscribe: async (input) => {
+            if (!options.resumeEndpoint)
+                return (async function* () { })();
+            const endpoint = typeof options.resumeEndpoint === "function"
+                ? options.resumeEndpoint(input)
+                : options.resumeEndpoint;
+            if (!endpoint)
+                return (async function* () { })();
+            const headers = await resolveHeaders(options.headers, input);
+            const response = await fetchImpl(normalizeEndpoint(endpoint), {
+                headers,
+                credentials: options.credentials,
+                signal: input.abortSignal,
+            });
+            if (!response.ok)
+                throw new Error(await readErrorText(response));
+            return streamResponseEvents(response, {
+                sessionId: input.sessionId ?? "session",
+                turnId: input.turnId,
+                runId: input.runId,
+                mapEvent,
+            });
+        },
+        resume: async (input) => {
+            const sessionId = input.sessionId ?? createRuntimeId("session");
+            const events = runtime.subscribe
+                ? await runtime.subscribe(input)
+                : (async function* () { })();
+            return {
+                id: input.turnId,
+                sessionId,
+                runId: input.runId,
+                events,
+            };
+        },
+        cancel: async (input) => {
+            if (!options.cancelEndpoint)
+                return { status: "unsupported" };
+            const endpoint = typeof options.cancelEndpoint === "function"
+                ? options.cancelEndpoint(input)
+                : options.cancelEndpoint;
+            if (!endpoint)
+                return { status: "unsupported" };
+            const headers = await resolveHeaders(options.headers, input);
+            if (!headers.has("Content-Type"))
+                headers.set("Content-Type", "application/json");
+            const response = await fetchImpl(normalizeEndpoint(endpoint), {
+                method: "POST",
+                headers,
+                credentials: options.credentials,
+                body: JSON.stringify(input),
+                signal: input.abortSignal,
+            });
+            return response.ok
+                ? { status: "cancelled" }
+                : { status: "unsupported", message: await readErrorText(response) };
+        },
+    };
+    return runtime;
+}
+function runtimeMessageText(message) {
+    return message.content
+        .map((part) => part.type === "text" || part.type === "reasoning" ? part.text : "")
+        .filter(Boolean)
+        .join("\n");
+}
+function nativeHistoryFromMessages(messages, currentPrompt) {
+    const history = (messages ?? [])
+        .filter((message) => message.role === "user" || message.role === "assistant")
+        .map((message) => ({
+        role: message.role,
+        content: runtimeMessageText(message),
+    }))
+        .filter((message) => message.content.trim());
+    if (!currentPrompt.trim())
+        return history;
+    const last = history[history.length - 1];
+    return last?.role === "user" && last.content === currentPrompt
+        ? history.slice(0, -1)
+        : history;
+}
+function mapAgentNativeEvent(raw, input) {
+    if (!raw || typeof raw !== "object")
+        return [];
+    const ev = raw;
+    const base = {
+        sessionId: input.sessionId,
+        turnId: input.turnId,
+    };
+    if (ev.seq !== undefined) {
+        base.metadata = {
+            seq: ev.seq,
+        };
+    }
+    if (ev.type === "text") {
+        const text = ev.text ?? "";
+        const events = [];
+        if (!input.text.started) {
+            input.text.started = true;
+            events.push({
+                type: "message-start",
+                ...base,
+                message: {
+                    id: input.messageId,
+                    role: "assistant",
+                    content: [],
+                },
+            });
+        }
+        input.text.value += text;
+        events.push({
+            type: "message-delta",
+            ...base,
+            messageId: input.messageId,
+            delta: { type: "text", text },
+        });
+        return events;
+    }
+    if (ev.type === "activity") {
+        return [
+            {
+                type: "status",
+                ...base,
+                message: ev.label ?? ev.tool ?? "Working",
+                metadata: ev.tool ? { tool: ev.tool } : undefined,
+            },
+        ];
+    }
+    if (ev.type === "tool_start") {
+        return [
+            {
+                type: "tool-start",
+                ...base,
+                toolCall: {
+                    id: ev.id ?? createRuntimeId("tool"),
+                    name: ev.tool ?? "unknown",
+                    input: ev.input,
+                    inputText: ev.input ? JSON.stringify(ev.input) : undefined,
+                },
+            },
+        ];
+    }
+    if (ev.type === "tool_done") {
+        return [
+            {
+                type: "tool-done",
+                ...base,
+                toolCallId: ev.id ?? "",
+                toolName: ev.tool ?? "unknown",
+                status: ev.error ? "failed" : "completed",
+                result: ev.result,
+                resultText: typeof ev.result === "string"
+                    ? ev.result
+                    : ev.result !== undefined
+                        ? JSON.stringify(ev.result)
+                        : undefined,
+                error: ev.error,
+                mcpApp: ev.mcpApp,
+                chatUI: ev.chatUI,
+            },
+        ];
+    }
+    if (ev.type === "approval_required") {
+        return [
+            {
+                type: "approval-request",
+                ...base,
+                approvalId: ev.approvalKey ?? ev.id ?? createRuntimeId("approval"),
+                toolCallId: ev.id,
+                toolName: ev.tool,
+                message: ev.label ?? "Approve this tool call?",
+                input: ev.input,
+            },
+        ];
+    }
+    if (ev.type === "error" || ev.type === "missing_api_key") {
+        return [
+            {
+                type: "error",
+                ...base,
+                error: ev.error ?? "Agent chat failed.",
+                code: ev.errorCode,
+                recoverable: ev.recoverable,
+            },
+            { type: "done", ...base, reason: "error" },
+        ];
+    }
+    if (ev.type === "done") {
+        const message = {
+            id: input.messageId,
+            role: "assistant",
+            content: input.text.value
+                ? [{ type: "text", text: input.text.value }]
+                : [],
+        };
+        return [
+            ...(input.text.started
+                ? [{ type: "message-done", ...base, message }]
+                : []),
+            { type: "done", ...base, reason: "complete" },
+        ];
+    }
+    return [];
+}
+export function createAgentNativeChatRuntime(options = {}) {
+    const apiUrl = options.apiUrl ?? agentNativePath("/_agent-native/agent-chat");
+    const runtimeId = options.id ?? "agent-native";
+    const fetchImpl = options.fetch ?? fetch;
+    return createHttpAgentChatRuntime({
+        id: runtimeId,
+        kind: "agent-native",
+        label: options.label ?? "Agent Native",
+        description: options.description ?? "Agent-Native's built-in chat transport.",
+        endpoint: apiUrl,
+        fetch: fetchImpl,
+        headers: async (input) => {
+            const headers = await resolveHeaders(options.headers, input);
+            headers.set("x-agent-native-surface", options.surface ?? "app");
+            return headers;
+        },
+        capabilities: DEFAULT_RUNTIME_CAPABILITIES,
+        mapRequest: ({ session, turn, turnId }) => {
+            const prompt = turn.prompt ??
+                [...(turn.messages ?? [])]
+                    .reverse()
+                    .find((message) => message.role === "user")
+                    ?.content.map((part) => (part.type === "text" ? part.text : ""))
+                    .join("\n") ??
+                "";
+            return {
+                message: prompt,
+                displayMessage: prompt,
+                history: nativeHistoryFromMessages(turn.messages, prompt),
+                turnId,
+                threadId: session.threadId ?? options.threadId,
+                ...(options.mode ? { mode: options.mode } : {}),
+                ...((turn.model ?? options.model)
+                    ? { model: turn.model ?? options.model }
+                    : {}),
+                ...(options.engine ? { engine: options.engine } : {}),
+                ...((turn.reasoningEffort ?? options.effort)
+                    ? { effort: turn.reasoningEffort ?? options.effort }
+                    : {}),
+                ...(options.browserTabId ? { browserTabId: options.browserTabId } : {}),
+                ...(options.scope ? { scope: options.scope } : {}),
+                ...(turn.attachments?.length ? { attachments: turn.attachments } : {}),
+                ...(turn.metadata ? { metadata: turn.metadata } : {}),
+            };
+        },
+        mapEvent: (() => {
+            const states = new Map();
+            return (event, context) => {
+                const stateKey = context.turnId ?? context.sessionId;
+                let state = states.get(stateKey);
+                if (!state) {
+                    state = {
+                        messageId: createRuntimeId("message"),
+                        text: { value: "", started: false },
+                    };
+                    states.set(stateKey, state);
+                }
+                const mapped = mapAgentNativeEvent(event, {
+                    sessionId: context.sessionId,
+                    turnId: context.turnId,
+                    messageId: state.messageId,
+                    text: state.text,
+                });
+                const type = event && typeof event === "object"
+                    ? event.type
+                    : undefined;
+                if (type === "done" || type === "error" || type === "missing_api_key") {
+                    states.delete(stateKey);
+                }
+                return mapped;
+            };
+        })(),
+        cancelEndpoint: (input) => input.runId
+            ? `${apiUrl}/runs/${encodeURIComponent(input.runId)}/abort`
+            : null,
+        resumeEndpoint: (input) => input.runId
+            ? `${apiUrl}/runs/${encodeURIComponent(input.runId)}/events?after=${input.after ?? 0}`
+            : null,
+    });
+}
+function toContentPartInput(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return {};
+    const out = {};
+    for (const [key, item] of Object.entries(value)) {
+        out[key] = typeof item === "string" ? item : JSON.stringify(item);
+    }
+    return out;
+}
+function toolResultText(value) {
+    if (typeof value === "string")
+        return value;
+    if (value === undefined)
+        return "";
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function applyRuntimeEventToContent(event, content) {
+    const typed = event;
+    if (typed.type === "message-start") {
+        for (const part of typed.message.content) {
+            if (part.type === "text" && part.text) {
+                content.push({ type: "text", text: part.text });
+            }
+        }
+        return { content: [...content] };
+    }
+    if (typed.type === "message-delta") {
+        if (typed.delta.type === "text") {
+            const last = content[content.length - 1];
+            if (last?.type === "text") {
+                last.text += typed.delta.text;
+            }
+            else {
+                content.push({ type: "text", text: typed.delta.text });
+            }
+            return { content: [...content] };
+        }
+        return null;
+    }
+    if (typed.type === "message-done") {
+        return { content: [...content] };
+    }
+    if (typed.type === "tool-start") {
+        content.push({
+            type: "tool-call",
+            toolCallId: typed.toolCall.id,
+            toolName: typed.toolCall.name,
+            argsText: typed.toolCall.inputText ?? JSON.stringify(typed.toolCall.input ?? {}),
+            args: toContentPartInput(typed.toolCall.input),
+        });
+        return { content: [...content] };
+    }
+    if (typed.type === "tool-delta") {
+        const part = [...content]
+            .reverse()
+            .find((candidate) => candidate.type === "tool-call" &&
+            candidate.toolCallId === typed.toolCallId);
+        if (!part)
+            return null;
+        if (typed.inputTextDelta) {
+            part.argsText += typed.inputTextDelta;
+        }
+        if (typed.resultTextDelta) {
+            part.result = `${part.result ?? ""}${typed.resultTextDelta}`;
+        }
+        return { content: [...content] };
+    }
+    if (typed.type === "tool-done") {
+        const part = [...content]
+            .reverse()
+            .find((candidate) => candidate.type === "tool-call" &&
+            candidate.toolCallId === typed.toolCallId);
+        if (part) {
+            part.result =
+                typed.error ?? typed.resultText ?? toolResultText(typed.result);
+            if (typed.mcpApp)
+                part.mcpApp = typed.mcpApp;
+            if (typed.chatUI)
+                part.chatUI = typed.chatUI;
+        }
+        return { content: [...content] };
+    }
+    if (typed.type === "approval-request") {
+        const part = [...content]
+            .reverse()
+            .find((candidate) => candidate.type === "tool-call" &&
+            (candidate.toolCallId === typed.toolCallId ||
+                candidate.toolName === typed.toolName));
+        if (part) {
+            part.approval = { approvalKey: typed.approvalId };
+        }
+        else {
+            content.push({
+                type: "tool-call",
+                toolCallId: typed.toolCallId ?? typed.approvalId,
+                toolName: typed.toolName ?? "approval",
+                argsText: typed.input ? JSON.stringify(typed.input) : "",
+                args: toContentPartInput(typed.input),
+                approval: { approvalKey: typed.approvalId },
+            });
+        }
+        return { content: [...content] };
+    }
+    if (typed.type === "error") {
+        settleInterruptedToolCalls(content);
+        content.push({
+            type: "text",
+            text: `Something went wrong: ${typed.error}`,
+        });
+        return {
+            content: [...content],
+            status: { type: "incomplete", reason: "error" },
+            metadata: {
+                custom: {
+                    runError: {
+                        message: typed.error,
+                        ...(typed.code ? { errorCode: typed.code } : {}),
+                        ...(typed.recoverable ? { recoverable: typed.recoverable } : {}),
+                    },
+                },
+            },
+        };
+    }
+    if (typed.type === "done") {
+        return {
+            content: [...content],
+            status: typed.reason === "error"
+                ? { type: "incomplete", reason: "error" }
+                : { type: "complete", reason: "stop" },
+        };
+    }
+    return null;
+}
+function assistantMessageText(message) {
+    return (message.content ?? [])
+        .filter((part) => part.type === "text")
+        .map((part) => part.text)
+        .join("\n");
+}
+function assistantMessagesToRuntimeMessages(messages) {
+    return messages
+        .filter((message) => message.role === "user" || message.role === "assistant")
+        .map((message, index) => {
+        const content = [];
+        for (const part of message.content ?? []) {
+            if (part.type === "text" && typeof part.text === "string") {
+                content.push({ type: "text", text: part.text });
+            }
+            else if (part.type === "image" && typeof part.image === "string") {
+                content.push({ type: "image", data: part.image });
+            }
+        }
+        return {
+            id: `assistant-ui-${index}`,
+            role: message.role,
+            content,
+        };
+    });
+}
+function latestUserPrompt(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const message = messages[i];
+        if (message.role !== "user")
+            continue;
+        return assistantMessageText(message);
+    }
+    return "";
+}
+export function createAgentChatRuntimeAdapter(runtime, options = {}) {
+    let sessionPromise = null;
+    const getSession = () => {
+        sessionPromise ??= Promise.resolve(runtime.createSession({
+            id: options.sessionId ?? options.threadId,
+            threadId: options.threadId,
+            metadata: options.metadata,
+        }));
+        return sessionPromise;
+    };
+    return {
+        async *run({ messages, abortSignal }) {
+            const adapterMessages = messages;
+            const session = await getSession();
+            const prompt = latestUserPrompt(adapterMessages);
+            const turn = await session.startTurn({
+                prompt,
+                messages: assistantMessagesToRuntimeMessages(adapterMessages),
+                model: options.modelRef?.current,
+                reasoningEffort: options.effortRef?.current,
+                abortSignal,
+                metadata: options.metadata,
+            });
+            const content = [];
+            try {
+                for await (const event of turn.events) {
+                    const result = applyRuntimeEventToContent(event, content);
+                    if (result) {
+                        const metadata = (result.metadata ?? {});
+                        const custom = metadata.custom && typeof metadata.custom === "object"
+                            ? metadata.custom
+                            : {};
+                        yield {
+                            ...result,
+                            metadata: {
+                                ...metadata,
+                                custom: {
+                                    ...custom,
+                                    runtimeId: runtime.id,
+                                    ...(turn.runId ? { runId: turn.runId } : {}),
+                                },
+                            },
+                        };
+                    }
+                }
+            }
+            catch (error) {
+                if (error instanceof Error && error.name === "AbortError") {
+                    await turn.cancel?.({ reason: "abort" });
+                    return;
+                }
+                throw error;
+            }
+        },
+    };
+}
 //# sourceMappingURL=runtime.js.map