@nylorun/runtime 0.16.0-beta → 0.19.0-beta

package/dist/adapters/execution/restate.js

@@ -17,11 +17,6 @@
  * - `<prefix>NylorunTimer`, key `<tenantId>:<timer key>`. `set` records the
  *   latest time and sends a delayed `fire`; a `fire` for an older time is a
  *   no-op, which is how setting a key again replaces it.
- * - `<prefix>NylorunAction`, key `<tenantId>:<actionId>`. Its exclusive
- *   `deliver` handler calls `WorkerHandlers.deliver`. Like `advance`, it keeps
- *   no state and makes no `ctx.run`: its only journal entry is the delayed
- *   self-send after a `retry` result, so an endpoint that is down never spends
- *   the retry budget, which is for infrastructure errors.
  * - `<prefix>NylorunSandbox`, key `<tenantId>:<sandboxId>` (F7.2). Its
  *   exclusive handlers serialize a pod sandbox's reconciles and timers:
  *   `reconcile` calls `WorkerHandlers.sandbox`; `arm` records a timer's latest
@@ -29,7 +24,7 @@
  *   `fire`; a `fire` for an older time is a no-op, as the timer object's.
  *   What a run answers arms its timers and its retry.
  *
- * Wakes, deliveries, timers and sweep arming go through the ingress as one-way
+ * Wakes, sandbox reconciles, timers and sweep arming go through the ingress as one-way
  * sends, so an API node can call them without ever calling `start`.
  */
 import { createServer } from "node:http2";
@@ -60,7 +55,6 @@ export class RestateExecution {
             session: `${prefix}NylorunSession`,
             tenant: `${prefix}NylorunTenant`,
             timer: `${prefix}NylorunTimer`,
-            action: `${prefix}NylorunAction`,
             sandbox: `${prefix}NylorunSandbox`,
         };
         this.ingressUrl = options.ingressUrl.replace(/\/+$/, "");
@@ -76,9 +70,6 @@ export class RestateExecution {
             throw new Error(`Unknown wake reason: ${String(wake.reason)}`);
         await this.send(this.names.session, sessionKey(tenantId, sessionId), "advance", { reason: wake.reason }, wake.dedupeKey);
     }
-    async deliver(tenantId, actionId) {
-        await this.send(this.names.action, sessionKey(tenantId, actionId), "deliver", {});
-    }
     async sandbox(tenantId, sandboxId, signal) {
         const key = sessionKey(tenantId, sandboxId);
         if (signal.kind === "reconcile")
@@ -259,24 +250,6 @@ export class RestateExecution {
             },
             options: serviceOptions,
         });
-        const action = restate.object({
-            name: names.action,
-            handlers: {
-                deliver: async (ctx, _input) => {
-                    const { tenantId, sessionId: actionId } = parseSessionKey(ctx.key);
-                    const result = await this.runAborted(ctx.request().attemptCompletedSignal, (handlers, signal) => {
-                        if (!handlers.deliver)
-                            throw new Error("WorkerHandlers.deliver is required for deliveries");
-                        return handlers.deliver(tenantId, actionId, signal);
-                    });
-                    if (result.status === "retry")
-                        ctx
-                            .objectSendClient({ name: names.action }, ctx.key)
-                            .deliver({}, restate.rpc.sendOpts({ delay: Math.max(0, result.retryAfterMs) }));
-                },
-            },
-            options: serviceOptions,
-        });
         /** Sets a sandbox timer: the latest time wins; `fire` checks it. */
         const armSandbox = async (ctx, input) => {
             ctx.set(`at:${input.timer}`, input.at);
@@ -318,11 +291,11 @@ export class RestateExecution {
             },
             options: serviceOptions,
         });
