@datalayer/agent-runtimes 1.5.21 → 1.5.23

package/lib/apps/apps/records.d.ts

@@ -1,13 +1,3 @@
-/**
- * The record of an application (LOOP R-07), as ai-agents keeps it: what it
- * did, session by session, written by the runtime it ran on — read here for
- * its activity feed (R-01b, R-15): the sessions, newest first, and what each
- * one did, step by step.
- *
- * Pure but for `fetch`: no React.
- *
- * @module apps/apps/records
- */
 /** What a record entry is. */
 export type RecordKind = 'session' | 'tool_call' | 'decision' | 'check' | 'approval' | 'output' | 'feedback'
 /** A turn of a conversation: what was asked, what it answered. */
@@ -38,29 +28,10 @@ export type RecordsContext = {
 export declare const RECORD_KIND_WORDS: Record<RecordKind, string>;
 /** An entry as ai-agents answers with it. */
 export declare function entryOf(raw: Record<string, unknown>): RecordEntry;
-/**
- * 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>;
 /** How the run an entry ends ended: `answered`, `stopped`, `gone`; `''` for any other entry. */
 export declare function runEndOf(entry: RecordEntry): string;
 /** An entry in words: its summary, or how its run ended when its words are not kept. */
 export declare function entrySaid(entry: RecordEntry): 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;
 /** A session in a sentence: how many calls, what stopped it, how it ended. */
 export declare function sessionSentence(entries: readonly RecordEntry[]): string;
 /**

package/lib/apps/apps/records.js

@@ -2,6 +2,17 @@
  * Copyright (c) 2025-2026 Datalayer, Inc.
  * Distributed under the terms of the Modified BSD License.
  */
+/**
+ * The record of an application (LOOP R-07), as ai-agents keeps it: what it
+ * did, session by session, written by the runtime it ran on — read here for
+ * its activity feed (R-01b, R-15): the sessions, newest first, and what each
+ * one did, step by step.
+ *
+ * Pure but for `fetch`: no React.
+ *
+ * @module apps/apps/records
+ */
+import { RUN_END_WORDS } from '../../portable/records';
 /** Each kind in a word, as the feed labels it. */
 export const RECORD_KIND_WORDS = {
     session: 'Session',
@@ -30,16 +41,6 @@ export function entryOf(raw) {
         createdAt: String(raw.created_at ?? ''),
     };
 }
-/**
- * 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',
-};
 /** How the run an entry ends ended: `answered`, `stopped`, `gone`; `''` for any other entry. */
 export function runEndOf(entry) {
     const status = entry.kind === 'output' ? entry.payload.status : undefined;
@@ -49,30 +50,6 @@ export function runEndOf(entry) {
 export function entrySaid(entry) {
     return entry.summary || RUN_END_WORDS[runEndOf(entry)] || '';
 }
-/**
- * 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();
-}
 /** A session in a sentence: how many calls, what stopped it, how it ended. */
 export function sessionSentence(entries) {
     const calls = entries.filter(entry => entry.kind === 'tool_call').length;

package/lib/apps/apps/threads.d.ts

@@ -9,17 +9,12 @@
  * stream's `MESSAGES_SNAPSHOT` says what it holds — and the chat draws it
  * and goes on with it on the same thread.
  *
- * Pure: the network is the `fetch` it is handed.
+ * Opening it is `openThread` (`portable/thread`), as every client opens one;
+ * here is what a deployment's chat decides of the thread it opens on.
  *
  * @module apps/apps/threads
  */
 import type { ResumedThread } from '../../types/chat';
-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;
-};
 /**
  * The deployment an application's agent is created for, as its create
  * payload names it (`app_instance.deployment_uid`, `appDatalayerCreatePayload`),
@@ -39,17 +34,3 @@ export declare function deploymentOfPayload(createPayload: Record<string, unknow
  * no deployment, keeps what it was given.
  */
 export declare function threadOfVisit(given: ResumedThread | undefined, deploymentUid: string, id: string): ResumedThread | undefined;
-/** 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/apps/apps/threads.js

@@ -2,12 +2,6 @@
  * Copyright (c) 2025-2026 Datalayer, Inc.
  * Distributed under the terms of the Modified BSD License.
  */
-import { messagesOfThread } from '../embed/embedSession';
-/** 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}`,
-};
 /**
  * The deployment an application's agent is created for, as its create
  * payload names it (`app_instance.deployment_uid`, `appDatalayerCreatePayload`),
@@ -39,72 +33,3 @@ export function threadOfVisit(given, deploymentUid, id) {
     }
     return { id, messages: [] };
 }
-/** The AG-UI messages a session-API stream's `MESSAGES_SNAPSHOT` carries, if one does. */
-export function snapshotOfStream(text) {
-    let found;
-    for (const block of text.split(/\r?\n\r?\n/)) {
-        const data = block
-            .split(/\r?\n/)
-            .filter(line => line.startsWith('data:'))
-            .map(line => line.slice('data:'.length).trim())
-            .join('');
-        if (!data) {
-            continue;
-        }
-        try {
-            const event = JSON.parse(data);
-            if (event.type === 'MESSAGES_SNAPSHOT' && Array.isArray(event.messages)) {
-                found = event.messages;
-            }
-        }
-        catch {
-            // Not an event: skipped.
-        }
-    }
-    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/apps/embed/embedSession.d.ts

@@ -48,14 +48,6 @@ export declare function sessionKeeper({ persist, storage, }: {
 }): SessionKeeper;
 /** Forget what this page holds in memory (a test). */
 export declare function forgetSessionsInMemory(): void;
-/**
- * A session's conversation as the chat draws it, from the AG-UI messages
- * the runtime says (`GET …/sessions/{uid}/messages`): what was said and
- * answered, in words. What its messages showed comes on the conversation's
- * ui socket once the chat opens it (REACTOR_UI RU-W), never here: a
- * `reactor.ui` activity in a thread is refused.
- */
-export declare function messagesOfThread(messages: unknown): ChatMessage[];
 /** What asking for a kept session found. */
 export type Reattached = {
     kind: 'resumed';

package/lib/apps/embed/embedSession.js

@@ -3,8 +3,7 @@
  * Distributed under the terms of the Modified BSD License.
  */
 import { windowTurnErrorOf } from '../../chat/base/loopWindow';
-import { AGUI_NAME } from '@datalayer/reactor/ui';
-import { askedOf } from '../apps/records';
+import { messagesOfThread } from '../../portable/thread';
 /** Where a visit's session is kept in the host's storage: `<prefix>:<app>:<visit>`. */
 export const EMBED_SESSION_KEY_PREFIX = 'datalayer-app:session';
 /**
@@ -92,42 +91,6 @@ export function sessionKeeper({ persist, storage = hostStorage, }) {
 export function forgetSessionsInMemory() {
     IN_MEMORY.clear();
 }
-/**
- * A session's conversation as the chat draws it, from the AG-UI messages
- * the runtime says (`GET …/sessions/{uid}/messages`): what was said and
- * answered, in words. What its messages showed comes on the conversation's
- * ui socket once the chat opens it (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 === AGUI_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()) {
-            // A turn a personal agent asked: what the runtime told the application
-            // before the person's words is never shown to them (decided 2026-10-14).
-            drawn.push({
-                id,
-                role,
-                content: role === 'user' ? askedOf(content) : content,
-                createdAt: new Date(),
-            });
-        }
-    }
-    return drawn;
-}
 /**
  * Ask the server that runs the application for a session's conversation,
  * with the visit's token. Anything but an answer — a session the runtime

package/lib/apps/embed/visitorApp.d.ts

@@ -13,7 +13,9 @@
  *   `GET /apps/deployments/at/<slug>` without a token says what its page is
  *   drawn from — the Appspec of the version it runs — and whether somebody
  *   signed out may talk to it (`session.opens`); the visitors' runtime
- *   answers `at:<slug>`, making the address's agent when first talked to;
+ *   answers `at:<slug>`, making the address's agent when first talked to —
+ *   or, for a version with code of its own (`runs_code`), the runtime its
+ *   deployment is kept on (`kept.url`), which runs that code;
  * - **a decision**, named by its id (`01M…`): framed from Datalayer's run
  *   page, as before.
  *
@@ -62,8 +64,12 @@ export type VisitorApp =
     kind: 'said';
     text: string;
 };
-/** Where a visitor's conversation with `app` runs: the visitors' runtime beside ai-agents, its token from ai-inference. */
-export declare function visitorsAt(api: string, app: string): DatalayerVisitors;
+/**
+ * Where a visitor's conversation with `app` runs: the visitors' runtime beside
+ * ai-agents — or `runtime`, the one a deployment with code of its own is
+ * kept on (R-30) — its token from ai-inference.
+ */
+export declare function visitorsAt(api: string, app: string, runtime?: string): DatalayerVisitors;
 /** What an embed without a token is told it takes. */
 export declare const TOKEN_HINT = "Embedded for a visitor it refuses, it takes its embed token (the \"token\" attribute).";
 /** The sentence for an example the visitors' runtime does not keep. */
@@ -85,3 +91,16 @@ export declare function readVisitorApp({ api, app, fetcher, catalogue, }: {
     fetcher?: typeof fetch;
     catalogue?: (ref: string) => AppSpec | undefined;
 }): Promise<VisitorApp>;
+/**
+ * Where somebody without an account talks to an address, as ai-agents says
+ * it (R-30, decided 14 October 2026): written as a spec, on the visitors'
+ * runtime (`url` unsaid); with code of its own (`runs_code`), on the runtime
+ * its deployment is kept on (`kept.url`), which runs that code — never the
+ * visitors', where its plain agent would answer in its code's place. An
+ * answer that does not say, or says code with no runtime, is not run.
+ */
+export declare function signedOutRuntime(body: Record<string, unknown>): {
+    url?: string;
+} | {
+    said: string;
+};

package/lib/apps/embed/visitorApp.js

@@ -20,10 +20,18 @@ export const DEFAULT_API = 'https://prod1.datalayer.run';
 export const isAppUid = (value) => /^[0-9A-HJKMNP-TV-Z]{26}$/.test(value);
 /** An address, as ai-agents spells one. */
 const SLUG = /^[a-z0-9][a-z0-9-]{0,62}$/;
-/** Where a visitor's conversation with `app` runs: the visitors' runtime beside ai-agents, its token from ai-inference. */
-export function visitorsAt(api, app) {
+/**
+ * Where a visitor's conversation with `app` runs: the visitors' runtime beside
+ * ai-agents — or `runtime`, the one a deployment with code of its own is
+ * kept on (R-30) — its token from ai-inference.
+ */
+export function visitorsAt(api, app, runtime) {
     const base = api.replace(/\/+$/, '');
-    return { url: `${base}${VISITORS_PATH}`, app, inferenceUrl: base };
+    return {
+        url: runtime ? runtime.replace(/\/+$/, '') : `${base}${VISITORS_PATH}`,
+        app,
+        inferenceUrl: base,
+    };
 }
 /** What an embed without a token is told it takes. */
 export const TOKEN_HINT = 'Embedded for a visitor it refuses, it takes its embed token (the "token" attribute).';
@@ -95,9 +103,39 @@ export async function readVisitorApp({ api = DEFAULT_API, app, fetcher = fetch,
     const name = typeof deployment.app_name === 'string' && deployment.app_name
         ? deployment.app_name
         : parsed.app.name;
+    const runtime = signedOutRuntime(body);
+    if ('said' in runtime) {
+        return { kind: 'said', text: refusedSentence(runtime.said) };
+    }
     return {
         kind: 'visitors',
         app: runnable({ app: { ...parsed.app, name }, problems: parsed.problems }),
-        visitors: visitorsAt(api, `${AT_PREFIX}${named}`),
+        visitors: visitorsAt(api, `${AT_PREFIX}${named}`, runtime.url),
     };
 }
+/**
+ * Where somebody without an account talks to an address, as ai-agents says
+ * it (R-30, decided 14 October 2026): written as a spec, on the visitors'
+ * runtime (`url` unsaid); with code of its own (`runs_code`), on the runtime
+ * its deployment is kept on (`kept.url`), which runs that code — never the
+ * visitors', where its plain agent would answer in its code's place. An
+ * answer that does not say, or says code with no runtime, is not run.
+ */
+export function signedOutRuntime(body) {
+    if (typeof body.runs_code !== 'boolean') {
+        return {
+            said: 'Datalayer did not say whether it runs code of its own, so it is not run.',
+        };
+    }
+    if (!body.runs_code) {
+        return {};
+    }
+    const kept = (body.kept ?? {});
+    const url = typeof kept.url === 'string' ? kept.url.trim() : '';
+    if (!url) {
+        return {
+            said: 'It runs its own code on a runtime kept for it, and none is running now.',
+        };
+    }
+    return { url };
+}

package/lib/apps/plugins/chat/ChatView.js

@@ -49,7 +49,8 @@ import { isInactiveSurfaceContribution, orderToolContributions, toolsForChatView
 import { agentBundleToolDefinitions, useAgentCommandTools, } from '../../../tools/adapters/commands';
 import { NONE_EDITOR, seedEditorChoice, setEditorOptions, } from '../shell/editorChoice';
 import { generateMessageId } from '../../../types/messages';
-import { deploymentOfPayload, openThread, THREAD_WORDS, threadOfVisit, } from '../../apps/threads';
+import { deploymentOfPayload, threadOfVisit } from '../../apps/threads';
+import { openThread, THREAD_WORDS } from '../../../portable/thread';
 import { FaceDrawing, PresenceFace, PresenceLine, } from '../../../chat/presence/Presence';
 import { presenceState, presenceToolOf, } from '../../../chat/presence/presenceStatus';
 import { latestSaying, newestIsAnswer, } from '../../../chat/assistant/state';

package/lib/chat/base/ChatBase.js

@@ -32,7 +32,7 @@ import { useCoreStore } from '@datalayer/core';
 import { DEFAULT_SERVICE_URLS } from '@datalayer/core/lib/api/constants';
 import { useChatStore } from '../../stores/chatStore';
 import { useConversationStore } from '../../stores/conversationStore';
-import { askedOf } from '../../apps/apps/records';
+import { askedOf } from '../../portable/records';
 import { extractChatMessagesFromFullContext } from './fullContextMessages';
 import { generateMessageId, createUserMessage, createAssistantMessage, } from '../../types/messages';
 import { AI_MODEL_CATALOGUE, DEFAULT_MODEL, isChatModel, } from '../../specs/models';

package/lib/chat/base/fullContextMessages.js

@@ -12,7 +12,7 @@
  * preamble the runtime told the application (`<asked-for>…</asked-for>`) is
  * kept in the record for the builder and never shown to the person.
  */
-import { askedOf } from '../../apps/apps/records';
+import { askedOf } from '../../portable/records';
 export function extractChatMessagesFromFullContext(fullContext) {
     if (!fullContext) {
         return [];

package/lib/hooks/useAgUi.js

@@ -3,7 +3,7 @@
  * Distributed under the terms of the Modified BSD License.
  */
 import { useCallback, useEffect, useState } from 'react';
-import { agUiRefusal, refusalBody } from '../protocols/agUiRefusal';
+import { agUiRefusal, refusalBody } from '../portable/agUiRefusal';
 /**
  * Hook to manage chat state with AG-UI protocol.
  *

package/lib/hooks/useToolApprovals.d.ts

@@ -1,5 +1,5 @@
 import type { ToolApprovalFilters } from '../types/tool-approvals';
-import { type ApprovalRecord } from '../utils/approvals';
+import { type ApprovalRecord } from '../portable/approvals';
 export type { ApprovalRecord };
 interface ApprovalsQueryData {
     approvals: ApprovalRecord[];

package/lib/hooks/useToolApprovals.js

@@ -21,7 +21,7 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { useQuery, useQueryClient } from '@tanstack/react-query';
 import { useAIAgentsWebSocket } from './useAIAgentsWebSocket';
-import { normalizeApproval } from '../utils/approvals';
+import { normalizeApproval } from '../portable/approvals';
 // ─── Helpers ─────────────────────────────────────────────────────────
 const APPROVALS_ROOT_KEY = ['tool-approvals'];
 function matchesFilter(a, filters) {

package/lib/{protocols → portable}/agUiRefusal.d.ts

@@ -16,7 +16,7 @@
  * Pure, so the hook, the adapter and the tests read a refusal the same way
  * (the repo's jest/vitest rule: rules live outside components).
  *
- * @module protocols/agUiRefusal
+ * @module portable/agUiRefusal
  */
 /** What the page says when an agent's AG-UI address answers nothing. */
 export declare const AG_UI_NOT_ON_RUNTIME: string;

package/lib/{protocols → portable}/agUiRefusal.js

@@ -20,7 +20,7 @@
  * Pure, so the hook, the adapter and the tests read a refusal the same way
  * (the repo's jest/vitest rule: rules live outside components).
  *
- * @module protocols/agUiRefusal
+ * @module portable/agUiRefusal
  */
 /** What the page says when an agent's AG-UI address answers nothing. */
 export const AG_UI_NOT_ON_RUNTIME = 'This agent is not on the runtime the page is addressing: its AG-UI address answered nothing. ' +

package/lib/portable/agui.d.ts

@@ -0,0 +1,72 @@
+/**
+ * An AG-UI run stream as any JavaScript runtime reads it: the
+ * `text/event-stream` frames a run answers, read into AG-UI events, and how a
+ * run is known to have ended. The web chat's `AGUIAdapter` and Datalayer
+ * Mobile read a stream with these, so that a stream is read one way.
+ *
+ * No React, DOM, Node or Reactor module: a phone passes a `fetch` whose
+ * response body streams (Expo's `expo/fetch`).
+ *
+ * @module portable/agui
+ */
+/** One AG-UI event, as a run stream carries it (`type` first, its fields beside it). */
+export type AgUiEvent = {
+    type: string;
+    [field: string]: unknown;
+};
+/** 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.";
+/**
+ * The name of `reactor.ui` (Reactor's `AGUI_NAME`): its ops come over the
+ * conversation's ui socket, never a run stream (REACTOR_UI RU-W). Held here
+ * so that a reader of a run needs no Reactor module; a test holds it to
+ * Reactor's.
+ */
+export declare const REACTOR_UI_NAME = "reactor.ui";
+/** What the page says when a `reactor.ui` op comes on a run stream. */
+export declare const UI_ON_RUN = "A reactor.ui op came on the run stream: it comes over the ui socket (REACTOR_UI RU-W).";
+/** What is said when the `fetch` given cannot read a response as it streams. */
+export declare const NOT_STREAMING = "This fetch does not stream a response: give one whose response body has getReader (expo/fetch on a phone).";
+/** Whether an event ends a run: the run said how it ended. */
+export declare const endsRun: (event: AgUiEvent) => boolean;
+/**
+ * The `text/event-stream` of a run, read as it arrives: text in, one AG-UI
+ * event out per frame. A frame is its `data:` lines up to a blank line; a
+ * frame whose data is not JSON is handed to `malformed`, never guessed at.
+ */
+export declare class AgUiFrames {
+    private readonly malformed;
+    private buffer;
+    private data;
+    constructor(malformed?: (data: string) => void);
+    /** The events the text completes. */
+    push(text: string): AgUiEvent[];
+    /** The events left when the stream closes: a last frame without its blank line. */
+    end(): AgUiEvent[];
+    private line;
+    private dispatch;
+}
+/** Every event a complete stream's text holds: a stream already read whole. */
+export declare function eventsOfStream(text: string): AgUiEvent[];
+/**
+ * Read a run's stream to its end, each event handed to `onEvent` as it
+ * arrives. Throws `RUN_CUT_SHORT` when the stream closes before the run said
+ * how it ended, and `NOT_STREAMING` for a response that cannot be read as it
+ * streams. An abort ends the reading with the caller's `AbortError`.
+ */
+export declare function readRunStream(response: {
+    body?: unknown;
+}, onEvent: (event: AgUiEvent) => void, malformed?: (data: string) => void): Promise<void>;
+/** A tool's result as a run says it (`TOOL_CALL_RESULT`): what it gave, and whether it failed. */
+export type ToolResultSaid = {
+    /** The result: its JSON read when it is JSON, else its text. */
+    result: unknown;
+    success: boolean;
+    error?: string;
+};
+/**
+ * A tool result's content, read as the chat reads it: JSON when it is JSON,
+ * and failed when the execution result says so (`execution_ok: false`, a
+ * `code_error`, or an `error` without `success`).
+ */
+export declare function toolResultOf(content: unknown): ToolResultSaid;