@datalayer/agent-runtimes 1.5.21 → 1.5.23

package/lib/portable/index.js

@@ -2,19 +2,22 @@
  * Copyright (c) 2025-2026 Datalayer, Inc.
  * Distributed under the terms of the Modified BSD License.
  */
-/*
- * Copyright (c) 2026 Datalayer, Inc.
- * Distributed under the terms of the Modified BSD License.
- */
 /**
  * What any JavaScript runtime can import from Agent Runtimes: no React, DOM,
- * Jupyter or Node built-in. Re-exports only; the mobile app reaches Agent
- * Runtimes through this entry alone.
+ * Jupyter, Reactor or Node module. Every module it reaches at run time lives
+ * in this folder (a test holds it to that), so that Datalayer Mobile's Metro
+ * graph takes `lib/portable/*` and nothing else of Agent Runtimes.
  *
  * @module portable
  */
-export { messageOfApproval, normalizeApproval, whyAsked, } from '../utils/approvals';
-// The AG-UI stream client and the messages it builds; a phone passes a
-// streaming `fetch` in the adapter's config.
-export { AGUIAdapter } from '../protocols/AGUIAdapter';
-export { createActivityMessage, createAssistantMessage, createUserMessage, generateMessageId, } from '../types/messages';
+export { messageOfApproval, normalizeApproval, whyAsked, } from './approvals';
+// A run's stream, read as every client reads it.
+export { AgUiFrames, endsRun, eventsOfStream, NOT_STREAMING, REACTOR_UI_NAME, readRunStream, RUN_CUT_SHORT, toolResultOf, UI_ON_RUN, } from './agui';
+export { AG_UI_NOT_ALLOWED, AG_UI_NOT_ON_RUNTIME, agUiRefusal, refusalBody, refusalDetail, } from './agUiRefusal';
+// The record's words, and a person's conversation read again.
+export { ASKED_FOR_TAG, askedOf, RUN_END_WORDS } from './records';
+export { messagesOfThread, openThread, snapshotOfStream, THREAD_WORDS, } from './thread';
+// A conversation as its stream builds it, for a native client.
+export { CUT_MARK, DIAGNOSTIC_LIMIT, emptyConversation, formFieldsOf, ITEM_LIMIT, MESSAGE_TEXT_LIMIT, questionOf, questionWords, reduceConversation, TOOL_TEXT_LIMIT, withError, withPrompt, withTurnEnded, } from './conversation';
+// The runtime's routes a native client drives.
+export { agentRunClient, agentRuntimesUrlOf, appSessionsClient, RuntimeRefusal, } from './sessions';

package/lib/portable/records.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The words of an application's record that every client shows the same:
+ * how a run ended, and what a person asked without what the runtime told the
+ * application before their words. Read by the web's record feed
+ * (`apps/apps/records`), the chat and Datalayer Mobile.
+ *
+ * @module portable/records
+ */
+/**
+ * How a run ended, in the `output` entry every run ends with, kept whatever
+ * the application's `record.include` says (PAP_DATALAYER R-01): its words
+ * only when it keeps `outputs`.
+ */
+export declare const RUN_END_WORDS: Record<string, string>;
+/**
+ * The mark around what the runtime tells an application of a turn a personal
+ * agent asked over PAP or PACT, before the request (`asked_for_said`,
+ * `ASKED_FOR_TAG` in agent_runtimes.loop.apps.pap_company).
+ */
+export declare const ASKED_FOR_TAG = "asked-for";
+/**
+ * What a person asked, as they are shown it: without what the runtime told
+ * the application before their words (PAP_DATALAYER, decided 2026-10-14).
+ * The record keeps it for the application's builder; the person never wrote
+ * it, so *Your conversations* and a thread opened again leave it out.
+ */
+export declare function askedOf(text: string): string;

