@nylorun/agents 0.9.0-beta → 0.11.0-beta

package/dist/session-client.js

@@ -0,0 +1,375 @@
+import { SANDBOX_TOOL_NAMES, delegateOf, isBuiltWorkflow, isSandboxToolName, } from "@nylorun/core/define";
+import { z } from "zod";
+import { SCOPES_HEADER, SUBJECT_HEADER } from "@nylorun/core/compatibility";
+import { parseSessionEvent, parseSubjectHeaders, } from "@nylorun/core/contracts";
+import { AccessClient, TokensClient } from "./access.js";
+import { Transport, id, segment } from "./http.js";
+import { observeSSE } from "./sse.js";
+function sessionSandboxOf(transport, sessionId) {
+    const call = (tool, args) => transport.json(`/v1/sessions/${segment(sessionId)}/sandbox/${segment(tool)}`, "POST", args);
+    const sandbox = {};
+    for (const tool of SANDBOX_TOOL_NAMES) {
+        if (!isSandboxToolName(tool))
+            continue;
+        sandbox[tool] = (args) => call(tool, args);
+    }
+    return sandbox;
+}
+function linkedSessionId(event) {
+    if (event.type !== "node.agent")
+        return undefined;
+    const payload = event.payload;
+    if (!payload || typeof payload !== "object" || Array.isArray(payload))
+        return undefined;
+    const sessionId = payload.sessionId;
+    return typeof sessionId === "string" && sessionId.length > 0
+        ? sessionId
+        : undefined;
+}
+const middlewareClosure = "Hosted definitions support declarative capabilities and before/after hooks, not middleware closures";
+/** The agent's declarations, then those of each agent it uses as a tool, keyed `<child>/<capability>`. */
+function declarationsOf(agent) {
+    if (isBuiltWorkflow(agent) || agent.manifest.kind === "workflow")
+        return [];
+    const built = agent.build?.() ?? agent;
+    if (isBuiltWorkflow(built))
+        return [];
+    const binding = built.getBinding?.();
+    if (!binding || !("declarations" in binding))
+        return [];
+    const found = (binding.declarations ?? []).map((item) => ({ key: item.id, item }));
+    for (const tool of binding.tools ?? []) {
+        const delegate = delegateOf(tool);
+        const child = delegate?.agent;
+        for (const item of child?.getBinding().declarations ?? [])
+            found.push({ key: `${child.id}/${item.id}`, item });
+        // A flow agent used as a tool: its agents' declarations, keyed `<flow>/<agent>/<capability>`.
+        const flow = delegate?.workflow;
+        for (const leaf of Object.values(flow?.getBinding().agents ?? {}))
+            for (const item of leaf.declarations ?? [])
+                found.push({ key: `${flow.id}/${leaf.manifest.id}/${item.id}`, item });
+    }
+    return found;
+}
+function pluginRootsOf(agent) {
+    const roots = {};
+    for (const { key, item } of declarationsOf(agent))
+        if (item.pluginRoot)
+            roots[key] = item.pluginRoot;
+    return Object.keys(roots).length === 0 ? undefined : roots;
+}
+/** Closures stay on the live binding. The published manifest cannot name them. */
+export function assertNoMiddlewareClosures(agent) {
+    if (declarationsOf(agent).some(({ item }) => item.hasMiddleware))
+        throw new Error(middlewareClosure);
+}
+export class AgentsClient {
+    transport;
+    /** The subject this client acts for (`as`), or `undefined` for the principal itself. */
+    subject;
+    constructor(destination = {}) {
+        this.transport = new Transport(destination);
+        this.subject = undefined;
+    }
+    /**
+     * A client that acts for `subject`: every call sends `Nylorun-Subject` and
+     * `Nylorun-Scopes`, and the Runtime limits it to the scopes and to the subject's own sessions
+     * and vaults (Host feature `subject-headers`). For app servers, which authenticate the person
+     * themselves and hold the key; nothing is minted, cached or refreshed.
+     */
+    as(subject, options = {}) {
+        if (this.subject !== undefined)
+            throw new Error(`This client already acts for ${this.subject}`);
+        const scopes = [...(options.scopes ?? ["sessions:own"])].join(" ");
+        const parsed = parseSubjectHeaders(subject, scopes);
+        if (!parsed.ok)
+            throw new TypeError(parsed.message);
+        const client = Object.create(AgentsClient.prototype);
+        return Object.assign(client, {
+            transport: this.transport.withHeaders({
+                [SUBJECT_HEADER]: subject,
+                [SCOPES_HEADER]: [...parsed.scopes].join(" "),
+            }),
+            subject,
+        });
+    }
+    /**
+     * Mints subject tokens for signed-in people (Host feature `subject-tokens`), so their
+     * browser or app calls the Runtime directly. Application key only.
+     */
+    get tokens() {
+        return new TokensClient(this.transport);
+    }
+    /** The access policy, signing keys and revocations (Host feature `subject-tokens`). */
+    get access() {
+        return new AccessClient(this.transport);
+    }
+    /** The Runtime's protocol features, including optional ones such as `transcript-events`. */
+    hostFeatures(options = {}) {
+        return this.transport.hostFeatures(options.signal);
+    }
+    listAgents(options = {}) {
+        return this.transport.json("/v1/agents", "GET", undefined, options.signal);
+    }
+    listSessions(options = {}) {
+        const query = options.agentId
+            ? `?agentId=${encodeURIComponent(options.agentId)}`
+            : "";
+        return this.transport.json(`/v1/sessions${query}`, "GET", undefined, options.signal);
+    }
+    async saveAgent(agent, options) {
+        if (isBuiltWorkflow(agent) && agent.manifest.workflowSchemaVersion === 2) {
+            // A v2 workflow embeds its agents: one document, carrying their plugin roots.
+            const pluginRoots = {};
+            for (const binding of Object.values(agent.getBinding().agents)) {
+                const leaf = { id: binding.manifest.id, manifest: binding.manifest, getBinding: () => binding };
+                assertNoMiddlewareClosures(leaf);
+                for (const [key, root] of Object.entries(pluginRootsOf(leaf) ?? {}))
+                    pluginRoots[`${leaf.id}/${key}`] = root;
+            }
+            return this.transport.json(`/v1/agents/${segment(agent.id)}`, "PUT", {
+                requestId: options.requestId ?? id(),
+                manifest: agent.manifest,
+                implementationVersion: options.implementationVersion,
+                ...(Object.keys(pluginRoots).length === 0 ? {} : { pluginRoots }),
+            });
+        }
+        if (isBuiltWorkflow(agent)) {
+            for (const binding of Object.values(agent.getBinding().agents)) {
+                await this.saveAgent({
+                    id: binding.manifest.id,
+                    manifest: binding.manifest,
+                    getBinding: () => binding,
+                }, options);
+            }
+            return this.transport.json(`/v1/agents/${segment(agent.id)}`, "PUT", {
+                requestId: options.requestId ?? id(),
+                manifest: agent.manifest,
+                implementationVersion: options.implementationVersion,
+            });
+        }
+        assertNoMiddlewareClosures(agent);
+        const pluginRoots = pluginRootsOf(agent);
+        return this.transport.json(`/v1/agents/${segment(agent.id)}`, "PUT", {
+            requestId: options.requestId ?? id(),
+            manifest: agent.manifest,
+            implementationVersion: options.implementationVersion,
+            ...(pluginRoots === undefined ? {} : { pluginRoots }),
+        });
+    }
+    async createSession(options) {
+        const sessionId = options.id ?? id();
+        await this.transport.json(`/v1/sessions/${segment(sessionId)}`, "PUT", {
+            requestId: options.requestId ?? id(),
+            agentId: options.agentId,
+            ownerUserId: options.ownerUserId,
+            ...(options.info ? { info: options.info } : {}),
+            ...(options.vaultIds ? { vaultIds: options.vaultIds } : {}),
+            ...(options.credentialSelections
+                ? { credentialSelections: options.credentialSelections }
+                : {}),
+            ...(options.sandbox === undefined ? {} : { sandbox: options.sandbox }),
+        });
+        return this.session(sessionId);
+    }
+    createVault(options) {
+        return this.transport.json("/v1/vaults", "POST", {
+            requestId: options.requestId ?? id(),
+            idempotencyKey: options.idempotencyKey,
+            name: options.name,
+            ownerUserId: options.ownerUserId,
+            ...(options.metadata ? { metadata: options.metadata } : {}),
+        });
+    }
+    listVaults(ownerUserId, signal) {
+        return this.transport.json(`/v1/vaults?ownerUserId=${encodeURIComponent(ownerUserId)}`, "GET", undefined, signal);
+    }
+    getVault(vaultId, signal) {
+        return this.transport.json(`/v1/vaults/${segment(vaultId)}`, "GET", undefined, signal);
+    }
+    deleteVault(vaultId) {
+        return this.transport.json(`/v1/vaults/${segment(vaultId)}`, "DELETE");
+    }
+    createCredential(vaultId, options) {
+        return this.transport.json(`/v1/vaults/${segment(vaultId)}/credentials`, "POST", {
+            requestId: options.requestId ?? id(),
+            idempotencyKey: options.idempotencyKey,
+            name: options.name,
+            auth: options.auth,
+        });
+    }
+    listCredentials(vaultId, signal) {
+        return this.transport.json(`/v1/vaults/${segment(vaultId)}/credentials`, "GET", undefined, signal);
+    }
+    getCredential(vaultId, credentialId, signal) {
+        return this.transport.json(`/v1/vaults/${segment(vaultId)}/credentials/${segment(credentialId)}`, "GET", undefined, signal);
+    }
+    rotateCredential(vaultId, credentialId, options) {
+        return this.transport.json(`/v1/vaults/${segment(vaultId)}/credentials/${segment(credentialId)}`, "POST", {
+            requestId: options.requestId ?? id(),
+            idempotencyKey: options.idempotencyKey,
+            auth: options.auth,
+        });
+    }
+    deleteCredential(vaultId, credentialId) {
+        return this.transport.json(`/v1/vaults/${segment(vaultId)}/credentials/${segment(credentialId)}`, "DELETE");
+    }
+    session(sessionId) {
+        return new SessionClient(this.transport, sessionId);
+    }
+}
+export class SessionClient {
+    transport;
+    id;
+    sandbox;
+    constructor(transport, id) {
+        this.transport = transport;
+        this.id = id;
+        this.sandbox = sessionSandboxOf(transport, id);
+    }
+    get path() {
+        return `/v1/sessions/${segment(this.id)}`;
+    }
+    inspect(signal) {
+        return this.transport.json(this.path, "GET", undefined, signal);
+    }
+    /** Pending waits / interactions from the session inspect view. */
+    async pending(signal) {
+        const view = await this.inspect(signal);
+        return view.waits ?? [];
+    }
+    command(command, signal) {
+        return this.transport.json(`${this.path}/commands`, "POST", command, signal);
+    }
+    /**
+     * Start a turn. Strings become `message.content`; any other JSON value becomes
+     * `message.data` (workflows.md §5).
+     */
+    input(value, options) {
+        const base = {
+            type: "message",
+            requestId: options.requestId ?? id(),
+            idempotencyKey: options.idempotencyKey,
+        };
+        return this.command(typeof value === "string"
+            ? { ...base, content: value }
+            : { ...base, data: value }, options.signal);
+    }
+    approve(interactionId, approved, options) {
+        return this.command({
+            type: "approve",
+            interactionId,
+            approved,
+            requestId: options.requestId ?? id(),
+            idempotencyKey: options.idempotencyKey,
+        }, options.signal);
+    }
+    respond(interactionId, value, options) {
+        return this.command({
+            type: "respond",
+            interactionId,
+            value,
+            requestId: options.requestId ?? id(),
+            idempotencyKey: options.idempotencyKey,
+        }, options.signal);
+    }
+    cancel(options) {
+        return this.command({
+            type: "cancel",
+            requestId: options.requestId ?? id(),
+            idempotencyKey: options.idempotencyKey,
+            ...(options.reason ? { reason: options.reason } : {}),
+        }, options.signal);
+    }
+    /** `agent` narrows to one agent used as a tool: its delegationId or its path. */
+    async history(options = {}) {
+        const query = new URLSearchParams();
+        if (options.cursor)
+            query.set("cursor", options.cursor);
+        if (options.agent)
+            query.set("agent", options.agent);
+        const search = query.toString();
+        const page = z
+            .object({ items: z.array(z.unknown()), cursor: z.string().nullable() })
+            .parse(await this.transport.json(`${this.path}/items${search ? `?${search}` : ""}`, "GET", undefined, options.signal));
+        // Typed when the catalog knows the type; a newer Runtime's type stays a bare envelope.
+        return { items: page.items.map(parseSessionEvent), cursor: page.cursor };
+    }
+    async *observe(options = {}) {
+        if (!options.follow) {
+            yield* this.observeOne(this.id, options);
+            return;
+        }
+        yield* this.observeFollowing(options);
+    }
+    async *observeOne(sessionId, options) {
+        for await (const frame of observeSSE(this.transport, `/v1/sessions/${segment(sessionId)}/events`, options)) {
+            if (frame.event === "heartbeat" || frame.event === "ready")
+                continue;
+            yield parseSessionEvent(JSON.parse(frame.data));
+        }
+    }
+    /**
+     * Own session stream plus linked agent sessions announced in `node.agent`
+     * events, merged by `time` then arrival order (workflows.md §11).
+     */
+    async *observeFollowing(options) {
+        const signal = options.signal;
+        const linked = new Set();
+        const queue = [];
+        let wait;
+        let open = 1;
+        let failed;
+        const wake = () => {
+            wait?.();
+            wait = undefined;
+        };
+        const push = (event) => {
+            queue.push(event);
+            queue.sort((a, b) => {
+                const byTime = a.time.localeCompare(b.time);
+                return byTime !== 0 ? byTime : a.cursor.localeCompare(b.cursor);
+            });
+            wake();
+        };
+        const pump = async (sessionId, cursor) => {
+            try {
+                for await (const event of this.observeOne(sessionId, { cursor, signal })) {
+                    push(event);
+                    const link = linkedSessionId(event);
+                    if (link && link !== this.id && !linked.has(link)) {
+                        linked.add(link);
+                        open += 1;
+                        void pump(link).finally(() => {
+                            open -= 1;
+                            wake();
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                if (!signal?.aborted)
+                    failed = error;
+            }
+        };
+        void pump(this.id, options.cursor).finally(() => {
+            open -= 1;
+            wake();
+        });
+        while (!signal?.aborted) {
+            if (failed)
+                throw failed;
+            if (queue.length) {
+                yield queue.shift();
+                continue;
+            }
+            if (open <= 0)
+                return;
+            await new Promise((resolve) => {
+                wait = resolve;
+            });
+        }
+    }
+}
+export { RuntimeError, IncompatibleRuntimeError } from "./http.js";
+export { AccessClient, PublishableKeysClient, SigningKeysClient, TokensClient, } from "./access.js";

package/dist/sse.js

@@ -65,7 +65,11 @@ export async function* observeSSE(transport, path, options = {}) {
     const signal = options.signal ?? controller.signal;
     let cursor = options.cursor;
     let retry = 250;
+    // The Runtime ended the stream because its subject token expired or was revoked: reconnect
+    // at once (the transport fetches a new token), but only once in a row.
+    let closedByRuntime = 0;
     while (!signal.aborted) {
+        let reconnectNow = false;
         try {
             const response = await transport.request(path, {
                 signal,
@@ -75,7 +79,13 @@ export async function* observeSSE(transport, path, options = {}) {
                 },
             });
             for await (const event of readSSE(response, signal)) {
+                if (event.event === "nylorun.closed") {
+                    closedByRuntime += 1;
+                    reconnectNow = closedByRuntime === 1;
+                    break;
+                }
                 retry = 250;
+                closedByRuntime = 0;
                 if (event.id)
                     cursor = event.id;
                 yield event;
@@ -90,6 +100,8 @@ export async function* observeSSE(transport, path, options = {}) {
                 ![408, 429].includes(error.status))
                 throw error;
         }
+        if (reconnectNow)
+            continue;
         if (!signal.aborted)
             await delay(retry, signal).catch(() => { });
         retry = Math.min(30000, retry * 2);

package/dist/studio-embed.d.ts

@@ -0,0 +1,9 @@
+/**
+ * `@nylorun/agents/studio-embed`: the contract between Studio and an app that embeds it in an
+ * iframe (Studio design §8). Studio's web app and embedders such as Babai import it from here,
+ * because Studio may not depend on `@nylorun/core` directly.
+ *
+ * No Node-only module is imported here or below.
+ */
+export { STUDIO_EMBED_MESSAGE_TYPE, STUDIO_EMBED_PROTOCOLS, StudioEmbedMessageSchema, StudioLoginTokenRequestSchema, StudioLoginTokenResponseSchema, StudioSessionRequestSchema, StudioSessionResponseSchema, StudioThemeSchema, isFrameAncestor, parseFrameAncestors, } from "@nylorun/core/contracts";
+export type { StudioEmbedKind, StudioEmbedMessage, StudioLoginTokenRequest, StudioLoginTokenResponse, StudioSessionRequest, StudioSessionResponse, StudioTheme, } from "@nylorun/core/contracts";

package/dist/studio-embed.js

@@ -0,0 +1,8 @@
+/**
+ * `@nylorun/agents/studio-embed`: the contract between Studio and an app that embeds it in an
+ * iframe (Studio design §8). Studio's web app and embedders such as Babai import it from here,
+ * because Studio may not depend on `@nylorun/core` directly.
+ *
+ * No Node-only module is imported here or below.
+ */
+export { STUDIO_EMBED_MESSAGE_TYPE, STUDIO_EMBED_PROTOCOLS, StudioEmbedMessageSchema, StudioLoginTokenRequestSchema, StudioLoginTokenResponseSchema, StudioSessionRequestSchema, StudioSessionResponseSchema, StudioThemeSchema, isFrameAncestor, parseFrameAncestors, } from "@nylorun/core/contracts";

package/dist/token-endpoint.d.ts

@@ -0,0 +1,23 @@
+/**
+ * A route for app servers that mints a subject token for the signed-in person (Host feature
+ * `subject-tokens`). The browser client calls it whenever it needs a token. Mount it on your
+ * app's own origin behind your sign-in: `POST` only, no CORS, never cached.
+ *
+ *   export const POST = createTokenEndpoint({
+ *     client, role: "user", subject: (request) => userFromCookie(request)?.id,
+ *   });
+ */
+import type { TokenScope } from "@nylorun/core/contracts";
+import type { AgentsClient } from "./session-client.js";
+export interface TokenEndpointOptions {
+    /** The application client (the Tenant key stays on the server). */
+    client: AgentsClient | Promise<AgentsClient>;
+    /** The signed-in person the token is for; `undefined` answers 401. */
+    subject(request: Request): string | undefined | Promise<string | undefined>;
+    /** The access policy role to mint for, or a function of the request and subject. */
+    role: string | ((request: Request, subject: string) => string | Promise<string>);
+    scopes?: readonly TokenScope[];
+    agents?: readonly string[];
+    ttlSeconds?: number;
+}
+export declare function createTokenEndpoint(options: TokenEndpointOptions): (request: Request) => Promise<Response>;

package/dist/token-endpoint.js

@@ -0,0 +1,30 @@
+import { RuntimeError } from "./http.js";
+const NO_STORE = { "cache-control": "no-store" };
+export function createTokenEndpoint(options) {
+    return async (request) => {
+        if (request.method !== "POST")
+            return new Response(null, { status: 405, headers: { allow: "POST", ...NO_STORE } });
+        const subject = await options.subject(request);
+        if (!subject)
+            return Response.json({ error: "Sign in required" }, { status: 401, headers: NO_STORE });
+        const role = typeof options.role === "string"
+            ? options.role
+            : await options.role(request, subject);
+        try {
+            const client = await options.client;
+            const minted = await client.tokens.create({
+                subject,
+                role,
+                ...(options.scopes ? { scopes: options.scopes } : {}),
+                ...(options.agents ? { agents: options.agents } : {}),
+                ...(options.ttlSeconds === undefined ? {} : { ttlSeconds: options.ttlSeconds }),
+            });
+            return Response.json({ token: minted.token, expiresAt: minted.expiresAt }, { headers: NO_STORE });
+        }
+        catch (error) {
+            // The person sees that a token could not be issued, never the Runtime's details.
+            const status = error instanceof RuntimeError && error.status === 400 ? 403 : 502;
+            return Response.json({ error: "Could not issue a token" }, { status, headers: NO_STORE });
+        }
+    };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nylorun/agents",
-  "version": "0.9.0-beta",
-  "description": "Nylorun agent definitions, session client and connected executor",
+  "version": "0.11.0-beta",
+  "description": "Nylorun agent definitions, session client and Action endpoint",
   "type": "module",
   "license": "Apache-2.0",
   "files": [
@@ -24,13 +24,21 @@
       "types": "./dist/client.d.ts",
       "import": "./dist/client.js"
     },
-    "./executor": {
-      "types": "./dist/executor.d.ts",
-      "import": "./dist/executor.js"
-    },
     "./ag-ui": {
       "types": "./dist/ag-ui/index.d.ts",
       "import": "./dist/ag-ui/index.js"
+    },
+    "./browser": {
+      "types": "./dist/browser.d.ts",
+      "import": "./dist/browser.js"
+    },
+    "./a2a": {
+      "types": "./dist/a2a/index.d.ts",
+      "import": "./dist/a2a/index.js"
+    },
+    "./studio-embed": {
+      "types": "./dist/studio-embed.d.ts",
+      "import": "./dist/studio-embed.js"
     }
   },
   "scripts": {
@@ -39,8 +47,7 @@
     "test": "vitest run --passWithNoTests"
   },
   "dependencies": {
-    "@ag-ui/core": "~1.0.0",
-    "@nylorun/core": "0.8.0-beta",
+    "@nylorun/core": "0.10.0-beta",
     "gray-matter": "^4.0.3"
   },
   "peerDependencies": {

package/dist/ag-ui/history.d.ts

@@ -1,7 +0,0 @@
-/**
- * An AG-UI transcript rebuilt from a session's log, with the ids a live run gave each
- * message (see `translate.ts`), usable as `HttpAgent`'s `initialMessages`.
- */
-import type { Message } from "@ag-ui/core";
-import { type LiveEvent } from "@nylorun/core/contracts";
-export declare function messagesFromEvents(items: readonly LiveEvent[]): Message[];

package/dist/ag-ui/history.js

@@ -1,60 +0,0 @@
-import { parseTranscriptEvent } from "@nylorun/core/contracts";
-import { outputText, toolResultOf } from "./translate.js";
-export function messagesFromEvents(items) {
-    const messages = [];
-    const results = new Set();
-    let sawAssistant = false;
-    for (const raw of items) {
-        if (raw.type === "command.message") {
-            const p = (raw.payload ?? {});
-            messages.push({
-                // The handler sends the client's message id as the idempotency key.
-                id: p.idempotencyKey ?? raw.eventId,
-                role: "user",
-                content: typeof p.content === "string" ? p.content : JSON.stringify(p.data),
-            });
-            sawAssistant = false;
-            continue;
-        }
-        const event = parseTranscriptEvent(raw);
-        if (!event)
-            continue;
-        const result = toolResultOf(event);
-        if (result) {
-            if (results.has(result.callId))
-                continue;
-            results.add(result.callId);
-            messages.push({
-                id: `${result.callId}:result`,
-                role: "tool",
-                toolCallId: result.callId,
-                content: result.content,
-            });
-            continue;
-        }
-        if (event.type === "message.assistant" && !event.payload.agent) {
-            const p = event.payload;
-            sawAssistant = true;
-            const message = { id: p.invocationId, role: "assistant" };
-            if (p.text)
-                message.content = p.text;
-            if (p.toolCalls.length)
-                message.toolCalls = p.toolCalls.map((call) => ({
-                    id: call.callId,
-                    type: "function",
-                    function: { name: call.name, arguments: JSON.stringify(call.input ?? {}) },
-                }));
-            messages.push(message);
-        }
-        else if (event.type === "turn.completed" && !sawAssistant) {
-            const output = event.payload.output;
-            if (output !== undefined && output !== null && outputText(output))
-                messages.push({
-                    id: raw.eventId,
-                    role: "assistant",
-                    content: outputText(output),
-                });
-        }
-    }
-    return messages;
-}

package/dist/ag-ui/sse.d.ts

@@ -1,9 +0,0 @@
-/**
- * AG-UI over server-sent events: one `data:` line of JSON per event. The last AG-UI event
- * made from a Runtime event carries that event's cursor as `id:`, so a client that resumes
- * from `Last-Event-ID` never lands inside a group.
- */
-import type { BaseEvent } from "@ag-ui/core";
-export declare const SSE_CONTENT_TYPE = "text/event-stream";
-export declare function sseFrame(event: BaseEvent, id?: string): string;
-export declare const SSE_HEARTBEAT = ": keep-alive\n\n";

package/dist/ag-ui/sse.js

@@ -1,7 +0,0 @@
-export const SSE_CONTENT_TYPE = "text/event-stream";
-export function sseFrame(event, id) {
-    // Cursors are opaque base64; a line break would end the field early.
-    const idLine = id && !/[\r\n]/.test(id) ? `id: ${id}\n` : "";
-    return `${idLine}data: ${JSON.stringify(event)}\n\n`;
-}
-export const SSE_HEARTBEAT = ": keep-alive\n\n";

package/dist/ag-ui/translate.d.ts

@@ -1,38 +0,0 @@
-/**
- * Runtime transcript events → AG-UI 1.0 events for one run. Ids: an assistant message is its
- * model call's `invocationId`, a tool call is the model's `callId`, a tool result is
- * `<callId>:result`, so live runs and `messagesFromEvents` agree.
- */
-import { type BaseEvent } from "@ag-ui/core";
-import { type LiveEvent, type TranscriptEvent } from "@nylorun/core/contracts";
-/** The text a tool result shows; `undefined` while there is no result yet. */
-export declare function toolResultText(result: unknown): string | undefined;
-export declare function outputText(output: unknown): string;
-/** One Runtime event's result for a run: AG-UI events, and whether the run ended. */
-export interface Step {
-    readonly events: BaseEvent[];
-    readonly finished: boolean;
-}
-/** A tool result from any of the three places a call can end. */
-export declare function toolResultOf(event: TranscriptEvent): {
-    callId: string;
-    content: string;
-} | undefined;
-export declare class RunTranslator {
-    private readonly threadId;
-    private readonly runId;
-    /** Tool invocation → the model's call id, for interrupts that name the invocation. */
-    private readonly callIds;
-    private readonly closed;
-    private sawAssistant;
-    /**
-     * `reattached`: the run continues from a cursor, so earlier assistant messages already
-     * reached the client and a workflow's output is not repeated as text.
-     */
-    constructor(threadId: string, runId: string, options?: {
-        reattached?: boolean;
-    });
-    translate(raw: LiveEvent): Step;
-    started(): BaseEvent;
-    private finished;
-}