-        return [session, tenant, timer, action, sandbox];
+        return [session, tenant, timer, sandbox];
     }
     /**
      * Runs a Worker handler with a signal aborted by `stop` or by the end of the Restate
-     * attempt (`advance` and `deliver`).
+     * attempt (`advance` and `reconcile`).
      */
     async runAborted(attemptDone, fn) {
         const controller = new AbortController();
@@ -424,7 +397,7 @@ export async function listStuckInvocations(options) {
     const prefix = options.servicePrefix ?? "";
     if (!/^[A-Za-z0-9_]*$/.test(prefix))
         throw new Error(`Invalid Restate service prefix: ${prefix}`);
-    const services = ["NylorunSession", "NylorunTenant", "NylorunTimer", "NylorunAction", "NylorunSandbox"].map((name) => `'${prefix}${name}'`);
+    const services = ["NylorunSession", "NylorunTenant", "NylorunTimer", "NylorunSandbox"].map((name) => `'${prefix}${name}'`);
     const clauses = [
         `target_service_name IN (${services.join(", ")})`,
         `status IN ('paused', 'backing-off')`,

package/dist/adapters/replication/pgoutput.js

@@ -146,7 +146,7 @@ export function createPgoutputSource(options) {
         },
         async lag() {
             // An idle relay confirms one byte past the last record, ahead of pg_current_wal_lsn():
-            // that is no lag, not -1 (the Admin status refuses a negative lag).
+            // that is no lag, not -1.
             const { rows } = await pool.query(`SELECT GREATEST(pg_wal_lsn_diff(pg_current_wal_lsn(), confirmed_flush_lsn), 0)::text AS lag
          FROM pg_replication_slots WHERE slot_name = $1`, [slot]);
             return rows[0]?.lag == null ? undefined : Number(rows[0].lag);

package/dist/adapters/sandbox/local.js

@@ -164,7 +164,7 @@ export function localBackend(options) {
             return { entries, truncated: !complete };
         },
         async writeFile(path, content) {
-            await writeFile(path, content, "utf8");
+            await (typeof content === "string" ? writeFile(path, content, "utf8") : writeFile(path, content));
         },
         async stop() { },
     };

package/dist/adapters/sandbox/virtual.js

@@ -140,7 +140,7 @@ export function virtualBackend(options) {
                     return { entries, truncated: !complete };
                 },
                 async writeFile(path, content) {
-                    await fs.writeFile(path, content, "utf8");
+                    await (typeof content === "string" ? fs.writeFile(path, content, "utf8") : fs.writeFile(path, content));
                 },
                 async stop() { },
             };

package/dist/api/ag-ui/endpoint.js

@@ -29,7 +29,6 @@ function registerComponents(api) {
 const FOR_A_PERSON = {
     credentials: ["subject", "token"],
     scopes: ["sessions:own"],
-    browser: true,
 };
 const events = (description) => ({
     description,
@@ -50,7 +49,7 @@ export function agUiRoutes(api) {
         path: "/v1/ag-ui/agents/{agentId}",
         tags: TAGS,
         summary: "Run an agent",
-        description: "For a person, named by a subject token or by `Nylorun-Subject`. The thread is one session per person, agent and thread, created on its first run with `forwardedProps.nylorun.session`. The trailing user message starts a turn (its id is the idempotency key); `resume` answers interrupts. A busy session or a turn limit is a `RUN_ERROR` in the stream.",
+        description: "For a person, named by a trusted issuer's token or by `Nylorun-Subject`. The thread is one session per person, agent and thread, created on its first run with `forwardedProps.nylorun.session`. The trailing user message starts a turn (its id is the idempotency key); `resume` answers interrupts. A busy session is a `RUN_ERROR` in the stream.",
         request: {
             params: agentId,
             body: {

package/dist/api/ag-ui/routes.d.ts

@@ -2,7 +2,7 @@ import type { ServerResponse } from "node:http";
 import { type Message } from "@ag-ui/core";
 import { type AuthScope, type SessionAccess, type TenantContext } from "../../tenant/context.js";
 /**
- * Who an AG-UI request acts for, once its agent is known: a person (a subject token's subject,
+ * Who an AG-UI request acts for, once its agent is known: a person (an issuer token's subject,
  * or `Nylorun-Subject`), who may use the agent; else 400, or the 404 of a missing agent.
  */
 export declare function agUiCaller(scope: AuthScope, agentId: string): {

package/dist/api/ag-ui/routes.js

@@ -1,6 +1,6 @@
 /**
  * The Runtime's AG-UI endpoint (Host feature `ag-ui-endpoint`): the Tenant's agents served to
- * AG-UI clients, for a person named by a subject token (a browser or app) or by subject headers
+ * AG-UI clients, for a person named by a trusted issuer's token (a browser or app) or by subject headers
  * (an app server's `createAgUiHandler`, which forwards here). One implementation for both, so
  * a thread is the same session whichever way it is reached.
  *
@@ -15,8 +15,8 @@
  * idempotency key, approvals become interrupts resumed through `resume`, and the last AG-UI
  * event made from each Runtime event carries its cursor as the SSE id. A run's session is
  * created on its first run with the options in `forwardedProps.nylorun.session` and never
- * changed afterwards. A stream opened with a subject token ends at the token's expiry or
- * revocation with `CUSTOM nylorun.stream_closed`, and the client reattaches with a new token.
+ * changed afterwards. A stream opened with an issuer token ends at the token's expiry with
+ * `CUSTOM nylorun.stream_closed`, and the client reattaches with a new token.
  */
 import { randomUUID } from "node:crypto";
 import { EventType, } from "@ag-ui/core";
@@ -30,9 +30,9 @@ import { accessOf } from "../../tenant/auth.js";
 import { command } from "../../tenant/commands.js";
 import { loadSession, sessionOf, } from "../../tenant/context.js";
 import { fail, HttpError } from "../../tenant/http.js";
-import { observeSession, readHistory, StreamClosed, } from "../../tenant/session-streams.js";
+import { observeSession, readHistory, StreamClosed, streamHolderOf, } from "../../tenant/session-streams.js";
 import { putSession, sessionView } from "../../tenant/sessions.js";
-import { mayUseAgent } from "../../tenant/tokens.js";
+import { mayUseAgent } from "../../tenant/auth.js";
 import { sandboxGrantsOf } from "../../tenant/sandboxes.js";
 const HEARTBEAT_MS = 15_000;
 const TERMINAL = new Set([
@@ -41,16 +41,14 @@ const TERMINAL = new Set([
     "turn.failed",
     "turn.cancelled",
 ]);
-/** The person a request acts for: a subject token's subject, or `Nylorun-Subject`. */
+/** The person a request acts for: an issuer token's subject, or `Nylorun-Subject`. */
 function personOf(scope) {
     if (scope.kind === "token" || scope.kind === "subject")
         return scope.subject;
-    return fail(400, "AG-UI runs act for a person: send a subject token, or Nylorun-Subject with the application key", { code: "invalid_request" });
+    return fail(400, "AG-UI runs act for a person: send a trusted issuer's token, or Nylorun-Subject with the application key", { code: "invalid_request" });
 }
 function holderOf(scope) {
-    return scope.kind === "token"
-        ? { subject: scope.subject, epoch: scope.epoch, expiresAt: scope.expiresAt }
-        : undefined;
+    return streamHolderOf(scope);
 }
 /** A refusal a client can act on, streamed as `RUN_ERROR` rather than an HTTP error. */
 function runError(error) {
@@ -96,7 +94,7 @@ function sessionOptions(input, scope) {
         });
     // Agent code may trust `info`: only an app server sets it.
     if (scope.kind === "token" && parsed.data.info !== undefined)
-        return fail(403, "A subject token cannot set session info", {
+        return fail(403, "A token caller cannot set session info", {
             code: "scope_required",
         });
     return parsed.data;
@@ -220,7 +218,7 @@ async function historyFrom(ctx, id, cursor) {
     return items;
 }
 /**
- * Who an AG-UI request acts for, once its agent is known: a person (a subject token's subject,
+ * Who an AG-UI request acts for, once its agent is known: a person (an issuer token's subject,
  * or `Nylorun-Subject`), who may use the agent; else 400, or the 404 of a missing agent.
  */
 export function agUiCaller(scope, agentId) {
@@ -236,7 +234,7 @@ export async function startRun(ctx, scope, agentId, caller, body, response) {
     if (!parsed.success)
         return fail(400, "Invalid RunAgentInput", { code: "invalid_request" });
     const input = parsed.data;
-    // Nylorun tools run in the Runtime or the app's Action endpoint; the browser runs none.
+    // Nylorun tools run in the Runtime (HTTP, MCP and built-in tools); the browser runs none.
     if (input.tools?.length)
         return fail(400, "Frontend tools are not supported", { code: "invalid_request" });
     const id = sessionIdFor(caller.subject, agentId, input.threadId);

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

@@ -13,7 +13,7 @@ export interface Step {
     readonly events: BaseEvent[];
     readonly finished: boolean;
 }
-/** A tool result from any of the three places a call can end. */
+/** A tool result from either of the two places a call can end. */
 export declare function toolResultOf(event: TranscriptEvent): {
     callId: string;
     content: string;
@@ -21,8 +21,6 @@ export declare function toolResultOf(event: TranscriptEvent): {
 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;
     /**

package/dist/api/ag-ui/translate.js

@@ -24,16 +24,9 @@ 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. */
+/** A tool result from either of the two 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)
@@ -60,8 +53,6 @@ export function toolResultOf(event) {
 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;
     /**
@@ -77,11 +68,6 @@ export class RunTranslator {
         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))
@@ -122,7 +108,7 @@ export class RunTranslator {
             case "turn.paused": {
                 const interrupts = event.payload.interactions.map((w) => {
                     const interaction = w.interaction;
-                    const toolCallId = this.callIds.get(w.invocationId);
+                    const toolCallId = w.callId;
                     return {
                         id: interaction.id,
                         reason: interaction.kind === "approval" ? "tool_approval" : "input_required",
@@ -163,7 +149,6 @@ export class RunTranslator {
                 };
             }
             case "effect.uncertain":
-            case "action.uncertain":
                 // The Runtime cannot tell whether a side effect happened; the run goes on.
                 return {
                     events: [