@nylorun/runtime 0.23.0-beta → 0.25.0-beta

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

@@ -12,7 +12,9 @@
  * - `POST …/threads/:thread/cancel` — cancel the running turn.
  *
  * Each thread maps to one session per subject, agent and thread. The message id is the
- * idempotency key, approvals become interrupts resumed through `resume`, and the last AG-UI
+ * idempotency key, a message's media parts become file parts (bytes sent inline are stored as
+ * artifacts of the session, `../inbound-files.ts`; a file the model does not read is a
+ * `RUN_ERROR`), 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 an issuer token ends at the token's expiry with
@@ -22,7 +24,8 @@ import { randomUUID } from "node:crypto";
 import { EventType, } from "@ag-ui/core";
 import { RunAgentInputSchema } from "@ag-ui/core/schemas";
 import { PutSessionRequestSchema, } from "@nylorun/core/contracts";
-import { messagesFromEvents } from "./history.js";
+import { messagesFromEvents, NYLORUN_FILE_PROVIDER } from "./history.js";
+import { discardFiles, inlineFileName, messageParts, refuseUrl, } from "../inbound-files.js";
 import { sessionIdFor } from "./session-id.js";
 import { SSE_CONTENT_TYPE, SSE_HEARTBEAT, sseFrame } from "./sse.js";
 import { RunTranslator } from "./translate.js";
@@ -33,7 +36,7 @@ import { fail, HttpError } from "../../tenant/http.js";
 import { observeSession, readHistory, StreamClosed, streamHolderOf, } from "../../tenant/session-streams.js";
 import { putSession, sessionView } from "../../tenant/sessions.js";
 import { mayUseAgent } from "../../tenant/auth.js";
