@dudousxd/nestjs-agent-core 0.34.0 → 0.36.0

package/dist/ag-ui/index.cjs

@@ -0,0 +1,1064 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/ag-ui/index.ts
+var ag_ui_exports = {};
+__export(ag_ui_exports, {
+  AG_UI_CUSTOM: () => AG_UI_CUSTOM,
+  AG_UI_PROTOCOL_VERSION: () => AG_UI_PROTOCOL_VERSION,
+  AgUiEncoder: () => AgUiEncoder,
+  agUiEvents: () => agUiEvents,
+  agUiFramesFromNdjson: () => agUiFramesFromNdjson,
+  agUiSse: () => agUiSse,
+  decodeInterruptId: () => decodeInterruptId,
+  encodeInterruptId: () => encodeInterruptId,
+  parseRunInput: () => parseRunInput,
+  planResume: () => planResume,
+  readAnswersPayload: () => readAnswersPayload,
+  readApprovalPayload: () => readApprovalPayload,
+  readContext: () => readContext,
+  readForwardedProps: () => readForwardedProps,
+  readUserTurn: () => readUserTurn
+});
+module.exports = __toCommonJS(ag_ui_exports);
+
+// src/ag-ui/interrupt-id.ts
+var PREFIX = "agora_";
+function encodeInterruptId(address) {
+  const compact = [
+    address.kind === "approval" ? "a" : "e",
+    address.parked,
+    address.stream,
+    address.toolCallId,
+    address.position
+  ];
+  return PREFIX + Buffer.from(JSON.stringify(compact), "utf8").toString("base64url");
+}
+__name(encodeInterruptId, "encodeInterruptId");
+function decodeInterruptId(id) {
+  if (typeof id !== "string" || !id.startsWith(PREFIX)) return null;
+  try {
+    const parsed = JSON.parse(Buffer.from(id.slice(PREFIX.length), "base64url").toString("utf8"));
+    if (!Array.isArray(parsed) || parsed.length !== 5) return null;
+    const [kind, parked, stream, toolCallId, position] = parsed;
+    if (kind !== "a" && kind !== "e" || typeof parked !== "string" || typeof stream !== "string" || typeof toolCallId !== "string" || typeof position !== "number" || !Number.isSafeInteger(position) || position < 0) {
+      return null;
+    }
+    return {
+      kind: kind === "a" ? "approval" : "elicitation",
+      parked,
+      stream,
+      toolCallId,
+      position
+    };
+  } catch {
+    return null;
+  }
+}
+__name(decodeInterruptId, "decodeInterruptId");
+
+// src/ag-ui/types.ts
+var AG_UI_PROTOCOL_VERSION = "1.0";
+var AG_UI_CUSTOM = {
+  /** `{ runId, threadId }` — the library's own ids for the run behind this stream (cancel, re-attach). */
+  run: "agora.run",
+  /** A generative-UI component (`AgentUiComponent`); a repeat `id` replaces. */
+  ui: "agora.ui",
+  title: "agora.title",
+  queue: "agora.queue",
+  /** The approval request as the native protocol carries it, for a consumer that renders it live. */
+  approvalRequested: "agora.approval-requested",
+  approvalSettled: "agora.approval-settled",
+  /** The whole question set of an elicitation (`ElicitationRequest`). */
+  elicitation: "agora.elicitation",
+  /** `{ usage, costUsd, reasoningMs }` of one model step. */
+  stepUsage: "agora.step-usage",
+  /** `{ message }` — input material this producer could not use and dropped. */
+  warning: "agora.warning"
+};
+
+// src/ag-ui/encoder.ts
+var APPROVAL_SCHEMA = {
+  type: "object",
+  properties: {
+    approved: {
+      type: "boolean"
+    },
+    reason: {
+      type: "string"
+    },
+    remember: {
+      type: "boolean"
+    }
+  },
+  required: [
+    "approved"
+  ]
+};
+function elicitationSchema(request) {
+  const properties = {};
+  for (const question of request.questions) {
+    const options = question.options?.map((option) => option.value);
+    properties[question.id] = {
+      type: "array",
+      title: question.prompt,
+      ...question.description !== void 0 ? {
+        description: question.description
+      } : {},
+      items: options !== void 0 && options.length > 0 && question.allowFreeText !== true ? {
+        type: "string",
+        enum: options
+      } : {
+        type: "string"
+      },
+      ...question.multiple === true ? {} : {
+        maxItems: 1
+      },
+      ...question.defaults !== void 0 ? {
+        default: question.defaults
+      } : {}
+    };
+  }
+  return {
+    type: "object",
+    properties: {
+      answers: {
+        type: "object",
+        properties
+      }
+    },
+    required: [
+      "answers"
+    ]
+  };
+}
+__name(elicitationSchema, "elicitationSchema");
+function text(value) {
+  if (typeof value === "string") return value;
+  const json = JSON.stringify(value);
+  return json === void 0 ? "" : json;
+}
+__name(text, "text");
+var AgUiEncoder = class {
+  static {
+    __name(this, "AgUiEncoder");
+  }
+  options;
+  position = 0;
+  started = false;
+  closed = false;
+  cancelled = false;
+  crossed = false;
+  messageSeq = 0;
+  stepSeq = 0;
+  openText;
+  openReasoning;
+  /** The last text message of the current step: a tool call attaches to it. */
+  stepMessage;
+  openSteps = [];
+  calls = /* @__PURE__ */ new Map();
+  pending = /* @__PURE__ */ new Map();
+  usage = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.options = options;
+  }
+  /** How many frames of the library stream this encoder has consumed. */
+  get consumed() {
+    return this.position;
+  }
+  /** The run is waiting on at least one approval or question set nobody has settled yet. */
+  get waiting() {
+    return this.pending.size > 0;
+  }
+  /**
+  * Is anything still in flight that is NOT waiting on a person — a tool call announced and neither
+  * answered nor parked? While there is, more frames are coming without anyone's help.
+  */
+  get busy() {
+    for (const [id, call] of this.calls) {
+      if (!call.answered && !this.pending.has(id)) return true;
+    }
+    return false;
+  }
+  /** `RUN_STARTED`, and the library's own ids for the run. Call once, before the first frame. */
+  start() {
+    if (this.started) return [];
+    this.started = true;
+    return [
+      {
+        type: "RUN_STARTED",
+        threadId: this.options.threadId,
+        runId: this.options.runId,
+        protocolVersion: AG_UI_PROTOCOL_VERSION
+      },
+      {
+        type: "CUSTOM",
+        name: AG_UI_CUSTOM.run,
+        value: {
+          runId: this.options.streamRunId,
+          threadId: this.options.streamThreadId ?? this.options.threadId
+        }
+      }
+    ];
+  }
+  /** The AG-UI events the next frame of the library stream stands for (possibly none). */
+  encode(frame) {
+    const position = this.position;
+    this.position += 1;
+    if (this.closed) return [];
+    const skip = this.options.skip ?? 0;
+    if (!this.crossed && position >= skip) this.crossBoundary();
+    const events = this.project(frame, position);
+    if (position < skip) {
+      if (this.position >= skip) this.crossBoundary();
+      return [];
+    }
+    return events;
+  }
+  /**
+  * The replayed frames are behind us: from here on events are written. The AG-UI run that delivered
+  * them closed everything it had open before it finished, so this run starts with nothing open, and
+  * what the resuming request answered is no longer waiting.
+  */
+  crossBoundary() {
+    this.crossed = true;
+    this.openText = void 0;
+    this.openReasoning = void 0;
+    this.stepMessage = void 0;
+    this.openSteps.length = 0;
+    for (const call of this.calls.values()) {
+      call.started = false;
+      call.ended = true;
+    }
+    for (const id of this.options.answered ?? []) this.pending.delete(id);
+  }
+  get replaying() {
+    return this.position <= (this.options.skip ?? 0);
+  }
+  project(event, position) {
+    switch (event.kind) {
+      case "error": {
+        this.closed = true;
+        const usage = this.usageEntries();
+        return [
+          {
+            type: "RUN_ERROR",
+            message: event.message,
+            code: event.code,
+            ...usage.length > 0 ? {
+              usage
+            } : {}
+          }
+        ];
+      }
+      case "ui":
+        return [
+          this.custom(AG_UI_CUSTOM.ui, {
+            id: event.id ?? `ui:${position}`,
+            component: event.component,
+            props: event.props,
+            ...event.version !== void 0 ? {
+              version: event.version
+            } : {},
+            ...event.toolCallId !== void 0 ? {
+              toolCallId: event.toolCallId
+            } : {}
+          })
+        ];
+      case "approval-requested": {
+        const call = this.calls.get(event.id);
+        const parked = event.runId ?? this.options.streamRunId;
+        const toolName = event.toolName ?? call?.name ?? "";
+        const input = event.input ?? call?.input ?? null;
+        this.pending.set(event.id, {
+          kind: "approval",
+          parked,
+          toolCallId: event.id,
+          interrupt: {
+            reason: "tool_approval",
+            message: event.reason ?? (toolName.length > 0 ? `Approve ${toolName}?` : "Approve?"),
+            toolCallId: event.id,
+            responseSchema: APPROVAL_SCHEMA,
+            ...event.expiresAt !== void 0 ? {
+              expiresAt: event.expiresAt
+            } : {},
+            metadata: {
+              "agora.toolName": toolName,
+              "agora.input": input,
+              "agora.approver": event.approver
+            }
+          }
+        });
+        return [
+          this.custom(AG_UI_CUSTOM.approvalRequested, {
+            id: event.id,
+            runId: parked,
+            toolName,
+            input,
+            approver: event.approver,
+            ...event.expiresAt !== void 0 ? {
+              expiresAt: event.expiresAt
+            } : {},
+            ...event.reason !== void 0 ? {
+              reason: event.reason
+            } : {}
+          })
+        ];
+      }
+      case "elicitation": {
+        const parked = event.runId ?? this.options.streamRunId;
+        this.pending.set(event.id, {
+          kind: "elicitation",
+          parked,
+          toolCallId: event.id,
+          interrupt: {
+            reason: "input_required",
+            message: event.request.preamble ?? event.request.questions[0]?.prompt ?? "Input required",
+            // An intake's question set belongs to no tool call the stream announced.
+            ...this.calls.has(event.id) ? {
+              toolCallId: event.id
+            } : {},
+            responseSchema: elicitationSchema(event.request),
+            metadata: {
+              "agora.request": event.request
+            }
+          }
+        });
+        return [
+          this.custom(AG_UI_CUSTOM.elicitation, {
+            runId: parked,
+            request: event.request
+          })
+        ];
+      }
+      case "text":
+        return event.text.length > 0 ? this.textDelta(event.text) : [];
+      case "reasoning":
+        return event.text.length > 0 ? this.reasoningDelta(event.text) : [];
+      case "step-start": {
+        this.stepSeq += 1;
+        const stepName = `step-${this.stepSeq}`;
+        this.openSteps.push(stepName);
+        this.stepMessage = void 0;
+        return [
+          ...this.closeStreams(),
+          {
+            type: "STEP_STARTED",
+            stepName
+          }
+        ];
+      }
+      case "step-finish": {
+        const out = this.closeStreams();
+        if (!this.replaying) this.addUsage(event.usage, event.model);
+        const stepName = this.openSteps.pop();
+        if (stepName !== void 0) out.push({
+          type: "STEP_FINISHED",
+          stepName
+        });
+        if (event.usage !== void 0 || event.costUsd !== void 0) {
+          out.push(this.custom(AG_UI_CUSTOM.stepUsage, {
+            ...event.usage !== void 0 ? {
+              usage: event.usage
+            } : {},
+            ...event.costUsd !== void 0 ? {
+              costUsd: event.costUsd
+            } : {},
+            ...event.reasoningMs !== void 0 ? {
+              reasoningMs: event.reasoningMs
+            } : {}
+          }));
+        }
+        return out;
+      }
+      case "tool-input-start": {
+        if (this.calls.has(event.id)) return [];
+        const out = this.closeStreams();
+        this.calls.set(event.id, {
+          name: event.name,
+          started: true,
+          ended: false,
+          sawDelta: false,
+          answered: false
+        });
+        out.push(this.callStart(event.id, event.name));
+        return out;
+      }
+      case "tool-input-delta": {
+        const call = this.calls.get(event.id);
+        if (call === void 0 || call.ended || event.delta.length === 0) return [];
+        call.sawDelta = true;
+        return [
+          {
+            type: "TOOL_CALL_ARGS",
+            toolCallId: event.id,
+            delta: event.delta
+          }
+        ];
+      }
+      case "tool-input-available": {
+        const known = this.calls.get(event.id);
+        if (known?.ended === true) return [];
+        const out = this.closeStreams();
+        const call = known ?? {
+          name: event.name,
+          started: false,
+          ended: false,
+          sawDelta: false,
+          answered: false
+        };
+        if (!call.started) {
+          call.started = true;
+          out.push(this.callStart(event.id, event.name));
+        }
+        if (!call.sawDelta) {
+          out.push({
+            type: "TOOL_CALL_ARGS",
+            toolCallId: event.id,
+            delta: text(event.input ?? {})
+          });
+        }
+        call.ended = true;
+        call.input = event.input;
+        this.calls.set(event.id, call);
+        out.push({
+          type: "TOOL_CALL_END",
+          toolCallId: event.id
+        });
+        return out;
+      }
+      case "tool-output":
+        return this.result(event.id, text(event.output));
+      case "tool-output-error":
+        return this.result(event.id, event.error, {
+          "agora.outcome": "error"
+        });
+      case "tool-output-denied":
+        return this.result(event.id, event.reason ?? "denied", {
+          "agora.outcome": "denied"
+        });
+      case "approval-settled":
+        this.pending.delete(event.id);
+        return [
+          this.custom(AG_UI_CUSTOM.approvalSettled, event)
+        ];
+      case "title":
+        return [
+          this.custom(AG_UI_CUSTOM.title, {
+            title: event.title
+          })
+        ];
+      case "queue":
+        return [
+          this.custom(AG_UI_CUSTOM.queue, {
+            queue: event.queue,
+            ...event.started !== void 0 ? {
+              started: event.started
+            } : {}
+          })
+        ];
+      case "cancelled":
+        this.cancelled = true;
+        return [];
+      default:
+        return [];
+    }
+  }
+  /**
+  * The events that end the AG-UI run: whatever is still open is closed first, then `RUN_FINISHED`
+  * with how it ended — interrupted when the run is waiting on someone, cancelled when it was
+  * stopped, success otherwise. Nothing after a `RUN_ERROR`. `ended` says the library run's stream
+  * itself ended, rather than this reader having stopped following it.
+  */
+  finish(ended = false) {
+    if (this.closed) return [];
+    this.closed = true;
+    if (!this.crossed) this.crossBoundary();
+    if (ended) this.pending.clear();
+    const out = this.start();
+    out.push(...this.closeStreams());
+    for (const [id, call] of this.calls) {
+      if (call.started && !call.ended) {
+        call.ended = true;
+        out.push({
+          type: "TOOL_CALL_END",
+          toolCallId: id
+        });
+      }
+    }
+    while (this.openSteps.length > 0) {
+      out.push({
+        type: "STEP_FINISHED",
+        stepName: this.openSteps.pop()
+      });
+    }
+    const usage = this.usageEntries();
+    const interrupts = this.cancelled ? [] : this.interrupts();
+    out.push({
+      type: "RUN_FINISHED",
+      threadId: this.options.threadId,
+      runId: this.options.runId,
+      ...this.cancelled ? {
+        outcome: {
+          type: "cancelled"
+        }
+      } : interrupts.length > 0 ? {
+        outcome: {
+          type: "interrupt",
+          interrupts
+        }
+      } : {},
+      ...usage.length > 0 ? {
+        usage
+      } : {}
+    });
+    return out;
+  }
+  interrupts() {
+    return [
+      ...this.pending.values()
+    ].map((entry) => ({
+      id: encodeInterruptId({
+        kind: entry.kind,
+        parked: entry.parked,
+        stream: this.options.streamRunId,
+        toolCallId: entry.toolCallId,
+        position: this.position
+      }),
+      ...entry.interrupt
+    }));
+  }
+  custom(name, value) {
+    return {
+      type: "CUSTOM",
+      name,
+      value
+    };
+  }
+  nextMessageId() {
+    this.messageSeq += 1;
+    return `${this.options.runId}:m${this.messageSeq}`;
+  }
+  textDelta(delta) {
+    const out = [];
+    if (this.openReasoning !== void 0) out.push(...this.closeReasoning());
+    if (this.openText === void 0) {
+      this.openText = this.nextMessageId();
+      this.stepMessage = this.openText;
+      out.push({
+        type: "TEXT_MESSAGE_START",
+        messageId: this.openText,
+        role: "assistant"
+      });
+    }
+    out.push({
+      type: "TEXT_MESSAGE_CONTENT",
+      messageId: this.openText,
+      delta
+    });
+    return out;
+  }
+  reasoningDelta(delta) {
+    const out = [];
+    if (this.openText !== void 0) out.push(...this.closeText());
+    if (this.openReasoning === void 0) {
+      this.openReasoning = this.nextMessageId();
+      out.push({
+        type: "REASONING_START",
+        messageId: this.openReasoning
+      }, {
+        type: "REASONING_MESSAGE_START",
+        messageId: this.openReasoning,
+        role: "reasoning"
+      });
+    }
+    out.push({
+      type: "REASONING_MESSAGE_CONTENT",
+      messageId: this.openReasoning,
+      delta
+    });
+    return out;
+  }
+  closeText() {
+    if (this.openText === void 0) return [];
+    const messageId = this.openText;
+    this.openText = void 0;
+    return [
+      {
+        type: "TEXT_MESSAGE_END",
+        messageId
+      }
+    ];
+  }
+  closeReasoning() {
+    if (this.openReasoning === void 0) return [];
+    const messageId = this.openReasoning;
+    this.openReasoning = void 0;
+    return [
+      {
+        type: "REASONING_MESSAGE_END",
+        messageId
+      },
+      {
+        type: "REASONING_END",
+        messageId
+      }
+    ];
+  }
+  closeStreams() {
+    return [
+      ...this.closeReasoning(),
+      ...this.closeText()
+    ];
+  }
+  callStart(id, name) {
+    return {
+      type: "TOOL_CALL_START",
+      toolCallId: id,
+      toolCallName: name,
+      ...this.stepMessage !== void 0 ? {
+        parentMessageId: this.stepMessage
+      } : {}
+    };
+  }
+  result(id, content, metadata) {
+    const call = this.calls.get(id);
+    if (call !== void 0) call.answered = true;
+    else {
+      this.calls.set(id, {
+        name: "",
+        started: false,
+        ended: true,
+        sawDelta: false,
+        answered: true
+      });
+    }
+    this.pending.delete(id);
+    return [
+      ...this.closeStreams(),
+      {
+        type: "TOOL_CALL_RESULT",
+        messageId: `${this.options.runId}:tool:${id}`,
+        toolCallId: id,
+        content,
+        role: "tool",
+        ...metadata !== void 0 ? {
+          metadata
+        } : {}
+      }
+    ];
+  }
+  addUsage(usage, model) {
+    if (usage === void 0) return;
+    const name = typeof model === "string" && model.length > 0 ? model : this.options.model;
+    const key = name ?? "";
+    const entry = this.usage.get(key) ?? (name !== void 0 ? {
+      model: name
+    } : {});
+    entry.inputTokens = (entry.inputTokens ?? 0) + usage.inputTokens;
+    entry.outputTokens = (entry.outputTokens ?? 0) + usage.outputTokens;
+    entry.totalTokens = entry.inputTokens + entry.outputTokens;
+    if (usage.cacheReadTokens !== void 0) {
+      entry.cachedInputTokens = (entry.cachedInputTokens ?? 0) + usage.cacheReadTokens;
+    }
+    if (usage.cacheWriteTokens !== void 0) {
+      entry.cacheWriteInputTokens = (entry.cacheWriteInputTokens ?? 0) + usage.cacheWriteTokens;
+    }
+    if (usage.reasoningTokens !== void 0) {
+      entry.reasoningTokens = (entry.reasoningTokens ?? 0) + usage.reasoningTokens;
+    }
+    this.usage.set(key, entry);
+  }
+  usageEntries() {
+    return [
+      ...this.usage.values()
+    ];
+  }
+};
+
+// src/ag-ui/input.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+function parseRunInput(body) {
+  if (!isRecord(body)) return "the body must be a RunAgentInput object";
+  if (typeof body.threadId !== "string" || body.threadId.length === 0) {
+    return "threadId must be a non-empty string";
+  }
+  if (body.threadId.length > 255) return "threadId must be at most 255 characters";
+  if (typeof body.runId !== "string" || body.runId.length === 0) {
+    return "runId must be a non-empty string";
+  }
+  if (!Array.isArray(body.messages)) return "messages must be an array";
+  for (const message of body.messages) {
+    if (!isRecord(message) || typeof message.role !== "string") {
+      return "each message must be an object with a role";
+    }
+  }
+  if (body.resume !== void 0) {
+    if (!Array.isArray(body.resume)) return "resume must be an array";
+    for (const entry of body.resume) {
+      if (!isRecord(entry) || typeof entry.interruptId !== "string" || entry.status !== "resolved" && entry.status !== "cancelled") {
+        return "each resume entry needs an interruptId and a status of 'resolved' or 'cancelled'";
+      }
+    }
+  }
+  if (body.context !== void 0 && !Array.isArray(body.context)) {
+    return "context must be an array";
+  }
+  return body;
+}
+__name(parseRunInput, "parseRunInput");
+var EXTENSIONS = {
+  "image/png": "png",
+  "image/jpeg": "jpg",
+  "image/gif": "gif",
+  "image/webp": "webp",
+  "application/pdf": "pdf",
+  "text/plain": "txt"
+};
+function filenameOf(part, index, contentType) {
+  const metadata = part.metadata;
+  if (isRecord(metadata)) {
+    for (const key of [
+      "filename",
+      "name",
+      "title"
+    ]) {
+      const value = metadata[key];
+      if (typeof value === "string" && value.trim().length > 0) return value.trim().slice(0, 200);
+    }
+  }
+  const extension = EXTENSIONS[contentType];
+  return `${part.type}-${index + 1}${extension !== void 0 ? `.${extension}` : ""}`;
+}
+__name(filenameOf, "filenameOf");
+function readUserTurn(messages) {
+  let last;
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    if (messages[index]?.role === "user") {
+      last = messages[index];
+      break;
+    }
+  }
+  if (last === void 0) return null;
+  if (typeof last.content === "string") return {
+    text: last.content,
+    media: [],
+    dropped: []
+  };
+  if (!Array.isArray(last.content)) return {
+    text: "",
+    media: [],
+    dropped: []
+  };
+  const texts = [];
+  const media = [];
+  const dropped = [];
+  last.content.forEach((part, index) => {
+    if (!isRecord(part)) return;
+    if (part.type === "text") {
+      if (typeof part.text === "string") texts.push(part.text);
+      return;
+    }
+    if (part.type !== "image" && part.type !== "audio" && part.type !== "video" && part.type !== "document") {
+      return;
+    }
+    const source = part.source;
+    if (!isRecord(source) || source.type !== "data") {
+      const how = isRecord(source) && typeof source.type === "string" ? source.type : "unknown";
+      dropped.push(`The ${part.type} part ${index + 1} was not used: only inline data is accepted, not a ${how} source.`);
+      return;
+    }
+    if (typeof source.value !== "string" || typeof source.mimeType !== "string") {
+      dropped.push(`The ${part.type} part ${index + 1} was not used: its inline data is malformed.`);
+      return;
+    }
+    const data = Buffer.from(source.value, "base64");
+    if (data.length === 0) {
+      dropped.push(`The ${part.type} part ${index + 1} was not used: it carries no bytes.`);
+      return;
+    }
+    const contentType = source.mimeType.toLowerCase();
+    media.push({
+      kind: part.type,
+      contentType,
+      data,
+      filename: filenameOf(part, index, contentType)
+    });
+  });
+  return {
+    text: texts.join("\n"),
+    media,
+    dropped
+  };
+}
+__name(readUserTurn, "readUserTurn");
+function readContext(context) {
+  if (context === void 0) return void 0;
+  const entries = context.filter((entry) => isRecord(entry) && typeof entry.description === "string" && typeof entry.value === "string");
+  return entries.length > 0 ? entries : void 0;
+}
+__name(readContext, "readContext");
+function readForwardedProps(forwarded) {
+  if (!isRecord(forwarded)) return {};
+  const pick = /* @__PURE__ */ __name((key) => {
+    const value = forwarded[key];
+    return typeof value === "string" && value.length > 0 ? value : void 0;
+  }, "pick");
+  const agent = pick("agent");
+  const model = pick("model");
+  const persona = pick("persona");
+  return {
+    ...agent !== void 0 ? {
+      agent
+    } : {},
+    ...model !== void 0 ? {
+      model
+    } : {},
+    ...persona !== void 0 ? {
+      persona
+    } : {},
+    ...isRecord(forwarded.pageContext) ? {
+      pageContext: forwarded.pageContext
+    } : {}
+  };
+}
+__name(readForwardedProps, "readForwardedProps");
+function planResume(resume) {
+  const decisions = [];
+  const unrecognised = [];
+  for (const entry of resume) {
+    const address = decodeInterruptId(entry.interruptId);
+    if (address === null) {
+      unrecognised.push(entry.interruptId);
+      continue;
+    }
+    decisions.push({
+      address,
+      entry
+    });
+  }
+  const first = decisions[0];
+  if (first === void 0) return {
+    decisions,
+    unrecognised
+  };
+  for (const { address } of decisions) {
+    if (address.stream !== first.address.stream || address.position !== first.address.position) {
+      return "the resume entries answer interrupts of different runs";
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const { address } of decisions) {
+    if (seen.has(address.toolCallId)) return "an interrupt is answered twice";
+    seen.add(address.toolCallId);
+  }
+  return {
+    decisions,
+    unrecognised
+  };
+}
+__name(planResume, "planResume");
+function readApprovalPayload(payload) {
+  if (typeof payload === "boolean") return {
+    approved: payload
+  };
+  if (!isRecord(payload) || typeof payload.approved !== "boolean") return null;
+  return {
+    approved: payload.approved,
+    ...typeof payload.reason === "string" ? {
+      reason: payload.reason
+    } : {},
+    ...typeof payload.remember === "boolean" ? {
+      remember: payload.remember
+    } : {}
+  };
+}
+__name(readApprovalPayload, "readApprovalPayload");
+function readAnswersPayload(payload) {
+  const source = isRecord(payload) && isRecord(payload.answers) ? payload.answers : payload;
+  if (!isRecord(source)) return null;
+  const answers = {};
+  for (const [key, value] of Object.entries(source)) {
+    if (typeof value === "string") answers[key] = [
+      value
+    ];
+    else if (Array.isArray(value) && value.every((item) => typeof item === "string")) {
+      answers[key] = value;
+    } else return null;
+  }
+  return answers;
+}
+__name(readAnswersPayload, "readAnswersPayload");
+
+// src/spi/token-stream-sink.ts
+var AgentStreamError = class extends Error {
+  static {
+    __name(this, "AgentStreamError");
+  }
+  code;
+  constructor(error) {
+    super(error.message);
+    this.name = "AgentStreamError";
+    this.code = error.code;
+  }
+};
+
+// src/stream-events.ts
+var encoder = new TextEncoder();
+function decodeStreamEvent(line) {
+  try {
+    const parsed = JSON.parse(line);
+    if (typeof parsed === "object" && parsed !== null && typeof parsed.kind === "string") {
+      return parsed;
+    }
+  } catch {
+  }
+  return null;
+}
+__name(decodeStreamEvent, "decodeStreamEvent");
+
+// src/ag-ui/stream.ts
+var DEFAULT_QUIET_MS = 750;
+var GRACE_MS = 50;
+async function* agUiEvents(frames, options) {
+  const encoder2 = new AgUiEncoder(options);
+  const quietMs = options.quietMs ?? DEFAULT_QUIET_MS;
+  yield* encoder2.start();
+  yield* options.preamble ?? [];
+  const iterator = frames[Symbol.asyncIterator]();
+  let upcoming;
+  let ended = false;
+  try {
+    for (; ; ) {
+      upcoming ??= iterator.next();
+      const caughtUp = encoder2.consumed >= (options.skip ?? 0);
+      let next;
+      if (caughtUp && encoder2.waiting) {
+        next = await raceQuiet(upcoming, encoder2.busy ? quietMs : Math.min(quietMs, GRACE_MS));
+      } else {
+        next = await upcoming;
+      }
+      if (next === "quiet") break;
+      upcoming = void 0;
+      if (next.done === true) {
+        ended = true;
+        break;
+      }
+      yield* encoder2.encode(next.value);
+    }
+  } finally {
+    void iterator.return?.();
+  }
+  yield* encoder2.finish(ended);
+}
+__name(agUiEvents, "agUiEvents");
+function raceQuiet(upcoming, ms) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => resolve("quiet"), ms);
+    upcoming.then((result) => {
+      clearTimeout(timer);
+      resolve(result);
+    }, (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+  });
+}
+__name(raceQuiet, "raceQuiet");
+function agUiSse(event) {
+  return `data: ${JSON.stringify(event)}
+
+`;
+}
+__name(agUiSse, "agUiSse");
+async function* agUiFramesFromNdjson(chunks) {
+  const decoder = new TextDecoder();
+  let buffer = "";
+  const read = /* @__PURE__ */ __name((line) => {
+    const event = decodeStreamEvent(line);
+    if (event !== null) return [
+      event
+    ];
+    const at = line.indexOf('{"kind":');
+    const tail = at > 0 ? decodeStreamEvent(line.slice(at)) : null;
+    if (tail !== null) return [
+      {
+        kind: "text",
+        text: line.slice(0, at)
+      },
+      tail
+    ];
+    return [
+      {
+        kind: "text",
+        text: line
+      }
+    ];
+  }, "read");
+  try {
+    for await (const chunk of chunks) {
+      buffer += decoder.decode(chunk, {
+        stream: true
+      });
+      let newline = buffer.indexOf("\n");
+      while (newline !== -1) {
+        const line = buffer.slice(0, newline);
+        buffer = buffer.slice(newline + 1);
+        if (line.length > 0) yield* read(line);
+        newline = buffer.indexOf("\n");
+      }
+    }
+    buffer += decoder.decode();
+    if (buffer.length > 0) yield* read(buffer);
+  } catch (error) {
+    if (error instanceof AgentStreamError) {
+      yield {
+        kind: "error",
+        code: error.code,
+        message: error.message
+      };
+      return;
+    }
+    throw error;
+  }
+}
+__name(agUiFramesFromNdjson, "agUiFramesFromNdjson");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AG_UI_CUSTOM,
+  AG_UI_PROTOCOL_VERSION,
+  AgUiEncoder,
+  agUiEvents,
+  agUiFramesFromNdjson,
+  agUiSse,
+  decodeInterruptId,
+  encodeInterruptId,
+  parseRunInput,
+  planResume,
+  readAnswersPayload,
+  readApprovalPayload,
+  readContext,
+  readForwardedProps,
+  readUserTurn
+});
+//# sourceMappingURL=index.cjs.map