@nylorun/runtime 0.13.0-beta → 0.14.0-beta

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

@@ -0,0 +1,222 @@
+/**
+ * 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;
+}