@nylorun/agents 0.8.0-beta → 0.10.0-beta

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.8.0-beta",
-  "description": "Nylorun agent definitions, session client and connected executor",
+  "version": "0.10.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.7.0-beta",
+    "@nylorun/core": "0.9.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;
-}

package/dist/ag-ui/translate.js

@@ -1,222 +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 { EventType } from "@ag-ui/core";
-import { parseTranscriptEvent, } from "@nylorun/core/contracts";
-/** The text a tool result shows; `undefined` while there is no result yet. */
-export function toolResultText(result) {
-    const value = result;
-    switch (value?.kind) {
-        case "completed":
-            return outputText(value.output ?? null);
-        case "failed":
-            return JSON.stringify({ error: value.code, message: value.message });
-        case "denied":
-            return JSON.stringify({ denied: true, reason: value.reason });
-        default:
-            // interaction-required and deferred: the call is still open.
-            return undefined;
-    }
-}
-export function outputText(output) {
-    return typeof output === "string" ? output : JSON.stringify(output);
-}
-const none = { events: [], finished: false };
-/** A tool result from any of the three places a call can end. */
-export function toolResultOf(event) {
-    switch (event.type) {
-        case "action.completed": {
-            const p = event.payload;
-            if (p.kind !== "tool" || !p.callId || p.agent)
-                return undefined;
-            const content = toolResultText(p.result);
-            return content === undefined ? undefined : { callId: p.callId, content };
-        }
-        case "tool.completed": {
-            const p = event.payload;
-            if (p.agent)
-                return undefined;
-            return {
-                callId: p.callId,
-                content: p.error !== undefined
-                    ? JSON.stringify({ error: p.error.code, message: p.error.message })
-                    : outputText(p.output ?? null),
-            };
-        }
-        case "delegation.completed": {
-            // An agent used as a tool: its own work stays inside it; the parent sees the result.
-            const p = event.payload;
-            if (!p.callId)
-                return undefined;
-            const content = toolResultText(p.outcome);
-            return content === undefined ? undefined : { callId: p.callId, content };
-        }
-        default:
-            return undefined;
-    }
-}
-export class RunTranslator {
-    threadId;
-    runId;
-    /** Tool invocation → the model's call id, for interrupts that name the invocation. */
-    callIds = new Map();
-    closed = new Set();
-    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, runId, options = {}) {
-        this.threadId = threadId;
-        this.runId = runId;
-        this.sawAssistant = options.reattached ?? false;
-    }
-    translate(raw) {
-        const event = parseTranscriptEvent(raw);
-        if (!event)
-            return none;
-        if (event.type === "action.pending" || event.type === "action.completed") {
-            const { callId, invocationId } = event.payload;
-            if (callId && invocationId)
-                this.callIds.set(invocationId, callId);
-        }
-        const result = toolResultOf(event);
-        if (result) {
-            if (this.closed.has(result.callId))
-                return none;
-            this.closed.add(result.callId);
-            return {
-                events: [
-                    {
-                        type: EventType.TOOL_CALL_RESULT,
-                        messageId: `${result.callId}:result`,
-                        toolCallId: result.callId,
-                        content: result.content,
-                        role: "tool",
-                    },
-                ],
-                finished: false,
-            };
-        }
-        switch (event.type) {
-            case "message.assistant": {
-                const p = event.payload;
-                if (p.agent)
-                    return none;
-                this.sawAssistant = true;
-                return { events: assistantEvents(p), finished: false };
-            }
-            case "turn.completed": {
-                const p = event.payload;
-                // Workflows finish without a model step of their own: show their output.
-                const text = this.sawAssistant || p.output === undefined || p.output === null
-                    ? []
-                    : textEvents(raw.eventId, outputText(p.output));
-                return {
-                    events: [...text, this.finished({ type: "success" }, p.output)],
-                    finished: true,
-                };
-            }
-            case "turn.paused": {
-                const interrupts = event.payload.interactions.map((w) => {
-                    const interaction = w.interaction;
-                    const toolCallId = this.callIds.get(w.invocationId);
-                    return {
-                        id: interaction.id,
-                        reason: interaction.kind === "approval" ? "tool_approval" : "input_required",
-                        ...(typeof interaction.prompt === "string"
-                            ? { message: interaction.prompt }
-                            : {}),
-                        ...(toolCallId ? { toolCallId } : {}),
-                        ...(interaction.kind === "approval"
-                            ? {
-                                responseSchema: {
-                                    type: "object",
-                                    properties: { approved: { type: "boolean" } },
-                                    required: ["approved"],
-                                },
-                            }
-                            : {}),
-                        metadata: { nylorun: { kind: interaction.kind } },
-                    };
-                });
-                return {
-                    events: [this.finished({ type: "interrupt", interrupts })],
-                    finished: true,
-                };
-            }
-            case "turn.cancelled":
-                return { events: [this.finished({ type: "cancelled" })], finished: true };
-            case "turn.failed": {
-                const p = event.payload;
-                return {
-                    events: [
-                        {
-                            type: EventType.RUN_ERROR,
-                            message: p.error?.message ?? p.message ?? "The agent failed",
-                            code: p.error?.code ?? "turn.failed",
-                        },
-                    ],
-                    finished: true,
-                };
-            }
-            case "effect.uncertain":
-            case "action.uncertain":
-                // The Runtime cannot tell whether a side effect happened; the run goes on.
-                return {
-                    events: [
-                        {
-                            type: EventType.CUSTOM,
-                            name: "nylorun.uncertain",
-                            value: event.payload,
-                        },
-                    ],
-                    finished: false,
-                };
-            default:
-                return none;
-        }
-    }
-    started() {
-        return {
-            type: EventType.RUN_STARTED,
-            threadId: this.threadId,
-            runId: this.runId,
-        };
-    }
-    finished(outcome, result) {
-        return {
-            type: EventType.RUN_FINISHED,
-            threadId: this.threadId,
-            runId: this.runId,
-            outcome,
-            ...(result === undefined ? {} : { result }),
-        };
-    }
-}
-function textEvents(messageId, text) {
-    if (!text)
-        return [];
-    return [
-        { type: EventType.TEXT_MESSAGE_START, messageId, role: "assistant" },
-        { type: EventType.TEXT_MESSAGE_CONTENT, messageId, delta: text },
-        { type: EventType.TEXT_MESSAGE_END, messageId },
-    ];
-}
-function assistantEvents(p) {
-    const events = textEvents(p.invocationId, p.text);
-    for (const call of p.toolCalls)
-        events.push({
-            type: EventType.TOOL_CALL_START,
-            toolCallId: call.callId,
-            toolCallName: call.name,
-            parentMessageId: p.invocationId,
-        }, {
-            type: EventType.TOOL_CALL_ARGS,
-            toolCallId: call.callId,
-            delta: JSON.stringify(call.input ?? {}),
-        }, { type: EventType.TOOL_CALL_END, toolCallId: call.callId });
-    return events;
-}