-import { sandboxGrantsOf } from "../../tenant/sandboxes.js";
+import { environmentGrantsOf } from "../../tenant/environments.js";
 const HEARTBEAT_MS = 15_000;
 const TERMINAL = new Set([
     "turn.completed",
@@ -60,11 +63,38 @@ function runError(error) {
         : error.message;
     return { type: EventType.RUN_ERROR, message, code };
 }
-/** The trailing user message: the Runtime keeps the transcript, AG-UI resends all of it. */
+/** A media part's file: bytes sent inline, or an artifact the Runtime already holds. */
+function inboundFile(part, index) {
+    const { source } = part;
+    if (source.type === "url")
+        return refuseUrl();
+    if (source.type === "file") {
+        if (source.provider !== NYLORUN_FILE_PROVIDER)
+            return fail(400, `A file source names an artifact: provider "${NYLORUN_FILE_PROVIDER}" and its artifact id`, { code: "invalid_request" });
+        return { type: "artifact", artifactId: source.value };
+    }
+    const metadata = (part.metadata ?? {});
+    const named = [metadata.filename, metadata.name].find((value) => typeof value === "string" && value !== "");
+    return {
+        type: "inline",
+        name: named ?? inlineFileName(source.mimeType, index),
+        mediaType: source.mimeType,
+        data: source.value,
+    };
+}
+/**
+ * The trailing user message: the Runtime keeps the transcript, AG-UI resends all of it. Its
+ * text, or its parts when it carries a media part.
+ */
 function lastUserMessage(messages) {
     const last = messages.at(-1);
     if (!last || last.role !== "user")
         return fail(400, "The run's last message must be a user message");
+    if (typeof last.content !== "string" && last.content.some((part) => part.type !== "text")) {
+        let files = 0;
+        const parts = last.content.map((part) => part.type === "text" ? { type: "text", text: part.text } : inboundFile(part, files++));
+        return { id: last.id, text: "", parts };
+    }
     const text = typeof last.content === "string"
         ? last.content
         : last.content
@@ -83,8 +113,7 @@ function sessionOptions(input, scope) {
         return {};
     const parsed = PutSessionRequestSchema.pick({
         info: true,
-        vaultIds: true,
-        credentialSelections: true,
+        environment: true,
     })
         .strict()
         .safeParse(raw);
@@ -99,11 +128,11 @@ function sessionOptions(input, scope) {
         });
     return parsed.data;
 }
-async function accepted(ctx, id, body, scope) {
-    const result = (await command(ctx, id, body, scope));
+async function accepted(ctx, id, body, scope, trace) {
+    const result = (await command(ctx, id, body, scope, trace ? { trace } : {}));
     return result?.cursor ?? null;
 }
-async function submit(ctx, id, input, scope) {
+async function submit(ctx, id, input, scope, trace) {
     if (input.resume?.length) {
         // The interaction's kind is on the session's pending view, not in its id.
         const view = (await ctx.store.tx(async (t) => sessionView(t, await sessionOf(t, id, accessOf(scope)))));
@@ -139,12 +168,23 @@ async function submit(ctx, id, input, scope) {
     const message = lastUserMessage(input.messages);
     // The AG-UI message id is the idempotency key: a retried run replays the same turn, and
     // history gives the message back its client id.
-    return accepted(ctx, id, {
-        type: "message",
-        requestId: randomUUID(),
-        idempotencyKey: message.id,
-        content: message.text,
-    }, scope);
+    if (!message.parts)
+        return accepted(ctx, id, {
+            type: "message",
+            requestId: randomUUID(),
+            idempotencyKey: message.id,
+            content: message.text,
+        }, scope, trace);
+    const access = accessOf(scope);
+    const { parts, stored } = await messageParts(ctx, id, message.id, message.parts, access);
+    try {
+        return await accepted(ctx, id, { type: "message", requestId: randomUUID(), idempotencyKey: message.id, parts }, scope, trace);
+    }
+    catch (error) {
+        // A refused message leaves no files behind.
+        await discardFiles(ctx, stored, access);
+        throw error;
+    }
 }
 /**
  * Streams translated events until the run ends. Closing the connection stops the read, never
@@ -229,7 +269,9 @@ export function agUiCaller(scope, agentId) {
     return { subject, access: accessOf(scope) };
 }
 /** `POST /v1/ag-ui/agents/:agent`: start a run, and stream it on `response`. */
-export async function startRun(ctx, scope, agentId, caller, body, response) {
+export async function startRun(ctx, scope, agentId, caller, body, response, 
+/** The request's trace context (R7.4): the turn the run starts joins the caller's trace. */
+trace) {
     const parsed = RunAgentInputSchema.safeParse(body);
     if (!parsed.success)
         return fail(400, "Invalid RunAgentInput", { code: "invalid_request" });
@@ -245,16 +287,17 @@ export async function startRun(ctx, scope, agentId, caller, body, response) {
         ...sessionOptions(input, scope),
     }, caller.access, {
         createOnly: true,
-        ...(sandboxGrantsOf(scope) === undefined ? {} : { sandboxGrants: sandboxGrantsOf(scope) }),
+        ...(environmentGrantsOf(scope) === undefined ? {} : { environmentGrants: environmentGrantsOf(scope) }),
     });
     const translator = new RunTranslator(input.threadId, input.runId);
     let cursor;
     try {
-        cursor = await submit(ctx, id, input, scope);
+        cursor = await submit(ctx, id, input, scope, trace);
     }
     catch (error) {
-        // A busy session or a limit is a run that could not start, not a transport failure.
-        if (error instanceof HttpError && (error.status === 409 || error.status === 429))
+        // A busy session, a limit or a file the model does not read is a run that could not start,
+        // not a transport failure.
+        if (error instanceof HttpError && [409, 422, 429].includes(error.status))
             return stream(response, translator, undefined, [runError(error)]);
         throw error;
     }

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

@@ -4,7 +4,7 @@
  * `<callId>:result`, so live runs and `messagesFromEvents` agree.
  */
 import { EventType } from "@ag-ui/core";
-import { parseTranscriptEvent, } from "@nylorun/core/contracts";
+import { isEmptyAssistantMessage, 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;
@@ -89,7 +89,8 @@ export class RunTranslator {
         switch (event.type) {
             case "message.assistant": {
                 const p = event.payload;
-                if (p.agent)
+                // A step that said nothing is in the log for its timing (R7.1), never a message.
+                if (p.agent || isEmptyAssistantMessage(p))
                     return none;
                 this.sawAssistant = true;
                 return { events: assistantEvents(p), finished: false };