package/lib/portable/records.js

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The words of an application's record that every client shows the same:
+ * how a run ended, and what a person asked without what the runtime told the
+ * application before their words. Read by the web's record feed
+ * (`apps/apps/records`), the chat and Datalayer Mobile.
+ *
+ * @module portable/records
+ */
+/**
+ * How a run ended, in the `output` entry every run ends with, kept whatever
+ * the application's `record.include` says (PAP_DATALAYER R-01): its words
+ * only when it keeps `outputs`.
+ */
+export const RUN_END_WORDS = {
+    answered: 'Answered',
+    stopped: 'Stopped',
+    gone: 'Its client went before the answer',
+};
+/**
+ * The mark around what the runtime tells an application of a turn a personal
+ * agent asked over PAP or PACT, before the request (`asked_for_said`,
+ * `ASKED_FOR_TAG` in agent_runtimes.loop.apps.pap_company).
+ */
+export const ASKED_FOR_TAG = 'asked-for';
+/**
+ * What a person asked, as they are shown it: without what the runtime told
+ * the application before their words (PAP_DATALAYER, decided 2026-10-14).
+ * The record keeps it for the application's builder; the person never wrote
+ * it, so *Your conversations* and a thread opened again leave it out.
+ */
+export function askedOf(text) {
+    const open = `<${ASKED_FOR_TAG}>`;
+    const close = `</${ASKED_FOR_TAG}>`;
+    if (!text.startsWith(open)) {
+        return text;
+    }
+    const end = text.indexOf(close);
+    if (end < 0) {
+        throw new Error(`What was asked opens <${ASKED_FOR_TAG}> and never closes it.`);
+    }
+    return text.slice(end + close.length).trimStart();
+}

package/lib/portable/sessions.d.ts

@@ -0,0 +1,92 @@
+/**
+ * The clients a native app talks to a runtime with: an application's
+ * sessions (`/api/v1/apps/sessions`, the Session API) and a standalone agent's
+ * AG-UI mount (`/api/v1/ag-ui/{agent}/`). Each streaming route's events are
+ * handed to `onEvent` as they arrive (`readRunStream`); a refusal is thrown
+ * as a `RuntimeRefusal` with its status and the runtime's own sentence.
+ *
+ * Nothing is read from a page: the runtime's address, the token and a
+ * `fetch` that streams are given (`{ baseUrl, getAccessToken, fetch }`).
+ *
+ * @module portable/sessions
+ */
+import type { ChatMessage } from '../types/messages';
+import { type AgUiEvent } from './agui';
+/** Where a runtime is, and as whom it is asked. */
+export type RuntimeClientOptions = {
+    /** The runtime's agent-runtimes address (`…/agent-runtimes/<runtime>`). */
+    baseUrl: string;
+    getAccessToken: () => string | undefined;
+    /** A `fetch` whose response body streams. */
+    fetch: typeof fetch;
+};
+/** A streaming request's listener and its cancellation. */
+export type StreamOptions = {
+    onEvent: (event: AgUiEvent) => void;
+    signal?: AbortSignal;
+};
+/** A route that refused: its status and the runtime's sentence. */
+export declare class RuntimeRefusal extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+/** What starting a session names: the application's agent and what it runs. */
+export type SessionStart = {
+    /** The agent the runtime made for the application. */
+    agent: string;
+    deploymentUid?: string;
+    appUid?: string;
+    version?: number;
+    /** The first message. */
+    opener: string;
+    /** The session's uid, when the client chose it. */
+    session?: string;
+};
+/**
+ * An application's sessions on the runtime that runs it: start, message,
+ * settings, resume (streamed), and stop, end, read (JSON).
+ */
+export declare function appSessionsClient(options: RuntimeClientOptions): {
+    /** Start a session with its first message. */
+    start: (start: SessionStart, streaming: StreamOptions) => Promise<void>;
+    /** The next turn, or the answer to what the application asked (text, a choice). */
+    message: (uid: string, text: string, streaming: StreamOptions) => Promise<void>;
+    /** A settings change: also what answers a form the application asked. */
+    changeSettings: (uid: string, values: Record<string, unknown>, streaming: StreamOptions) => Promise<void>;
+    /** Resume a stopped session — or, with its agent, one the runtime no longer holds, from its record. */
+    resume: (uid: string, agent: string, streaming: StreamOptions) => Promise<void>;
+    /** Stop: what runs is cancelled; the session waits to be resumed. */
+    stop: (uid: string) => Promise<Record<string, unknown>>;
+    /** End the conversation for good; its record stays. */
+    end: (uid: string) => Promise<Record<string, unknown>>;
+    /** What the session is: its state (`open`, `running`, `waiting`, `stopped`) and what it asks. */
+    describe: (uid: string) => Promise<Record<string, unknown>>;
+    /** Its conversation as a person reads it (`messagesOfThread`). */
+    messages: (uid: string) => Promise<ChatMessage[]>;
+};
+export type AppSessionsClient = ReturnType<typeof appSessionsClient>;
+/** One turn of a conversation, as an agent's AG-UI run is sent it. */
+export type AgentTurn = {
+    id: string;
+    role: 'user' | 'assistant';
+    content: string;
+};
+/**
+ * A standalone agent over its AG-UI mount: a run carries the conversation so
+ * far, and stopping it terminates the thread's run on the runtime. A raw
+ * agent has no session, record or question of an application's.
+ */
+export declare function agentRunClient(options: RuntimeClientOptions & {
+    agent: string;
+}): {
+    run: (threadId: string, runId: string, messages: AgentTurn[], streaming: StreamOptions) => Promise<void>;
+    /** Stop the thread's run on the runtime (`POST /api/v1/ag-ui/terminate`). */
+    terminate: (threadId: string) => Promise<void>;
+};
+export type AgentRunClient = ReturnType<typeof agentRunClient>;
+/**
+ * A runtime's agent-runtimes address from its ingress, as the runtimes
+ * service gives it (`…/jupyter/server/<runtime>` → `…/agent-runtimes/<runtime>`,
+ * `build_agent_runtimes_base_url`). Refused when there is none.
+ */
+export declare function agentRuntimesUrlOf(ingress: string): string;