package/dist/derived-credentials.d.ts

@@ -1,5 +0,0 @@
-/**
- * Deterministic executor token from an application key (D§7.3).
- * Same key, Tenant and agent always produce the same token.
- */
-export declare function deriveExecutorToken(applicationKey: string, tenantId: string, agentId: string): string;

package/dist/derived-credentials.js

@@ -1,17 +0,0 @@
-import { createHmac } from "node:crypto";
-/**
- * Deterministic executor token from an application key (D§7.3).
- * Same key, Tenant and agent always produce the same token.
- */
-export function deriveExecutorToken(applicationKey, tenantId, agentId) {
-    const message = Buffer.concat([
-        Buffer.from("nylorun/executor/v1", "utf8"),
-        Buffer.from([0]),
-        Buffer.from(tenantId, "utf8"),
-        Buffer.from([0]),
-        Buffer.from(agentId, "utf8"),
-    ]);
-    return createHmac("sha256", Buffer.from(applicationKey, "utf8"))
-        .update(message)
-        .digest("hex");
-}

package/dist/executor.d.ts

@@ -1,20 +0,0 @@
-import { type BuiltWorkflow } from "@nylorun/core/define";
-import { AgentsClient, type AgentSource } from "./client.js";
-import { deriveExecutorToken } from "./derived-credentials.js";
-import { type Destination } from "./http.js";
-export interface ConnectOptions {
-    agents: readonly (AgentSource | BuiltWorkflow)[];
-    /** Application-mode client; when set, connectAgents uses application mode (D§7.2). */
-    application?: AgentsClient;
-    runtime?: Destination;
-    implementationVersion?: string;
-    onError?: (error: unknown) => void;
-}
-export interface AgentConnection {
-    /** Settles after authenticated SSE is established and initial discovery succeeds. */
-    readonly ready: Promise<void>;
-    /** Abort subscriptions and leases. Running user code receives an AbortSignal. */
-    close(): Promise<void>;
-}
-export declare function connectAgents(options: ConnectOptions): AgentConnection;
-export { deriveExecutorToken };