package/lib/portable/sessions.js

@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { readRunStream } from './agui';
+import { agUiRefusal, refusalBody } from './agUiRefusal';
+import { messagesOfThread } from './thread';
+/** A route that refused: its status and the runtime's sentence. */
+export class RuntimeRefusal extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = 'RuntimeRefusal';
+    }
+}
+function clientOf({ baseUrl, getAccessToken, fetch: fetcher, }) {
+    const root = baseUrl.replace(/\/+$/, '');
+    const headers = (extra = {}) => {
+        const token = getAccessToken();
+        return {
+            ...extra,
+            ...(token ? { Authorization: `Bearer ${token}` } : {}),
+        };
+    };
+    const refused = async (response) => {
+        throw new RuntimeRefusal(response.status, agUiRefusal(response.status, response.statusText, await refusalBody(response)));
+    };
+    const json = async (path, method = 'GET') => {
+        const response = await fetcher(`${root}${path}`, {
+            method,
+            headers: headers({ Accept: 'application/json' }),
+        });
+        if (!response.ok) {
+            return refused(response);
+        }
+        return (await response.json());
+    };
+    const stream = async (path, body, { onEvent, signal }, method = 'POST') => {
+        const response = await fetcher(`${root}${path}`, {
+            method,
+            headers: headers({
+                'Content-Type': 'application/json',
+                Accept: 'text/event-stream',
+            }),
+            body: JSON.stringify(body),
+            signal,
+        });
+        if (!response.ok) {
+            return refused(response);
+        }
+        await readRunStream(response, onEvent);
+    };
+    return { json, stream, refused, headers, root, fetcher };
+}
+const at = (uid) => `/api/v1/apps/sessions/${encodeURIComponent(uid)}`;
+/**
+ * An application's sessions on the runtime that runs it: start, message,
+ * settings, resume (streamed), and stop, end, read (JSON).
+ */
+export function appSessionsClient(options) {
+    const { json, stream } = clientOf(options);
+    return {
+        /** Start a session with its first message. */
+        start: (start, streaming) => stream('/api/v1/apps/sessions', {
+            agent: start.agent,
+            ...(start.deploymentUid
+                ? { deployment_uid: start.deploymentUid }
+                : {}),
+            ...(start.appUid ? { app_uid: start.appUid } : {}),
+            ...(start.version ? { version: start.version } : {}),
+            ...(start.session ? { session: start.session } : {}),
+            opener: start.opener,
+        }, streaming),
+        /** The next turn, or the answer to what the application asked (text, a choice). */
+        message: (uid, text, streaming) => stream(`${at(uid)}/messages`, { text }, streaming),
+        /** A settings change: also what answers a form the application asked. */
+        changeSettings: (uid, values, streaming) => stream(`${at(uid)}/settings`, { values }, streaming, 'PUT'),
+        /** Resume a stopped session — or, with its agent, one the runtime no longer holds, from its record. */
+        resume: (uid, agent, streaming) => stream(`${at(uid)}/resume`, { agent }, streaming),
+        /** Stop: what runs is cancelled; the session waits to be resumed. */
+        stop: (uid) => json(`${at(uid)}/stop`, 'POST'),
+        /** End the conversation for good; its record stays. */
+        end: (uid) => json(`${at(uid)}/end`, 'POST'),
+        /** What the session is: its state (`open`, `running`, `waiting`, `stopped`) and what it asks. */
+        describe: (uid) => json(at(uid)),
+        /** Its conversation as a person reads it (`messagesOfThread`). */
+        messages: async (uid) => messagesOfThread((await json(`${at(uid)}/messages`)).messages),
+    };
+}
+/**
+ * A standalone agent over its AG-UI mount: a run carries the conversation so
+ * far, and stopping it terminates the thread's run on the runtime. A raw
+ * agent has no session, record or question of an application's.
+ */
+export function agentRunClient(options) {
+    const { stream, refused, root, headers, fetcher } = clientOf(options);
+    return {
+        run: (threadId, runId, messages, streaming) => stream(`/api/v1/ag-ui/${encodeURIComponent(options.agent)}/`, {
+            threadId,
+            runId,
+            messages,
+            state: null,
+            tools: [],
+            context: [],
+            forwardedProps: null,
+        }, streaming),
+        /** Stop the thread's run on the runtime (`POST /api/v1/ag-ui/terminate`). */
+        terminate: async (threadId) => {
+            const response = await fetcher(`${root}/api/v1/ag-ui/terminate`, {
+                method: 'POST',
+                headers: headers({ 'Content-Type': 'application/json' }),
+                body: JSON.stringify({ thread_id: threadId }),
+            });
+            if (!response.ok) {
+                await refused(response);
+            }
+        },
+    };
+}
+/**
+ * A runtime's agent-runtimes address from its ingress, as the runtimes
+ * service gives it (`…/jupyter/server/<runtime>` → `…/agent-runtimes/<runtime>`,
+ * `build_agent_runtimes_base_url`). Refused when there is none.
+ */
+export function agentRuntimesUrlOf(ingress) {
+    const base = ingress.trim().replace(/\/+$/, '');
+    if (!/^https?:\/\//.test(base)) {
+        throw new Error(`The runtime gave no address to reach its agents: ${ingress || 'none'}.`);
+    }
+    return base.includes('/jupyter/server/')
+        ? base.replace('/jupyter/server/', '/agent-runtimes/')
+        : base;
+}

package/lib/portable/thread.d.ts

@@ -0,0 +1,41 @@
+/**
+ * A person's conversation with an application, read again: the person-facing
+ * projection of a session's thread, and the thread opened from the runtime
+ * that holds it — or resumed from its record (LOOP P-24, D-13, R-04).
+ *
+ * The web chat (`ChatView`, an embed after its page reloads) and Datalayer
+ * Mobile open a thread with these, so that what a person reads of their own
+ * conversation is the same on each. Pure: the network is the `fetch` given.
+ *
+ * @module portable/thread
+ */
+import type { ChatMessage } from '../types/messages';
+/** What opening a thread says, in a person's words. */
+export declare const THREAD_WORDS: {
+    readonly opening: "Opening your conversation…";
+    readonly notOpened: (detail: string) => string;
+};
+/**
+ * A session's conversation as a person reads it, from the AG-UI messages the
+ * runtime says (`GET …/sessions/{uid}/messages`, a `MESSAGES_SNAPSHOT`): what
+ * was said and answered, in words. A turn a personal agent asked is shown
+ * without what the runtime told the application before the person's words
+ * (`askedOf`, decided 2026-10-14). What its messages showed comes on the
+ * conversation's ui socket (REACTOR_UI RU-W), never here: a `reactor.ui`
+ * activity in a thread is refused.
+ */
+export declare function messagesOfThread(messages: unknown): ChatMessage[];
+/** The AG-UI messages a session-API stream's `MESSAGES_SNAPSHOT` carries, if one does. */
+export declare function snapshotOfStream(text: string): unknown[] | undefined;
+/**
+ * A thread's conversation, read from the runtime its application runs on:
+ * held there, or resumed from its record. Throws the runtime's sentence when
+ * neither answers.
+ */
+export declare function openThread({ agentBaseUrl, agentId, uid, token, fetcher, }: {
+    agentBaseUrl: string;
+    agentId: string;
+    uid: string;
+    token?: string | null;
+    fetcher?: typeof fetch;
+}): Promise<ChatMessage[]>;

package/lib/portable/thread.js

@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { eventsOfStream, REACTOR_UI_NAME } from './agui';
+import { askedOf } from './records';
+/** What opening a thread says, in a person's words. */
+export const THREAD_WORDS = {
+    opening: 'Opening your conversation…',
+    notOpened: (detail) => `Your conversation could not be opened, so this is a new one: ${detail}`,
+};
+/**
+ * A session's conversation as a person reads it, from the AG-UI messages the
+ * runtime says (`GET …/sessions/{uid}/messages`, a `MESSAGES_SNAPSHOT`): what
+ * was said and answered, in words. A turn a personal agent asked is shown
+ * without what the runtime told the application before the person's words
+ * (`askedOf`, decided 2026-10-14). What its messages showed comes on the
+ * conversation's ui socket (REACTOR_UI RU-W), never here: a `reactor.ui`
+ * activity in a thread is refused.
+ */
+export function messagesOfThread(messages) {
+    if (!Array.isArray(messages)) {
+        return [];
+    }
+    const drawn = [];
+    for (const message of messages) {
+        if (!message || typeof message !== 'object') {
+            continue;
+        }
+        const { id, role, content, activityType } = message;
+        if (role === 'activity' && activityType === REACTOR_UI_NAME) {
+            throw new Error(`Activity ${String(id)}: what a message showed comes on the ui socket (REACTOR_UI RU-W)`);
+        }
+        if ((role === 'user' || role === 'assistant') &&
+            typeof id === 'string' &&
+            typeof content === 'string' &&
+            content.trim()) {
+            drawn.push({
+                id,
+                role,
+                content: role === 'user' ? askedOf(content) : content,
+                createdAt: new Date(),
+            });
+        }
+    }
+    return drawn;
+}
+/** The AG-UI messages a session-API stream's `MESSAGES_SNAPSHOT` carries, if one does. */
+export function snapshotOfStream(text) {
+    let found;
+    for (const event of eventsOfStream(text)) {
+        if (event.type === 'MESSAGES_SNAPSHOT' && Array.isArray(event.messages)) {
+            found = event.messages;
+        }
+    }
+    return found;
+}
+async function detailOf(response) {
+    try {
+        const body = (await response.json());
+        if (typeof body.detail === 'string' && body.detail) {
+            return body.detail;
+        }
+    }
+    catch {
+        // No sentence: the status says it.
+    }
+    return `${response.status}`;
+}
+/**
+ * A thread's conversation, read from the runtime its application runs on:
+ * held there, or resumed from its record. Throws the runtime's sentence when
+ * neither answers.
+ */
+export async function openThread({ agentBaseUrl, agentId, uid, token, fetcher = fetch, }) {
+    const base = `${agentBaseUrl.replace(/\/+$/, '')}/api/v1/apps/sessions/${encodeURIComponent(uid)}`;
+    const authorization = token
+        ? { Authorization: `Bearer ${token}` }
+        : {};
+    const held = await fetcher(`${base}/messages`, { headers: authorization });
+    if (held.ok) {
+        const body = (await held.json());
+        return messagesOfThread(body.messages);
+    }
+    if (held.status !== 404) {
+        throw new Error(await detailOf(held));
+    }
+    // Not held here: resumed from its record, under the same uid.
+    const resumed = await fetcher(`${base}/resume`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...authorization },
+        body: JSON.stringify({ agent: agentId }),
+    });
+    if (!resumed.ok) {
+        throw new Error(await detailOf(resumed));
+    }
+    const snapshot = snapshotOfStream(await resumed.text());
+    if (!snapshot) {
+        throw new Error(`The runtime said nothing of session ${uid}.`);
+    }
+    return messagesOfThread(snapshot);
+}

package/lib/protocols/AGUIAdapter.d.ts

@@ -7,8 +7,6 @@ import type { ProtocolAdapterConfig } from '../types';
 import type { ChatMessage } from '../types/messages';
 import type { ToolDefinition, ToolExecutionResult } from '../types/tools';
 import { BaseProtocolAdapter } from './BaseProtocolAdapter';
-/** What the page says when a run's stream closes before the run said how it ended. */
-export declare const RUN_CUT_SHORT = "The run stopped before it finished, without an answer or an error: send it again.";
 /**
  * AG-UI specific configuration
  */

package/lib/protocols/AGUIAdapter.js

@@ -3,11 +3,9 @@
  * Distributed under the terms of the Modified BSD License.
  */
 import { generateMessageId, createAssistantMessage } from '../types/messages';
-import { agUiRefusal, refusalBody } from './agUiRefusal';
+import { agUiRefusal, refusalBody } from '../portable/agUiRefusal';
+import { AgUiFrames, endsRun, REACTOR_UI_NAME, RUN_CUT_SHORT, toolResultOf, UI_ON_RUN, } from '../portable/agui';
 import { BaseProtocolAdapter } from './BaseProtocolAdapter';
-import { AGUI_NAME } from '@datalayer/reactor/ui';
-/** What the page says when a run's stream closes before the run said how it ended. */
-export const RUN_CUT_SHORT = 'The run stopped before it finished, without an answer or an error: send it again.';
 /**
  * AG-UI protocol adapter
  * Uses HTTP POST with SSE streaming for responses
@@ -434,7 +432,8 @@ export class AGUIAdapter extends BaseProtocolAdapter {
             throw new Error('Response body is not readable');
         }
         const decoder = new TextDecoder();
-        let buffer = '';
+        // The stream's frames, read as every client reads them (portable/agui).
+        const frames = new AgUiFrames(data => console.warn('[AGUIAdapter] Failed to parse event data:', data));
         // Always start fresh — each turn gets its own message bubble.
         // Continuations will naturally appear AFTER the tool calls in the
         // display because they create a new message that is appended at the
@@ -459,56 +458,41 @@ export class AGUIAdapter extends BaseProtocolAdapter {
         // or the network — and the page says so instead of waiting for an answer
         // that is not coming (a Preview gave no answer for minutes, 2026-10-12).
         let ended = false;
+        const handle = (events) => {
+            for (const event of events) {
+                if (endsRun(event)) {
+                    ended = true;
+                }
+                this.handleAGUIEvent(event, {
+                    getCurrentMessageId: () => currentMessageId,
+                    setCurrentMessageId: id => {
+                        currentMessageId = id;
+                    },
+                    getCurrentContent: () => currentContent,
+                    appendContent: content => {
+                        currentContent += content;
+                    },
+                    resetContent: () => {
+                        currentContent = '';
+                    },
+                    appendTurnContent: content => {
+                        currentTurnContent += content;
+                    },
+                    getCurrentTurnContent: () => currentTurnContent,
+                });
+            }
+        };
         try {
             while (true) {
                 const { done, value } = await reader.read();
                 if (done) {
+                    handle(frames.end());
                     if (!ended) {
                         throw new Error(RUN_CUT_SHORT);
                     }
                     break;
                 }
-                buffer += decoder.decode(value, { stream: true });
-                const lines = buffer.split('\n');
-                buffer = lines.pop() || '';
-                for (const line of lines) {
-                    if (line.startsWith('event: ')) {
-                        // Event type (currently unused)
-                        // const eventType = line.slice(7);
-                        // Handle event type if needed
-                    }
-                    else if (line.startsWith('data: ')) {
-                        const data = line.slice(6);
-                        try {
-                            const event = JSON.parse(data);
-                            const kind = event.type;
-                            if (kind === 'RUN_FINISHED' || kind === 'RUN_ERROR') {
-                                ended = true;
-                            }
-                            this.handleAGUIEvent(event, {
-                                getCurrentMessageId: () => currentMessageId,
-                                setCurrentMessageId: id => {
-                                    currentMessageId = id;
-                                },
-                                getCurrentContent: () => currentContent,
-                                appendContent: content => {
-                                    currentContent += content;
-                                },
-                                resetContent: () => {
-                                    currentContent = '';
-                                },
-                                appendTurnContent: content => {
-                                    currentTurnContent += content;
-                                },
-                                getCurrentTurnContent: () => currentTurnContent,
-                            });
-                        }
-                        catch (e) {
-                            // Non-JSON data, might be raw content
-                            console.warn('[AGUIAdapter] Failed to parse event data:', e);
-                        }
-                    }
-                }
+                handle(frames.push(decoder.decode(value, { stream: true })));
             }
         }
         finally {
@@ -531,7 +515,7 @@ export class AGUIAdapter extends BaseProtocolAdapter {
     refuseUiOnRun() {
         this.emit({
             type: 'error',
-            error: new Error('A reactor.ui op came on the run stream: it comes over the ui socket (REACTOR_UI RU-W).'),
+            error: new Error(UI_ON_RUN),
             timestamp: new Date(),
         });
     }
@@ -678,36 +662,17 @@ export class AGUIAdapter extends BaseProtocolAdapter {
                 // Tool execution result with actual output
                 // AG-UI uses camelCase (toolCallId)
                 const toolCallId = event.toolCallId || event.tool_call_id;
-                let content = event.content;
-                // Parse JSON content if it's a string
-                if (typeof content === 'string') {
-                    try {
-                        content = JSON.parse(content);
-                    }
-                    catch {
-                        // Keep as string if not valid JSON
-                    }
-                }
                 if (toolCallId) {
-                    // Check for execution errors in the result
-                    // ExecutionResult format: { execution_ok, execution_error, code_error, ... }
-                    const contentObj = content;
-                    const isError = contentObj?.execution_ok === false ||
-                        contentObj?.code_error != null ||
-                        (contentObj?.error != null && !contentObj?.success);
-                    const errorMessage = contentObj?.execution_error ||
-                        contentObj?.error ||
-                        (contentObj?.code_error
-                            ? `${contentObj.code_error?.name || 'Error'}: ${contentObj.code_error?.value || ''}`
-                            : undefined);
-                    // Emit tool result event with the actual content
+                    // Read as every client reads it (portable/agui): JSON when it is,
+                    // failed when the execution result says so.
+                    const said = toolResultOf(event.content);
                     this.emit({
                         type: 'tool-result',
                         toolResult: {
                             toolCallId,
-                            success: !isError,
-                            result: content,
-                            error: isError ? errorMessage : undefined,
+                            success: said.success,
+                            result: said.result,
+                            error: said.error,
                         },
                         timestamp: new Date(),
                     });
@@ -741,14 +706,14 @@ export class AGUIAdapter extends BaseProtocolAdapter {
                 // `reactor.ui` ops come over the conversation's ui socket, never
                 // the run stream (REACTOR_UI RU-W): one here is refused. Any other
                 // activity is nobody's here.
-                if (event.activityType === AGUI_NAME) {
+                if (event.activityType === REACTOR_UI_NAME) {
                     this.refuseUiOnRun();
                 }
                 break;
             }
             case 'CUSTOM': {
                 const name = event.name;
-                if (name === AGUI_NAME) {
+                if (name === REACTOR_UI_NAME) {
                     this.refuseUiOnRun();
                     break;
                 }