@anvia/client 1.0.0-rc.10

package/dist/index.js

@@ -0,0 +1,2522 @@
+import {
+  createFetchEventTransport
+} from "./chunk-2KGXQZWA.js";
+
+// src/adapters.ts
+import {
+  isJsonValue as isJsonValue3
+} from "@anvia/core/completion";
+
+// src/messages.ts
+import { isJsonValue } from "@anvia/core/completion";
+function uiMessagesToMessages(messages) {
+  const result = [];
+  for (const message of messages) {
+    assertMetadata(message.metadata);
+    if (message.role === "system") {
+      assertOnlyParts(message, ["text", "data", "error"]);
+      result.push({
+        role: "system",
+        content: textFromParts(message.parts),
+        ...metadataField(message.metadata)
+      });
+      continue;
+    }
+    if (message.role === "user") {
+      assertOnlyParts(message, ["text", "attachment", "data", "error"]);
+      const content2 = [];
+      for (const part of message.parts) {
+        if (part.type === "text") {
+          content2.push(textContent(part.text, part.signature));
+        } else if (part.type === "attachment") {
+          content2.push(attachmentToUserContent(part.attachment));
+        }
+      }
+      result.push({ role: "user", content: content2, ...metadataField(message.metadata) });
+      continue;
+    }
+    if (message.role === "assistant") {
+      assertOnlyParts(message, [
+        "text",
+        "reasoning",
+        "tool",
+        "attachment",
+        "source",
+        "data",
+        "error"
+      ]);
+      const content2 = [];
+      const toolResults = [];
+      for (const part of message.parts) {
+        if (part.type === "text") {
+          content2.push(textContent(part.text, part.signature));
+        } else if (part.type === "reasoning") {
+          let reasoning = {
+            type: "reasoning",
+            text: part.text
+          };
+          if (part.reasoningId !== void 0) reasoning = { ...reasoning, id: part.reasoningId };
+          if (part.content !== void 0) reasoning = { ...reasoning, details: part.content };
+          content2.push(reasoning);
+        } else if (part.type === "tool") {
+          assertReplayableToolPart(part);
+          let toolCall = {
+            type: "tool-call",
+            toolCallId: part.toolCallId,
+            toolName: part.toolName,
+            input: part.input
+          };
+          if (part.callId !== void 0) toolCall = { ...toolCall, callId: part.callId };
+          if (part.signature !== void 0) toolCall = { ...toolCall, signature: part.signature };
+          content2.push(toolCall);
+          if (part.state === "output-available" || part.state === "error") {
+            toolResults.push(toolResultFromPart(part));
+          }
+        } else if (part.type === "attachment") {
+          content2.push(attachmentToAssistantContent(part.attachment));
+        }
+      }
+      let assistant = {
+        role: "assistant",
+        content: content2,
+        ...metadataField(message.metadata)
+      };
+      if (message.modelMessageId !== void 0) {
+        assistant = { ...assistant, id: message.modelMessageId };
+      }
+      result.push(assistant);
+      if (toolResults.length > 0) {
+        result.push({ role: "tool", content: toolResults });
+      }
+      continue;
+    }
+    assertOnlyParts(message, ["tool", "data", "error"]);
+    const content = [];
+    for (const part of message.parts) {
+      if (part.type !== "tool") continue;
+      assertToolResultPart(part);
+      content.push(toolResultFromPart(part));
+    }
+    result.push({ role: "tool", content, ...metadataField(message.metadata) });
+  }
+  return result;
+}
+function messagesToUIMessages(messages) {
+  const result = [];
+  const byToolCallId = /* @__PURE__ */ new Map();
+  const byCallId = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    assertMetadata(message.metadata);
+    if (message.role === "system") {
+      result.push({
+        id: createId("msg"),
+        role: "system",
+        parts: [{ id: createId("part"), type: "text", text: message.content }],
+        ...metadataField(message.metadata)
+      });
+      continue;
+    }
+    if (message.role === "user") {
+      const content = typeof message.content === "string" ? [{ type: "text", text: message.content }] : message.content;
+      const parts = content.map((part) => contentToUIMessagePart(part));
+      result.push({
+        id: createId("msg"),
+        role: "user",
+        parts,
+        ...metadataField(message.metadata)
+      });
+      continue;
+    }
+    if (message.role === "assistant") {
+      const content = typeof message.content === "string" ? [{ type: "text", text: message.content }] : message.content;
+      const parts = content.map(assistantContentToUIMessagePart);
+      let uiMessage = {
+        id: createId("msg"),
+        role: "assistant",
+        parts,
+        ...metadataField(message.metadata)
+      };
+      if (message.id !== void 0) uiMessage = { ...uiMessage, modelMessageId: message.id };
+      const messageIndex = result.length;
+      result.push(uiMessage);
+      for (const [partIndex, part] of parts.entries()) {
+        if (part.type !== "tool") continue;
+        const location = { messageIndex, partIndex };
+        byToolCallId.set(part.toolCallId, location);
+        if (part.callId !== void 0) byCallId.set(part.callId, location);
+      }
+      continue;
+    }
+    const unmerged = [];
+    for (const content of message.content) {
+      if (content.type !== "tool-result") continue;
+      const location = (content.callId === void 0 ? void 0 : byCallId.get(content.callId)) ?? byToolCallId.get(content.toolCallId);
+      const ownerPart = toolPartAt(result, location);
+      if (ownerPart === void 0 || ownerPart.state === "input-streaming") {
+        throw new TypeError(
+          `Tool result "${content.toolCallId}" requires a matching completed tool call.`
+        );
+      }
+      const part = toolResultToUIMessagePart(content, ownerPart.toolName, ownerPart.input);
+      if (message.metadata === void 0 && location !== void 0) {
+        const owner = result[location.messageIndex];
+        const existing = owner?.parts[location.partIndex];
+        if (owner !== void 0 && existing?.type === "tool") {
+          const parts = [...owner.parts];
+          parts[location.partIndex] = { ...existing, ...part, id: existing.id };
+          result[location.messageIndex] = { ...owner, parts };
+          continue;
+        }
+      }
+      unmerged.push(part);
+    }
+    if (unmerged.length > 0 || message.metadata !== void 0) {
+      result.push({
+        id: createId("msg"),
+        role: "tool",
+        parts: unmerged,
+        ...metadataField(message.metadata)
+      });
+    }
+  }
+  return result;
+}
+function contentToUIMessagePart(content) {
+  if (content.type === "text") {
+    const part = {
+      id: createId("part"),
+      type: "text",
+      text: content.text
+    };
+    if (content.signature !== void 0) part.signature = content.signature;
+    return part;
+  }
+  return {
+    id: createId("part"),
+    type: "attachment",
+    attachment: contentToAttachment(content)
+  };
+}
+function assistantContentToUIMessagePart(content) {
+  if (content.type === "text") return contentToUIMessagePart(content);
+  if (content.type === "reasoning") {
+    const part = {
+      id: createId("part"),
+      type: "reasoning",
+      text: content.text
+    };
+    if (content.id !== void 0) part.reasoningId = content.id;
+    if (content.details !== void 0) part.content = content.details;
+    return part;
+  }
+  if (content.type === "tool-call") {
+    const part = {
+      id: toolPartId(content.toolCallId),
+      type: "tool",
+      toolName: content.toolName,
+      toolCallId: content.toolCallId,
+      state: "input-available",
+      input: content.input
+    };
+    if (content.callId !== void 0) part.callId = content.callId;
+    if (content.signature !== void 0) part.signature = content.signature;
+    return part;
+  }
+  return {
+    id: createId("part"),
+    type: "attachment",
+    attachment: contentToAttachment(content)
+  };
+}
+function textContent(text, signature) {
+  return signature === void 0 ? { type: "text", text } : { type: "text", text, signature };
+}
+function toolResultFromPart(part) {
+  let result = {
+    type: "tool-result",
+    toolCallId: part.toolCallId,
+    toolName: part.toolName,
+    output: toolOutputFromPart(part)
+  };
+  if (part.callId !== void 0) result = { ...result, callId: part.callId };
+  return result;
+}
+function toolOutputFromPart(part) {
+  if (part.state === "error") {
+    return { type: "error-text", value: part.error.message };
+  }
+  if (part.resultContent !== void 0) {
+    return { type: "content", value: part.resultContent };
+  }
+  const output = part.output;
+  return typeof output === "string" ? { type: "text", value: output } : { type: "json", value: output };
+}
+function attachmentToUserContent(attachment) {
+  if (attachment.type === "image" || attachment.mediaType?.startsWith("image/") === true) {
+    return attachmentToImageContent(attachment);
+  }
+  return attachmentToFileContent(attachment);
+}
+function attachmentToAssistantContent(attachment) {
+  return attachment.type === "image" || attachment.mediaType?.startsWith("image/") === true ? attachmentToImageContent(attachment) : attachmentToFileContent(attachment);
+}
+function attachmentToImageContent(attachment) {
+  const image = attachment.url !== void 0 ? { type: "url", url: attachment.url } : attachment.data !== void 0 ? { type: "data", data: attachment.data } : (() => {
+    throw new TypeError("Image attachments require a URL or base64 data.");
+  })();
+  let content = {
+    type: "image",
+    image
+  };
+  if (attachment.mediaType !== void 0) content = { ...content, mediaType: attachment.mediaType };
+  if (attachment.detail !== void 0) content = { ...content, detail: attachment.detail };
+  return content;
+}
+function attachmentToFileContent(attachment) {
+  const data = attachment.url !== void 0 ? { type: "url", url: attachment.url } : attachment.data !== void 0 ? { type: "data", data: attachment.data } : attachment.text !== void 0 ? { type: "text", text: attachment.text } : (() => {
+    throw new TypeError("File attachments require a URL, base64 data, or text.");
+  })();
+  let content = {
+    type: "file",
+    data,
+    mediaType: attachment.mediaType ?? "application/octet-stream"
+  };
+  if (attachment.name !== void 0) content = { ...content, filename: attachment.name };
+  return content;
+}
+function contentToAttachment(content) {
+  const attachment = {
+    id: createId("attachment"),
+    type: content.type === "image" ? "image" : "file"
+  };
+  if (content.type === "image") {
+    if (content.detail !== void 0) attachment.detail = content.detail;
+    if (content.mediaType !== void 0) attachment.mediaType = content.mediaType;
+    if (content.image.type === "url") attachment.url = content.image.url;
+    else attachment.data = content.image.data;
+    return attachment;
+  }
+  attachment.mediaType = content.mediaType;
+  if (content.filename !== void 0) attachment.name = content.filename;
+  if (content.data.type === "url") attachment.url = content.data.url;
+  else if (content.data.type === "data") attachment.data = content.data.data;
+  else attachment.text = content.data.text;
+  return attachment;
+}
+function toolResultToUIMessagePart(content, fallbackToolName, input) {
+  const output = content.output;
+  const common = {
+    id: toolPartId(content.toolCallId),
+    type: "tool",
+    toolName: content.toolName || fallbackToolName,
+    toolCallId: content.toolCallId,
+    input
+  };
+  if (content.callId !== void 0) Object.assign(common, { callId: content.callId });
+  if (output.type === "error-text" || output.type === "error-json") {
+    return {
+      ...common,
+      state: "error",
+      error: {
+        message: output.type === "error-text" ? output.value : JSON.stringify(output.value)
+      }
+    };
+  }
+  if (output.type === "execution-denied") {
+    return {
+      ...common,
+      state: "error",
+      error: { message: output.reason ?? "Tool execution was denied." }
+    };
+  }
+  const part = {
+    ...common,
+    state: "output-available",
+    output: toolResultOutput(output)
+  };
+  if (output.type === "content") part.resultContent = output.value;
+  return part;
+}
+function toolResultOutput(output) {
+  if (output.type === "text" || output.type === "error-text") return output.value;
+  if (output.type === "json" || output.type === "error-json") return output.value;
+  if (output.type === "execution-denied") return output.reason ?? "Tool execution was denied.";
+  return output.value.length === 1 && output.value[0]?.type === "text" ? output.value[0].text : output.value.map(
+    (part) => part.type === "text" ? { ...part } : { ...part, data: { ...part.data } }
+  );
+}
+function toolPartAt(messages, location) {
+  if (location === void 0) return void 0;
+  const part = messages[location.messageIndex]?.parts[location.partIndex];
+  return part?.type === "tool" ? part : void 0;
+}
+function assertReplayableToolPart(part) {
+  if (part.state === "input-streaming") {
+    throw new TypeError(
+      `Tool call "${part.toolCallId}" is still streaming and cannot be converted to a model message.`
+    );
+  }
+  if (!isJsonValue(part.input)) {
+    throw new TypeError(`Tool call "${part.toolCallId}" input must be a strict JSON value.`);
+  }
+}
+function assertToolResultPart(part) {
+  assertReplayableToolPart(part);
+  if (part.state === "input-available") {
+    throw new TypeError(
+      `Tool message part "${part.toolCallId}" requires an output or execution error.`
+    );
+  }
+}
+function textFromParts(parts) {
+  return parts.flatMap((part) => part.type === "text" ? [part.text] : []).join("");
+}
+function assertOnlyParts(message, allowed) {
+  for (const part of message.parts) {
+    if (!allowed.includes(part.type)) {
+      throw new TypeError(`${message.role} UI messages cannot contain ${part.type} parts.`);
+    }
+  }
+}
+function assertMetadata(metadata) {
+  if (metadata !== void 0 && (!isJsonValue(metadata) || Array.isArray(metadata))) {
+    throw new TypeError("Message metadata must be a strict JSON object.");
+  }
+}
+function metadataField(metadata) {
+  return metadata === void 0 ? {} : { metadata };
+}
+function toolPartId(toolCallId) {
+  return `tool_${toolCallId}`;
+}
+var nextId = 0;
+function createClientId(prefix) {
+  const random = globalThis.crypto?.randomUUID?.();
+  if (random !== void 0) return `${prefix}_${random}`;
+  nextId += 1;
+  return `${prefix}_${nextId.toString(36)}`;
+}
+function createId(prefix) {
+  return createClientId(prefix);
+}
+
+// src/protocol.ts
+import {
+  parseAgentInteractionRequest,
+  parseAgentInteractionResponse
+} from "@anvia/core/agent/interactions";
+import { isJsonValue as isJsonValue2, parseMessages } from "@anvia/core/completion";
+
+// src/types.ts
+var CLIENT_STREAM_PROTOCOL = "anvia.client.v3";
+
+// src/protocol.ts
+var ClientProtocolError = class extends Error {
+  constructor(message, value) {
+    super(message);
+    this.value = value;
+    this.name = "ClientProtocolError";
+  }
+  value;
+};
+function parseUIMessage(value, options = {}) {
+  const message = requireRecord(value, "UI message");
+  if (!isJsonValue2(message)) {
+    throw new ClientProtocolError("UI messages must be strict JSON values.", value);
+  }
+  requireOnlyKeys(
+    message,
+    ["id", "role", "parts", "modelMessageId", "metadata", "generation"],
+    "UI message"
+  );
+  if (typeof message.id !== "string") invalid("UI message.id", value);
+  requireOneOf(message.role, ["system", "user", "assistant", "tool"], "UI message.role", value);
+  if (!Array.isArray(message.parts)) invalid("UI message.parts", value);
+  const parts = message.parts.map((part) => parseUIMessagePart(part, options.dataSchemas, value));
+  if (message.modelMessageId !== void 0 && typeof message.modelMessageId !== "string") {
+    invalid("UI message.modelMessageId", value);
+  }
+  const metadata = message.metadata === void 0 ? void 0 : parseMetadata(message.metadata, options.metadataSchema, value);
+  if (message.generation !== void 0 && !isUIMessageGeneration(message.generation)) {
+    invalid("UI message.generation", value);
+  }
+  let parsed = {
+    id: message.id,
+    role: message.role,
+    parts
+  };
+  if (message.modelMessageId !== void 0) {
+    parsed = { ...parsed, modelMessageId: message.modelMessageId };
+  }
+  if (metadata !== void 0) parsed = { ...parsed, metadata };
+  if (message.generation !== void 0) {
+    parsed = { ...parsed, generation: message.generation };
+  }
+  return parsed;
+}
+function parseUIMessages(value, options = {}) {
+  if (!Array.isArray(value)) {
+    throw new ClientProtocolError("UI messages must be an array.", value);
+  }
+  return value.map((message) => parseUIMessage(message, options));
+}
+function parseClientStreamRequest(value) {
+  const input = requireRecord(value, "Client stream request");
+  requireOnlyKeys(
+    input,
+    ["type", "messages", "interactionId", "response", "metadata", "resume"],
+    "Client stream request"
+  );
+  requireOneOf(
+    input.type,
+    ["messages", "interaction_response"],
+    "Client stream request.type",
+    value
+  );
+  if (input.metadata !== void 0 && !isJsonObject(input.metadata)) {
+    throw new ClientProtocolError("Client stream request.metadata must be a JSON object.", value);
+  }
+  let request;
+  if (input.type === "messages") {
+    if (input.interactionId !== void 0 || input.response !== void 0) {
+      throw new ClientProtocolError(
+        "Messages requests cannot include interaction response fields.",
+        value
+      );
+    }
+    let messages;
+    try {
+      messages = parseMessages(input.messages);
+    } catch {
+      throw new ClientProtocolError("Client stream request.messages must be Message[].", value);
+    }
+    request = { type: "messages", messages };
+  } else {
+    if (input.messages !== void 0 || typeof input.interactionId !== "string") {
+      throw new ClientProtocolError(
+        "Interaction response requests require interactionId and cannot include messages.",
+        value
+      );
+    }
+    try {
+      request = {
+        type: "interaction_response",
+        interactionId: input.interactionId,
+        response: parseAgentInteractionResponse(input.response)
+      };
+    } catch {
+      throw new ClientProtocolError("Client interaction response is invalid.", value);
+    }
+  }
+  if (input.metadata !== void 0) request.metadata = input.metadata;
+  if (input.resume !== void 0) {
+    const resume = requireRecord(input.resume, "Client stream request.resume");
+    requireOnlyKeys(resume, ["streamId", "after"], "Client stream request.resume");
+    if (typeof resume.streamId !== "string" || !isEventId(resume.after)) {
+      throw new ClientProtocolError(
+        "Client stream resume cursor requires streamId and a nonnegative safe integer after.",
+        value
+      );
+    }
+    request.resume = { streamId: resume.streamId, after: resume.after };
+  }
+  return request;
+}
+function parseClientStreamEvent(value, options = {}) {
+  const event = requireRecord(value, "Client stream event");
+  if (!isJsonValue2(event)) {
+    throw new ClientProtocolError("Client stream events must be strict JSON values.", value);
+  }
+  if (typeof event.type !== "string" || typeof event.runId !== "string") {
+    throw new ClientProtocolError("Client stream events require type and runId.", value);
+  }
+  if (event.turn !== void 0 && !isPositiveEventId(event.turn)) {
+    throw new ClientProtocolError(
+      "Client stream event.turn must be a positive safe integer.",
+      value
+    );
+  }
+  if (event.scope !== void 0 && !isScope(event.scope)) {
+    throw new ClientProtocolError("Client stream event.scope is invalid.", value);
+  }
+  switch (event.type) {
+    case "run_start":
+      requireEventKeys(event, ["source", "metadata"]);
+      requireOneOf(event.source, ["completion", "agent"], "run_start.source", value);
+      break;
+    case "turn_start":
+      requireEventKeys(event, []);
+      if (!isPositiveEventId(event.turn)) invalid("turn_start.turn", value);
+      break;
+    case "generation_start":
+      requireEventKeys(event, ["model"]);
+      if (event.model !== void 0 && (!isRecord(event.model) || !hasOnlyKeys(event.model, ["provider", "modelId"]) || typeof event.model.provider !== "string" || typeof event.model.modelId !== "string")) {
+        invalid("generation_start.model", value);
+      }
+      break;
+    case "message_start":
+      requireEventKeys(event, ["messageId", "role", "metadata"]);
+      requireStrings(event, ["messageId"], value);
+      if (event.role !== "assistant") invalid("message_start.role", value);
+      break;
+    case "text_start":
+      requireEventKeys(event, ["messageId", "partId"]);
+      requireStrings(event, ["messageId", "partId"], value);
+      break;
+    case "text_delta":
+      requireEventKeys(event, ["messageId", "partId", "delta"]);
+      requireStrings(event, ["messageId", "partId", "delta"], value);
+      break;
+    case "reasoning_delta":
+      requireEventKeys(event, ["messageId", "partId", "delta", "contentType", "signature"]);
+      requireStrings(event, ["messageId", "partId", "delta"], value);
+      requireOptionalStrings(event, ["signature"], value);
+      if (event.contentType !== void 0 && !["text", "summary", "encrypted", "redacted"].includes(event.contentType)) {
+        invalid("reasoning_delta.contentType", value);
+      }
+      break;
+    case "text_end":
+      requireEventKeys(event, ["messageId", "partId", "text", "signature"]);
+      requireStrings(event, ["messageId", "partId"], value);
+      requireOptionalStrings(event, ["text", "signature"], value);
+      break;
+    case "reasoning_start":
+      requireEventKeys(event, ["messageId", "partId", "reasoningId"]);
+      requireStrings(event, ["messageId", "partId"], value);
+      requireOptionalStrings(event, ["reasoningId"], value);
+      break;
+    case "reasoning_end":
+      requireEventKeys(event, ["messageId", "partId", "text", "content"]);
+      requireStrings(event, ["messageId", "partId"], value);
+      requireOptionalStrings(event, ["text"], value);
+      if (event.content !== void 0 && (!Array.isArray(event.content) || !event.content.every(isReasoningContent))) {
+        invalid("reasoning_end.content", value);
+      }
+      break;
+    case "tool_call_start":
+      requireEventKeys(event, ["messageId", "partId", "toolCallId", "callId", "toolName"]);
+      requireStrings(event, ["messageId", "partId", "toolCallId"], value);
+      requireOptionalStrings(event, ["callId", "toolName"], value);
+      break;
+    case "tool_call_delta":
+      requireEventKeys(event, [
+        "messageId",
+        "partId",
+        "toolCallId",
+        "callId",
+        "toolName",
+        "delta",
+        "mode",
+        "signature"
+      ]);
+      requireStrings(event, ["messageId", "partId", "toolCallId", "delta"], value);
+      requireOptionalStrings(event, ["callId", "toolName"], value);
+      requireOptionalStrings(event, ["signature"], value);
+      requireOneOf(event.mode, ["append", "replace"], "tool_call_delta.mode", value);
+      break;
+    case "tool_call_end":
+      requireEventKeys(event, [
+        "messageId",
+        "partId",
+        "toolCallId",
+        "callId",
+        "toolName",
+        "input",
+        "signature"
+      ]);
+      requireStrings(event, ["messageId", "partId", "toolCallId", "toolName"], value);
+      requireOptionalStrings(event, ["callId", "signature"], value);
+      if (!isJsonValue2(event.input)) invalid("tool_call_end.input", value);
+      break;
+    case "tool_result":
+      requireEventKeys(event, [
+        "messageId",
+        "partId",
+        "toolCallId",
+        "callId",
+        "internalCallId",
+        "toolName",
+        "input",
+        "result"
+      ]);
+      requireStrings(event, ["messageId", "partId", "toolCallId", "toolName"], value);
+      requireOptionalStrings(event, ["callId", "internalCallId"], value);
+      if (!isJsonValue2(event.input)) invalid("tool_result.input", value);
+      if (!isRecord(event.result)) invalid("tool_result.result", value);
+      if (event.result.status === "success") {
+        if (!hasOnlyKeys(event.result, ["status", "output", "content"]) || !isJsonValue2(event.result.output) || event.result.content !== void 0 && (!Array.isArray(event.result.content) || !event.result.content.every(isToolResultContent))) {
+          invalid("tool_result.result", value);
+        }
+      } else if (event.result.status === "error") {
+        if (!hasOnlyKeys(event.result, ["status", "error"]) || !isClientStreamError(event.result.error)) {
+          invalid("tool_result.result", value);
+        }
+      } else {
+        invalid("tool_result.result.status", value);
+      }
+      break;
+    case "source":
+      requireEventKeys(event, ["messageId", "partId", "source"]);
+      requireStrings(event, ["messageId", "partId"], value);
+      if (!isCompletionSource(event.source)) invalid("source.source", value);
+      break;
+    case "attachment":
+      requireEventKeys(event, ["messageId", "partId", "attachment"]);
+      requireStrings(event, ["messageId", "partId"], value);
+      if (!isAttachment(event.attachment)) invalid("attachment.attachment", value);
+      break;
+    case "provider_tool_call":
+      requireEventKeys(event, ["toolCall"]);
+      if (!isProviderToolCall(event.toolCall)) invalid("provider_tool_call.toolCall", value);
+      break;
+    case "interaction":
+      requireEventKeys(event, ["interaction"]);
+      try {
+        parseAgentInteractionRequest(event.interaction);
+      } catch {
+        invalid("interaction.interaction", value);
+      }
+      break;
+    case "guardrail_decision":
+      requireEventKeys(event, ["decision"]);
+      if (!isGuardrailDecision(event.decision)) invalid("guardrail_decision.decision", value);
+      break;
+    case "data":
+      requireEventKeys(event, ["name", "data", "transient"]);
+      requireStrings(event, ["name"], value);
+      if (!isJsonValue2(event.data)) invalid("data.data", value);
+      if (event.transient !== void 0 && typeof event.transient !== "boolean") {
+        invalid("data.transient", value);
+      }
+      return {
+        ...event,
+        data: parseDataEvent(event.name, event.data, options.dataSchemas, value)
+      };
+    case "message_end":
+      requireEventKeys(event, [
+        "messageId",
+        "modelMessageId",
+        "parts",
+        "usage",
+        "contextUsage",
+        "metadata"
+      ]);
+      requireStrings(event, ["messageId"], value);
+      requireOptionalStrings(event, ["modelMessageId"], value);
+      if (event.parts !== void 0) {
+        if (!Array.isArray(event.parts)) invalid("message_end.parts", value);
+        const parts = event.parts.map(
+          (part) => parseUIMessagePart(part, options.dataSchemas, value)
+        );
+        validateUsageAndContext(event, value);
+        return parseEventMetadata(
+          { ...event, parts },
+          options.metadataSchema,
+          value
+        );
+      }
+      validateUsageAndContext(event, value);
+      break;
+    case "turn_end":
+      requireEventKeys(event, ["usage", "contextUsage", "firstDeltaMs"]);
+      if (!isPositiveEventId(event.turn)) invalid("turn_end.turn", value);
+      if (event.firstDeltaMs !== void 0 && !isNonnegativeNumber(event.firstDeltaMs)) {
+        invalid("turn_end.firstDeltaMs", value);
+      }
+      validateUsageAndContext(event, value);
+      break;
+    case "memory_compaction":
+      requireEventKeys(event, [
+        "originalMessageCount",
+        "compactedMessageCount",
+        "retainedMessageCount",
+        "attempts",
+        "usage"
+      ]);
+      validateMemoryCompactionInfo(event, value);
+      break;
+    case "run_end":
+      requireEventKeys(event, [
+        "status",
+        "text",
+        "output",
+        "usage",
+        "contextUsage",
+        "trace",
+        "memoryCompaction",
+        "metadata"
+      ]);
+      requireOneOf(
+        event.status,
+        ["completed", "blocked", "suspended", "cancelled", "error"],
+        "run_end.status",
+        value
+      );
+      requireOptionalStrings(event, ["text"], value);
+      validateUsageAndContext(event, value);
+      if (event.trace !== void 0 && !isTrace(event.trace)) invalid("run_end.trace", value);
+      if (event.memoryCompaction !== void 0) {
+        if (!isRecord(event.memoryCompaction)) invalid("run_end.memoryCompaction", value);
+        requireOnlyKeys(
+          event.memoryCompaction,
+          [
+            "originalMessageCount",
+            "compactedMessageCount",
+            "retainedMessageCount",
+            "attempts",
+            "usage"
+          ],
+          "run_end.memoryCompaction"
+        );
+        validateMemoryCompactionInfo(event.memoryCompaction, value);
+      }
+      break;
+    case "error":
+      requireEventKeys(event, ["error", "usage"]);
+      if (!isClientStreamError(event.error)) invalid("error.error", value);
+      if (event.usage !== void 0 && !isUsage(event.usage)) invalid("error.usage", value);
+      break;
+    default:
+      throw new ClientProtocolError(`Unknown client stream event type "${event.type}".`, value);
+  }
+  return parseEventMetadata(event, options.metadataSchema, value);
+}
+function parseClientStreamFrame(value, options = {}) {
+  const frame = requireRecord(value, "Client stream frame");
+  if (!isJsonValue2(frame)) {
+    throw new ClientProtocolError("Client stream frames must be strict JSON values.", value);
+  }
+  if (typeof frame.type !== "string") {
+    throw new ClientProtocolError("Client stream frames require type.", value);
+  }
+  if (frame.type === "stream_start") {
+    requireOnlyKeys(
+      frame,
+      ["type", "protocol", "streamId", "eventId", "resumable"],
+      "stream_start frame"
+    );
+    if (frame.protocol === "anvia.client.v1" || frame.protocol === "anvia.client.v2") {
+      throw new ClientProtocolError(
+        `Client stream protocol ${frame.protocol.slice(-2)} is not supported.`,
+        value
+      );
+    }
+    if (frame.protocol !== CLIENT_STREAM_PROTOCOL || typeof frame.streamId !== "string" || frame.eventId !== 0 || typeof frame.resumable !== "boolean") {
+      throw new ClientProtocolError("Invalid client stream_start frame.", value);
+    }
+    return frame;
+  }
+  if (frame.type === "stream_event") {
+    requireOnlyKeys(frame, ["type", "streamId", "eventId", "event"], "stream_event frame");
+    if (typeof frame.streamId !== "string" || !isPositiveEventId(frame.eventId)) {
+      throw new ClientProtocolError("Invalid client stream_event frame.", value);
+    }
+    const event = parseClientStreamEvent(frame.event, options);
+    return { ...frame, event };
+  }
+  if (frame.type === "stream_end") {
+    requireOnlyKeys(frame, ["type", "streamId", "eventId", "status"], "stream_end frame");
+    if (typeof frame.streamId !== "string" || !isEventId(frame.eventId)) {
+      throw new ClientProtocolError("Invalid client stream_end frame.", value);
+    }
+    requireOneOf(frame.status, ["completed", "error", "missing"], "stream_end.status", value);
+    return frame;
+  }
+  throw new ClientProtocolError(`Unknown client stream frame type "${frame.type}".`, value);
+}
+function maskedClientError() {
+  return { message: "An unexpected error occurred." };
+}
+function normalizeClientError(value) {
+  if (value instanceof Error) return value;
+  if (isClientStreamError(value)) {
+    const error = new Error(value.message);
+    if (value.name !== void 0) error.name = value.name;
+    return error;
+  }
+  return new Error(typeof value === "string" ? value : "An unexpected error occurred.");
+}
+function parseDataEvent(name, data, schemas, value) {
+  if (schemas === void 0) return data;
+  const schema = schemas[name];
+  if (schema === void 0) {
+    throw new ClientProtocolError(`Invalid data event "${name}".`, value);
+  }
+  const parsed = schema.safeParse(data);
+  if (parsed.success !== true || !isJsonValue2(parsed.data)) {
+    throw new ClientProtocolError(`Invalid data event "${name}".`, value);
+  }
+  return parsed.data;
+}
+function parseUIMessagePart(value, schemas, root) {
+  if (!isUIMessagePart(value)) {
+    throw new ClientProtocolError("UI message contains an invalid part.", root);
+  }
+  if (value.type !== "data") {
+    return value;
+  }
+  return {
+    ...value,
+    data: parseDataEvent(value.name, value.data, schemas, root)
+  };
+}
+function parseMetadata(value, schema, root) {
+  if (schema === void 0) {
+    if (!isJsonObject(value)) {
+      throw new ClientProtocolError("Client metadata must be a JSON object.", root);
+    }
+    return value;
+  }
+  const parsed = schema.safeParse(value);
+  if (parsed.success !== true || !isJsonObject(parsed.data)) {
+    throw new ClientProtocolError("Invalid client metadata.", root);
+  }
+  return parsed.data;
+}
+function parseEventMetadata(event, schema, root) {
+  if (event.metadata === void 0) return event;
+  return { ...event, metadata: parseMetadata(event.metadata, schema, root) };
+}
+function isUIMessageGeneration(value) {
+  if (!isRecord(value)) return false;
+  if (!hasOnlyKeys(value, ["runId", "status", "usage", "contextUsage", "trace", "memoryCompaction"])) {
+    return false;
+  }
+  return (value.runId === void 0 || typeof value.runId === "string") && (value.status === void 0 || ["completed", "blocked", "suspended", "cancelled", "error"].includes(
+    value.status
+  )) && (value.usage === void 0 || isUsage(value.usage)) && (value.contextUsage === void 0 || isContextUsage(value.contextUsage)) && (value.trace === void 0 || isTrace(value.trace)) && (value.memoryCompaction === void 0 || isRecord(value.memoryCompaction) && validateMemoryCompactionForGuard(value.memoryCompaction));
+}
+function validateMemoryCompactionForGuard(value) {
+  try {
+    requireOnlyKeys(
+      value,
+      [
+        "originalMessageCount",
+        "compactedMessageCount",
+        "retainedMessageCount",
+        "attempts",
+        "usage"
+      ],
+      "memory compaction"
+    );
+    validateMemoryCompactionInfo(value, value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isJsonObject(value) {
+  return isRecord(value) && isJsonValue2(value);
+}
+function isClientStreamError(value) {
+  return isRecord(value) && hasOnlyKeys(value, ["name", "message", "code", "retryable", "details"]) && typeof value.message === "string" && (value.name === void 0 || typeof value.name === "string") && (value.code === void 0 || typeof value.code === "string") && (value.retryable === void 0 || typeof value.retryable === "boolean") && (value.details === void 0 || isJsonValue2(value.details));
+}
+function isScope(value) {
+  if (!isRecord(value)) return false;
+  const keys = [
+    "agentId",
+    "agentName",
+    "parentRunId",
+    "parentToolName",
+    "parentToolCallId",
+    "parentInternalToolCallId"
+  ];
+  return hasOnlyKeys(value, keys) && keys.every((key) => value[key] === void 0 || typeof value[key] === "string");
+}
+function isAttachment(value) {
+  if (!isRecord(value) || typeof value.id !== "string") return false;
+  if (value.type !== "image" && value.type !== "document" && value.type !== "file") return false;
+  return hasOnlyKeys(value, [
+    "id",
+    "type",
+    "name",
+    "mediaType",
+    "url",
+    "data",
+    "text",
+    "detail",
+    "metadata"
+  ]) && (value.name === void 0 || typeof value.name === "string") && (value.mediaType === void 0 || typeof value.mediaType === "string") && (value.url === void 0 || typeof value.url === "string") && (value.data === void 0 || typeof value.data === "string") && (value.text === void 0 || typeof value.text === "string") && (value.detail === void 0 || ["auto", "low", "high"].includes(value.detail)) && (value.metadata === void 0 || isJsonValue2(value.metadata));
+}
+function isUIMessagePart(value) {
+  if (!isRecord(value) || typeof value.id !== "string" || typeof value.type !== "string") {
+    return false;
+  }
+  if (value.type === "text") {
+    return hasOnlyKeys(value, ["id", "type", "text", "signature"]) && typeof value.text === "string" && (value.signature === void 0 || typeof value.signature === "string");
+  }
+  if (value.type === "reasoning") {
+    return hasOnlyKeys(value, ["id", "type", "text", "reasoningId", "content"]) && typeof value.text === "string" && (value.reasoningId === void 0 || typeof value.reasoningId === "string") && (value.content === void 0 || Array.isArray(value.content) && value.content.every(isReasoningContent));
+  }
+  if (value.type === "source") {
+    return hasOnlyKeys(value, ["id", "type", "source"]) && isCompletionSource(value.source);
+  }
+  if (value.type === "data") {
+    return hasOnlyKeys(value, ["id", "type", "name", "data"]) && typeof value.name === "string" && isJsonValue2(value.data);
+  }
+  if (value.type === "attachment") {
+    return hasOnlyKeys(value, ["id", "type", "attachment"]) && isAttachment(value.attachment);
+  }
+  if (value.type === "error") {
+    return hasOnlyKeys(value, ["id", "type", "error"]) && isClientStreamError(value.error);
+  }
+  if (value.type !== "tool" || !hasOnlyKeys(value, [
+    "id",
+    "type",
+    "toolName",
+    "toolCallId",
+    "callId",
+    "internalCallId",
+    "turn",
+    "state",
+    "input",
+    "output",
+    "resultContent",
+    "signature",
+    "error"
+  ]) || typeof value.toolName !== "string" || typeof value.toolCallId !== "string" || value.callId !== void 0 && typeof value.callId !== "string" || value.internalCallId !== void 0 && typeof value.internalCallId !== "string" || value.turn !== void 0 && !isPositiveEventId(value.turn) || value.signature !== void 0 && typeof value.signature !== "string") {
+    return false;
+  }
+  if (value.state === "input-streaming") {
+    return typeof value.input === "string" && value.output === void 0 && value.resultContent === void 0 && value.error === void 0;
+  }
+  if (value.state === "input-available") {
+    return isJsonValue2(value.input) && value.output === void 0 && value.resultContent === void 0 && value.error === void 0;
+  }
+  if (value.state === "output-available") {
+    return isJsonValue2(value.input) && isJsonValue2(value.output) && (value.resultContent === void 0 || Array.isArray(value.resultContent) && value.resultContent.every(isToolResultContent)) && value.error === void 0;
+  }
+  return value.state === "error" && isJsonValue2(value.input) && value.output === void 0 && value.resultContent === void 0 && isClientStreamError(value.error);
+}
+function isReasoningContent(value) {
+  if (!isRecord(value) || typeof value.type !== "string") return false;
+  if (value.type === "text") {
+    return hasOnlyKeys(value, ["type", "text", "signature"]) && typeof value.text === "string" && (value.signature === void 0 || typeof value.signature === "string");
+  }
+  if (value.type === "summary") {
+    return hasOnlyKeys(value, ["type", "text"]) && typeof value.text === "string";
+  }
+  if (value.type === "encrypted" || value.type === "redacted") {
+    return hasOnlyKeys(value, ["type", "data"]) && typeof value.data === "string";
+  }
+  return false;
+}
+function isToolResultContent(value) {
+  if (!isRecord(value)) return false;
+  if (value.type === "text") {
+    return hasOnlyKeys(value, ["type", "text", "signature"]) && typeof value.text === "string" && (value.signature === void 0 || typeof value.signature === "string");
+  }
+  return value.type === "file" && hasOnlyKeys(value, ["type", "data", "mediaType", "filename"]) && isFileData(value.data) && typeof value.mediaType === "string" && (value.filename === void 0 || typeof value.filename === "string");
+}
+function isFileData(value) {
+  if (!isRecord(value)) return false;
+  if (value.type === "url") {
+    return hasOnlyKeys(value, ["type", "url"]) && typeof value.url === "string";
+  }
+  if (value.type === "data") {
+    return hasOnlyKeys(value, ["type", "data"]) && typeof value.data === "string";
+  }
+  return value.type === "text" && hasOnlyKeys(value, ["type", "text"]) && typeof value.text === "string";
+}
+function isCompletionSource(value) {
+  return isRecord(value) && value.type === "url" && hasOnlyKeys(value, ["type", "url", "title", "id", "startIndex", "endIndex"]) && typeof value.url === "string" && (value.title === void 0 || typeof value.title === "string") && (value.id === void 0 || typeof value.id === "string") && (value.startIndex === void 0 || isNonnegativeNumber(value.startIndex)) && (value.endIndex === void 0 || isNonnegativeNumber(value.endIndex));
+}
+function isProviderToolCall(value) {
+  return isRecord(value) && hasOnlyKeys(value, ["id", "name", "status", "details"]) && typeof value.id === "string" && typeof value.name === "string" && (value.status === void 0 || typeof value.status === "string") && (value.details === void 0 || isRecord(value.details) && isJsonValue2(value.details));
+}
+function isGuardrailDecision(value) {
+  return isRecord(value) && hasOnlyKeys(value, [
+    "policyId",
+    "guardrailId",
+    "boundary",
+    "mode",
+    "action",
+    "applied",
+    "reason",
+    "message",
+    "metadata",
+    "latencyMs"
+  ]) && typeof value.policyId === "string" && typeof value.guardrailId === "string" && (value.boundary === "input" || value.boundary === "output") && (value.mode === "enforce" || value.mode === "observe") && typeof value.action === "string" && ["allow", "block", "rewrite", "error"].includes(value.action) && typeof value.applied === "boolean" && (value.reason === void 0 || typeof value.reason === "string") && (value.message === void 0 || typeof value.message === "string") && (value.metadata === void 0 || isRecord(value.metadata) && isJsonValue2(value.metadata)) && isNonnegativeNumber(value.latencyMs);
+}
+function isUsage(value) {
+  if (!isRecord(value) || !hasOnlyKeys(value, [
+    "inputTokens",
+    "outputTokens",
+    "totalTokens",
+    "cachedInputTokens",
+    "cacheCreationInputTokens",
+    "details"
+  ]) || ![
+    value.inputTokens,
+    value.outputTokens,
+    value.totalTokens,
+    value.cachedInputTokens,
+    value.cacheCreationInputTokens
+  ].every(isNonnegativeNumber)) {
+    return false;
+  }
+  return value.details === void 0 || isRecord(value.details) && Object.values(value.details).every(isNonnegativeNumber);
+}
+function isContextUsage(value) {
+  if (!isRecord(value) || !isRecord(value.model) || !isRecord(value.model.context)) return false;
+  const context = value.model.context;
+  return hasOnlyKeys(value, [
+    "model",
+    "usedTokens",
+    "remainingTokens",
+    "usedPercent",
+    "remainingPercent"
+  ]) && hasOnlyKeys(value.model, ["modelId", "context"]) && typeof value.model.modelId === "string" && hasOnlyKeys(context, ["contextWindow", "maxInputTokens", "maxOutputTokens"]) && isNonnegativeNumber(context.contextWindow) && (context.maxInputTokens === void 0 || isNonnegativeNumber(context.maxInputTokens)) && (context.maxOutputTokens === void 0 || isNonnegativeNumber(context.maxOutputTokens)) && isNonnegativeNumber(value.usedTokens) && isNonnegativeNumber(value.remainingTokens) && isNonnegativeNumber(value.usedPercent) && isNonnegativeNumber(value.remainingPercent);
+}
+function validateUsageAndContext(event, original) {
+  if (event.usage !== void 0 && !isUsage(event.usage)) {
+    invalid(`${String(event.type)}.usage`, original);
+  }
+  if (event.contextUsage !== void 0 && !isContextUsage(event.contextUsage)) {
+    invalid(`${String(event.type)}.contextUsage`, original);
+  }
+}
+function validateMemoryCompactionInfo(value, original) {
+  for (const field of ["originalMessageCount", "compactedMessageCount", "retainedMessageCount"]) {
+    if (!isEventId(value[field])) invalid(`memory_compaction.${field}`, original);
+  }
+  if (!isPositiveEventId(value.attempts)) invalid("memory_compaction.attempts", original);
+  if (!isUsage(value.usage)) invalid("memory_compaction.usage", original);
+}
+function isTrace(value) {
+  return isRecord(value) && hasOnlyKeys(value, ["observer", "traceId", "observationId"]) && typeof value.observer === "string" && value.observer.trim().length > 0 && (value.traceId === void 0 || typeof value.traceId === "string") && (value.observationId === void 0 || typeof value.observationId === "string");
+}
+function requireRecord(value, label) {
+  if (!isRecord(value)) throw new ClientProtocolError(`${label} must be an object.`, value);
+  return value;
+}
+function requireOnlyKeys(value, keys, label) {
+  for (const key of Object.keys(value)) {
+    if (!keys.includes(key)) throw new ClientProtocolError(`${label} has unknown field "${key}".`);
+  }
+}
+function requireEventKeys(value, keys) {
+  requireOnlyKeys(
+    value,
+    ["type", "runId", "turn", "scope", ...keys],
+    `${String(value.type)} event`
+  );
+}
+function requireStrings(value, keys, original) {
+  for (const key of keys) {
+    if (typeof value[key] !== "string") invalid(`${String(value.type)}.${key}`, original);
+  }
+}
+function requireOptionalStrings(value, keys, original) {
+  for (const key of keys) {
+    if (value[key] !== void 0 && typeof value[key] !== "string") {
+      invalid(`${String(value.type)}.${key}`, original);
+    }
+  }
+}
+function requireOneOf(value, allowed, label, original) {
+  if (typeof value !== "string" || !allowed.includes(value)) invalid(label, original);
+}
+function invalid(label, value) {
+  throw new ClientProtocolError(`Invalid ${label}.`, value);
+}
+function isEventId(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function isPositiveEventId(value) {
+  return isEventId(value) && value > 0;
+}
+function isNonnegativeNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function hasOnlyKeys(value, keys) {
+  return Object.keys(value).every((key) => keys.includes(key));
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/adapters.ts
+function completionToClientStream(options) {
+  const { events } = options;
+  const runId = options.runId ?? createClientId("run");
+  return propagateCancellation(events, (source) => ({
+    async *[Symbol.asyncIterator]() {
+      const state = createMessageState({ runId });
+      const runStart = {
+        type: "run_start",
+        source: "completion"
+      };
+      if (options.metadata !== void 0) runStart.metadata = options.metadata;
+      yield clientEvent(state, runStart);
+      if (options.model !== void 0) {
+        yield clientEvent(state, { type: "generation_start", model: options.model });
+      }
+      yield* startMessage(state);
+      let terminal = false;
+      try {
+        for await (const event of source) {
+          if (terminal) break;
+          switch (event.type) {
+            case "text_delta":
+              yield* appendText(state, event.delta);
+              break;
+            case "reasoning_delta":
+              yield* appendReasoning(state, event);
+              break;
+            case "tool_call_delta":
+              yield* appendToolCall(state, event);
+              break;
+            case "tool_call":
+              yield* finishToolCall(state, event.toolCall);
+              break;
+            case "source":
+              yield* emitSource(state, event.source);
+              break;
+            case "provider_tool_call":
+              yield* emitProviderToolCall(state, event.toolCall);
+              break;
+            case "message_id":
+              state.modelMessageId = event.id;
+              break;
+            case "final": {
+              const result = event.result;
+              if (result.messageId !== void 0) state.modelMessageId = result.messageId;
+              const finalMetadata = {
+                usage: result.usage
+              };
+              if (result.contextUsage !== void 0) {
+                finalMetadata.contextUsage = result.contextUsage;
+              }
+              if (result.sources !== void 0) finalMetadata.sources = result.sources;
+              if (result.providerToolCalls !== void 0) {
+                finalMetadata.providerToolCalls = result.providerToolCalls;
+              }
+              yield* finishMessage(state, result.content, finalMetadata);
+              const output = clientOutput(result.output, options.mapOutput);
+              const runEnd = {
+                type: "run_end",
+                status: "completed",
+                text: result.text,
+                usage: result.usage
+              };
+              if (output !== void 0) runEnd.output = output;
+              if (result.contextUsage !== void 0) runEnd.contextUsage = result.contextUsage;
+              yield clientEvent(state, runEnd);
+              terminal = true;
+              break;
+            }
+            case "error":
+              yield* finishErroredRun(state, event.error, event.usage, options.mapError);
+              terminal = true;
+              break;
+          }
+        }
+        if (!terminal) {
+          yield* finishErroredRun(
+            state,
+            new Error("Completion stream ended without a terminal event."),
+            void 0,
+            options.mapError
+          );
+        }
+      } catch (error) {
+        if (!terminal) yield* finishErroredRun(state, error, void 0, options.mapError);
+      }
+    }
+  }));
+}
+function agentToClientStream(options) {
+  const { events } = options;
+  const runId = options.runId ?? createClientId("run");
+  return propagateCancellation(events, (source) => ({
+    async *[Symbol.asyncIterator]() {
+      const runtime = {
+        runId,
+        options,
+        messages: /* @__PURE__ */ new Map(),
+        startedScopes: /* @__PURE__ */ new Set(["root"])
+      };
+      const runStart = {
+        type: "run_start",
+        source: "agent"
+      };
+      if (options.metadata !== void 0) runStart.metadata = options.metadata;
+      yield rootEvent(runId, runStart);
+      let terminal = false;
+      try {
+        for await (const event of source) {
+          if (terminal) break;
+          yield* translateAgentEvent(runtime, event, void 0);
+          terminal = isRootTerminalAgentEvent(event);
+        }
+        if (!terminal) {
+          const error = mapClientError(
+            new Error("Agent stream ended without a terminal event."),
+            options.mapError
+          );
+          yield rootEvent(runId, { type: "error", error });
+          yield rootEvent(runId, { type: "run_end", status: "error" });
+        }
+      } catch (error) {
+        if (!terminal) {
+          yield rootEvent(runId, {
+            type: "error",
+            error: mapClientError(error, options.mapError)
+          });
+          yield rootEvent(runId, { type: "run_end", status: "error" });
+        }
+      }
+    }
+  }));
+}
+function customAgentEventsToClientStream(options) {
+  return agentToClientStream(
+    options
+  );
+}
+async function* translateAgentEvent(runtime, event, scope) {
+  if (event.type === "agent_tool_event") {
+    const childScope = {
+      agentId: event.agentId,
+      parentRunId: runtime.runId,
+      parentToolName: event.toolName,
+      parentToolCallId: event.toolCallId ?? event.internalCallId,
+      parentInternalToolCallId: event.internalCallId
+    };
+    if (event.agentName !== void 0) childScope.agentName = event.agentName;
+    const key = scopeKey(childScope);
+    if (!runtime.startedScopes.has(key)) {
+      runtime.startedScopes.add(key);
+      yield rootEvent(runtime.runId, { type: "run_start", source: "agent" }, childScope);
+    }
+    yield* translateAgentEvent(runtime, event.event, childScope);
+    return;
+  }
+  const turn = "turn" in event && typeof event.turn === "number" ? event.turn : void 0;
+  switch (event.type) {
+    case "memory_compaction":
+      yield scopedEvent(runtime.runId, turn, scope, {
+        type: "memory_compaction",
+        originalMessageCount: event.originalMessageCount,
+        compactedMessageCount: event.compactedMessageCount,
+        retainedMessageCount: event.retainedMessageCount,
+        attempts: event.attempts,
+        usage: event.usage
+      });
+      return;
+    case "turn_start":
+      yield scopedEvent(runtime.runId, turn, scope, { type: "turn_start" });
+      return;
+    case "generation_start": {
+      const state = getAgentMessage(runtime, event.turn, scope);
+      yield scopedEvent(runtime.runId, event.turn, scope, {
+        type: "generation_start",
+        model: {
+          provider: event.modelInfo.provider,
+          modelId: event.modelInfo.modelId
+        }
+      });
+      yield* startMessage(state);
+      return;
+    }
+    case "text_delta": {
+      const state = getAgentMessage(runtime, event.turn, scope);
+      yield* startMessage(state);
+      yield* appendText(state, event.delta);
+      return;
+    }
+    case "reasoning_delta": {
+      const state = getAgentMessage(runtime, event.turn, scope);
+      yield* startMessage(state);
+      yield* appendReasoning(state, event);
+      return;
+    }
+    case "tool_call_delta": {
+      const state = getAgentMessage(runtime, event.turn, scope);
+      yield* startMessage(state);
+      yield* appendToolCall(state, event);
+      return;
+    }
+    case "tool_call": {
+      const state = getAgentMessage(runtime, event.turn, scope);
+      yield* startMessage(state);
+      yield* finishToolCall(state, event.toolCall);
+      return;
+    }
+    case "source": {
+      const state = getAgentMessage(runtime, event.turn, scope);
+      yield* startMessage(state);
+      yield* emitSource(state, event.source);
+      return;
+    }
+    case "provider_tool_call": {
+      const state = getAgentMessage(runtime, event.turn, scope);
+      yield* emitProviderToolCall(state, event.toolCall);
+      return;
+    }
+    case "tool_result": {
+      const state = getAgentMessage(runtime, event.turn, scope);
+      yield* startMessage(state);
+      const tool = getToolResultState(
+        state,
+        event.toolName,
+        event.toolCallId,
+        event.callId,
+        event.internalCallId
+      );
+      tool.result = clientToolResult(event.output, event.result);
+      const resultEvent = {
+        type: "tool_result",
+        messageId: state.messageId,
+        partId: tool.partId,
+        toolCallId: tool.toolCallId,
+        internalCallId: event.internalCallId,
+        toolName: event.toolName,
+        input: parseJsonOrString(event.args),
+        result: tool.result
+      };
+      if (tool.callId !== void 0) resultEvent.callId = tool.callId;
+      yield clientEvent(state, resultEvent);
+      return;
+    }
+    case "turn_end": {
+      const state = getAgentMessage(runtime, event.turn, scope);
+      yield* startMessage(state);
+      if (event.response.messageId !== void 0) state.modelMessageId = event.response.messageId;
+      const finalMetadata = {
+        usage: event.response.usage
+      };
+      if (event.response.contextUsage !== void 0) {
+        finalMetadata.contextUsage = event.response.contextUsage;
+      }
+      if (event.response.sources !== void 0) finalMetadata.sources = event.response.sources;
+      if (event.response.providerToolCalls !== void 0) {
+        finalMetadata.providerToolCalls = event.response.providerToolCalls;
+      }
+      yield* finishMessage(state, event.response.choice, finalMetadata);
+      const turnEnd = {
+        type: "turn_end",
+        usage: event.response.usage
+      };
+      if (event.response.contextUsage !== void 0) {
+        turnEnd.contextUsage = event.response.contextUsage;
+      }
+      if (event.firstDeltaMs !== void 0) turnEnd.firstDeltaMs = event.firstDeltaMs;
+      yield scopedEvent(runtime.runId, event.turn, scope, turnEnd);
+      return;
+    }
+    case "guardrail_decision":
+      yield scopedEvent(runtime.runId, event.turn, scope, {
+        type: "guardrail_decision",
+        decision: event.decision
+      });
+      return;
+    case "final": {
+      const result = event.result;
+      if (result.status === "suspended" && scope === void 0) {
+        yield scopedEvent(runtime.runId, turn, scope, {
+          type: "interaction",
+          interaction: result.interaction
+        });
+      }
+      const output = result.status === "completed" ? clientOutput(result.output, runtime.options.mapOutput) : void 0;
+      const runEnd = {
+        type: "run_end",
+        status: result.status,
+        text: result.text,
+        usage: result.usage
+      };
+      if (output !== void 0) runEnd.output = output;
+      if (result.contextUsage !== void 0) runEnd.contextUsage = result.contextUsage;
+      if (result.trace !== void 0) runEnd.trace = clientTrace(result.trace);
+      if (result.memoryCompaction !== void 0) {
+        runEnd.memoryCompaction = result.memoryCompaction;
+      }
+      if (runtime.options.metadata !== void 0) runEnd.metadata = runtime.options.metadata;
+      yield scopedEvent(runtime.runId, turn, scope, runEnd);
+      return;
+    }
+    case "error": {
+      const error = mapClientError(event.error, runtime.options.mapError);
+      yield scopedEvent(runtime.runId, turn, scope, { type: "error", error, usage: event.usage });
+      yield scopedEvent(runtime.runId, turn, scope, {
+        type: "run_end",
+        status: "error",
+        usage: event.usage
+      });
+      return;
+    }
+    default: {
+      const context = {
+        runId: runtime.runId
+      };
+      if (turn !== void 0) context.turn = turn;
+      if (scope !== void 0) context.scope = scope;
+      const mapped = runtime.options.mapCustomEvent?.(event, context);
+      if (mapped === void 0) return;
+      if (Array.isArray(mapped)) {
+        yield* mapped;
+      } else {
+        yield mapped;
+      }
+    }
+  }
+}
+function createMessageState(input) {
+  const state = {
+    runId: input.runId,
+    messageId: createClientId("msg"),
+    started: false,
+    ended: false,
+    textPartId: createClientId("text"),
+    text: "",
+    textStarted: false,
+    textEnded: false,
+    reasoning: /* @__PURE__ */ new Map(),
+    tools: /* @__PURE__ */ new Map(),
+    sourceFingerprints: /* @__PURE__ */ new Set(),
+    providerToolCallFingerprints: /* @__PURE__ */ new Set()
+  };
+  if (input.turn !== void 0) state.turn = input.turn;
+  if (input.scope !== void 0) state.scope = input.scope;
+  return state;
+}
+function getAgentMessage(runtime, turn, scope) {
+  const key = `${scopeKey(scope)}:${turn}`;
+  const current = runtime.messages.get(key);
+  if (current !== void 0) return current;
+  const input = {
+    runId: runtime.runId,
+    turn
+  };
+  if (scope !== void 0) input.scope = scope;
+  const created = createMessageState(input);
+  runtime.messages.set(key, created);
+  return created;
+}
+async function* startMessage(state) {
+  if (state.started) return;
+  state.started = true;
+  yield clientEvent(state, {
+    type: "message_start",
+    messageId: state.messageId,
+    role: "assistant"
+  });
+}
+async function* appendText(state, delta) {
+  if (!state.textStarted) {
+    state.textStarted = true;
+    yield clientEvent(state, {
+      type: "text_start",
+      messageId: state.messageId,
+      partId: state.textPartId
+    });
+  }
+  state.text += delta;
+  yield clientEvent(state, {
+    type: "text_delta",
+    messageId: state.messageId,
+    partId: state.textPartId,
+    delta
+  });
+}
+async function* emitSource(state, source) {
+  const fingerprint = valueFingerprint(source);
+  if (state.sourceFingerprints.has(fingerprint)) return;
+  state.sourceFingerprints.add(fingerprint);
+  yield clientEvent(state, {
+    type: "source",
+    messageId: state.messageId,
+    partId: createClientId("source"),
+    source
+  });
+}
+async function* emitProviderToolCall(state, toolCall) {
+  const fingerprint = valueFingerprint(toolCall);
+  if (state.providerToolCallFingerprints.has(fingerprint)) return;
+  state.providerToolCallFingerprints.add(fingerprint);
+  yield clientEvent(state, { type: "provider_tool_call", toolCall });
+}
+async function* appendReasoning(state, event) {
+  const key = event.id ?? "default";
+  let reasoning = state.reasoning.get(key);
+  if (reasoning === void 0) {
+    reasoning = {
+      partId: createClientId("reasoning"),
+      text: "",
+      ended: false
+    };
+    if (event.id !== void 0) reasoning.reasoningId = event.id;
+    state.reasoning.set(key, reasoning);
+    const reasoningStart = {
+      type: "reasoning_start",
+      messageId: state.messageId,
+      partId: reasoning.partId
+    };
+    if (event.id !== void 0) reasoningStart.reasoningId = event.id;
+    yield clientEvent(state, reasoningStart);
+  }
+  reasoning.text += event.delta;
+  const reasoningDelta = {
+    type: "reasoning_delta",
+    messageId: state.messageId,
+    partId: reasoning.partId,
+    delta: event.delta
+  };
+  if (event.contentType !== void 0) reasoningDelta.contentType = event.contentType;
+  if (event.signature !== void 0) reasoningDelta.signature = event.signature;
+  yield clientEvent(state, reasoningDelta);
+}
+async function* appendToolCall(state, event) {
+  const tool = getToolState(state, event.id, event.name);
+  if (!tool.started) {
+    tool.started = true;
+    const toolCallStart = {
+      type: "tool_call_start",
+      messageId: state.messageId,
+      partId: tool.partId,
+      toolCallId: event.id
+    };
+    if (event.callId !== void 0) toolCallStart.callId = event.callId;
+    if (event.name !== void 0) toolCallStart.toolName = event.name;
+    yield clientEvent(state, toolCallStart);
+  }
+  if (event.callId !== void 0) tool.callId = event.callId;
+  if (event.name !== void 0) tool.toolName = event.name;
+  if (event.signature !== void 0) tool.signature = event.signature;
+  if (event.argumentsDelta === void 0) return;
+  const mode = event.argumentsMode ?? "append";
+  const prior = typeof tool.input === "string" ? tool.input : "";
+  tool.input = mode === "replace" ? event.argumentsDelta : `${prior}${event.argumentsDelta}`;
+  const toolCallDelta = {
+    type: "tool_call_delta",
+    messageId: state.messageId,
+    partId: tool.partId,
+    toolCallId: event.id,
+    delta: event.argumentsDelta,
+    mode
+  };
+  if (event.callId !== void 0) toolCallDelta.callId = event.callId;
+  if (event.name !== void 0) toolCallDelta.toolName = event.name;
+  if (event.signature !== void 0) toolCallDelta.signature = event.signature;
+  yield clientEvent(state, toolCallDelta);
+}
+async function* finishToolCall(state, toolCall) {
+  const tool = getToolState(state, toolCall.toolCallId, toolCall.toolName);
+  const wasEnded = tool.ended;
+  if (!tool.started) {
+    tool.started = true;
+    const toolCallStart = {
+      type: "tool_call_start",
+      messageId: state.messageId,
+      partId: tool.partId,
+      toolCallId: toolCall.toolCallId,
+      toolName: toolCall.toolName
+    };
+    if (toolCall.callId !== void 0) toolCallStart.callId = toolCall.callId;
+    yield clientEvent(state, toolCallStart);
+  }
+  if (toolCall.callId === void 0) delete tool.callId;
+  else tool.callId = toolCall.callId;
+  tool.toolName = toolCall.toolName;
+  tool.input = toolCall.input;
+  if (toolCall.signature === void 0) delete tool.signature;
+  else tool.signature = toolCall.signature;
+  if (wasEnded) return;
+  tool.ended = true;
+  const toolCallEnd = {
+    type: "tool_call_end",
+    messageId: state.messageId,
+    partId: tool.partId,
+    toolCallId: toolCall.toolCallId,
+    toolName: toolCall.toolName,
+    input: toolCall.input
+  };
+  if (toolCall.callId !== void 0) toolCallEnd.callId = toolCall.callId;
+  if (toolCall.signature !== void 0) toolCallEnd.signature = toolCall.signature;
+  yield clientEvent(state, toolCallEnd);
+}
+async function* finishMessage(state, content, metadata) {
+  if (state.ended) return;
+  const textContent2 = content.filter(
+    (part) => part.type === "text"
+  );
+  const text = textContent2.map((part) => part.text).join("");
+  if (state.textStarted || text.length > 0) {
+    if (!state.textStarted) {
+      state.textStarted = true;
+      yield clientEvent(state, {
+        type: "text_start",
+        messageId: state.messageId,
+        partId: state.textPartId
+      });
+    }
+    state.text = text;
+    state.textEnded = true;
+    const textEnd = {
+      type: "text_end",
+      messageId: state.messageId,
+      partId: state.textPartId,
+      text
+    };
+    if (textContent2.length === 1 && textContent2[0]?.signature !== void 0) {
+      textEnd.signature = textContent2[0].signature;
+    }
+    yield clientEvent(state, textEnd);
+  }
+  const finalReasoning = content.filter(
+    (part) => part.type === "reasoning"
+  );
+  const anonymousReasoning = [...state.reasoning.values()].filter(
+    (reasoning) => reasoning.reasoningId === void 0
+  );
+  let anonymousIndex = 0;
+  for (const [index, reasoning] of finalReasoning.entries()) {
+    const existing = reasoning.id === void 0 ? anonymousReasoning[anonymousIndex++] : state.reasoning.get(reasoning.id);
+    const current = existing ?? createReasoningState(reasoning.id);
+    if (existing === void 0) {
+      state.reasoning.set(reasoning.id ?? `final:${index}`, current);
+      const reasoningStart = {
+        type: "reasoning_start",
+        messageId: state.messageId,
+        partId: current.partId
+      };
+      if (reasoning.id !== void 0) reasoningStart.reasoningId = reasoning.id;
+      yield clientEvent(state, reasoningStart);
+    }
+    if (!current.ended) {
+      current.ended = true;
+      current.text = reasoning.text;
+      const reasoningEnd = {
+        type: "reasoning_end",
+        messageId: state.messageId,
+        partId: current.partId,
+        text: reasoning.text
+      };
+      if (reasoning.details !== void 0) reasoningEnd.content = reasoning.details;
+      yield clientEvent(state, reasoningEnd);
+    }
+  }
+  for (const reasoning of state.reasoning.values()) {
+    if (reasoning.ended) continue;
+    reasoning.ended = true;
+    yield clientEvent(state, {
+      type: "reasoning_end",
+      messageId: state.messageId,
+      partId: reasoning.partId,
+      text: reasoning.text
+    });
+  }
+  for (const part of content) {
+    if (part.type === "tool-call") yield* finishToolCall(state, part);
+    if (part.type === "image" || part.type === "file") {
+      const attachment = contentAttachment(part);
+      yield clientEvent(state, {
+        type: "attachment",
+        messageId: state.messageId,
+        partId: createClientId("attachment_part"),
+        attachment
+      });
+    }
+  }
+  for (const source of metadata.sources ?? []) yield* emitSource(state, source);
+  for (const toolCall of metadata.providerToolCalls ?? []) {
+    yield* emitProviderToolCall(state, toolCall);
+  }
+  state.ended = true;
+  const messageEnd = {
+    type: "message_end",
+    messageId: state.messageId,
+    parts: contentToUIMessageParts(content, state),
+    usage: metadata.usage
+  };
+  if (state.modelMessageId !== void 0) messageEnd.modelMessageId = state.modelMessageId;
+  if (metadata.contextUsage !== void 0) messageEnd.contextUsage = metadata.contextUsage;
+  yield clientEvent(state, messageEnd);
+}
+async function* finishErroredRun(state, error, usage, mapper) {
+  const mapped = mapClientError(error, mapper);
+  if (state.textStarted && !state.textEnded) {
+    state.textEnded = true;
+    yield clientEvent(state, {
+      type: "text_end",
+      messageId: state.messageId,
+      partId: state.textPartId,
+      text: state.text
+    });
+  }
+  const errorEvent = {
+    type: "error",
+    error: mapped
+  };
+  if (usage !== void 0) errorEvent.usage = usage;
+  yield clientEvent(state, errorEvent);
+  if (!state.ended) {
+    state.ended = true;
+    const messageEnd = {
+      type: "message_end",
+      messageId: state.messageId
+    };
+    if (state.modelMessageId !== void 0) messageEnd.modelMessageId = state.modelMessageId;
+    if (usage !== void 0) messageEnd.usage = usage;
+    yield clientEvent(state, messageEnd);
+  }
+  const runEnd = {
+    type: "run_end",
+    status: "error"
+  };
+  if (usage !== void 0) runEnd.usage = usage;
+  yield clientEvent(state, runEnd);
+}
+function contentToUIMessageParts(content, state) {
+  let textIndex = 0;
+  let anonymousReasoningIndex = 0;
+  const anonymousReasoning = [...state.reasoning.values()].filter(
+    (reasoning) => reasoning.reasoningId === void 0
+  );
+  return content.map((contentPart) => {
+    if (contentPart.type === "text") {
+      const part = {
+        id: textIndex === 0 ? state.textPartId : createClientId("text"),
+        type: "text",
+        text: contentPart.text
+      };
+      textIndex += 1;
+      if (contentPart.signature !== void 0) part.signature = contentPart.signature;
+      return part;
+    }
+    if (contentPart.type === "reasoning") {
+      const current = contentPart.id === void 0 ? anonymousReasoning[anonymousReasoningIndex++] : state.reasoning.get(contentPart.id);
+      const part = {
+        id: current?.partId ?? createClientId("reasoning"),
+        type: "reasoning",
+        text: contentPart.text
+      };
+      if (contentPart.id !== void 0) part.reasoningId = contentPart.id;
+      if (contentPart.details !== void 0) part.content = contentPart.details;
+      return part;
+    }
+    if (contentPart.type === "tool-call") {
+      const tool = getToolState(state, contentPart.toolCallId, contentPart.toolName);
+      const partBase = {
+        id: tool.partId,
+        type: "tool",
+        toolName: contentPart.toolName,
+        toolCallId: contentPart.toolCallId
+      };
+      if (contentPart.callId !== void 0) Object.assign(partBase, { callId: contentPart.callId });
+      if (tool.internalCallId !== void 0) {
+        Object.assign(partBase, { internalCallId: tool.internalCallId });
+      }
+      if (state.turn !== void 0) Object.assign(partBase, { turn: state.turn });
+      if (contentPart.signature !== void 0) {
+        Object.assign(partBase, { signature: contentPart.signature });
+      }
+      if (tool.result?.status === "success") {
+        const part = {
+          ...partBase,
+          state: "output-available",
+          input: contentPart.input,
+          output: tool.result.output
+        };
+        if (tool.result.content !== void 0) part.resultContent = tool.result.content;
+        return part;
+      }
+      if (tool.result?.status === "error") {
+        return {
+          ...partBase,
+          state: "error",
+          input: contentPart.input,
+          error: tool.result.error
+        };
+      }
+      return {
+        ...partBase,
+        state: "input-available",
+        input: contentPart.input
+      };
+    }
+    const attachment = contentAttachment(contentPart);
+    return {
+      id: createClientId("attachment_part"),
+      type: "attachment",
+      attachment
+    };
+  });
+}
+function getToolState(state, id, name) {
+  let tool = state.tools.get(id);
+  if (tool === void 0) {
+    tool = {
+      partId: createClientId("tool"),
+      toolCallId: id,
+      input: "",
+      started: false,
+      ended: false
+    };
+    if (name !== void 0) tool.toolName = name;
+    state.tools.set(id, tool);
+  } else if (name !== void 0) {
+    tool.toolName = name;
+  }
+  return tool;
+}
+function getToolResultState(state, toolName, toolCallId, callId, internalCallId) {
+  const matchedByToolCallId = state.tools.get(toolCallId);
+  const matchedByCallId = callId === void 0 ? void 0 : [...state.tools.values()].find((tool2) => tool2.callId === callId);
+  const tool = matchedByToolCallId ?? matchedByCallId ?? getToolState(state, toolCallId, toolName);
+  tool.toolName = toolName;
+  if (callId !== void 0) tool.callId = callId;
+  tool.internalCallId = internalCallId;
+  return tool;
+}
+function createReasoningState(id) {
+  const state = {
+    partId: createClientId("reasoning"),
+    text: "",
+    ended: false
+  };
+  if (id !== void 0) state.reasoningId = id;
+  return state;
+}
+function contentAttachment(content) {
+  const attachment = {
+    id: createClientId("attachment"),
+    type: content.type === "image" ? "image" : "file"
+  };
+  if (content.type === "image") {
+    if (content.detail !== void 0) attachment.detail = content.detail;
+    if (content.mediaType !== void 0) attachment.mediaType = content.mediaType;
+    if (content.image.type === "url") attachment.url = content.image.url;
+    else attachment.data = content.image.data;
+    return attachment;
+  }
+  attachment.mediaType = content.mediaType;
+  if (content.filename !== void 0) attachment.name = content.filename;
+  if (content.data.type === "url") {
+    attachment.url = content.data.url;
+  } else if (content.data.type === "data") {
+    attachment.data = content.data.data;
+  } else {
+    attachment.text = content.data.text;
+  }
+  return attachment;
+}
+function clientToolResult(output, result) {
+  switch (output.type) {
+    case "text":
+      return { status: "success", output: output.value };
+    case "json":
+      return { status: "success", output: output.value };
+    case "content":
+      return { status: "success", output: result, content: output.value };
+    case "execution-denied":
+      return {
+        status: "error",
+        error: {
+          message: output.reason ?? "Tool execution was denied.",
+          code: "tool_execution_denied"
+        }
+      };
+    case "error-text":
+      return {
+        status: "error",
+        error: { message: output.value, code: "tool_execution_error" }
+      };
+    case "error-json":
+      return {
+        status: "error",
+        error: {
+          message: "Tool execution failed.",
+          code: "tool_execution_error",
+          details: output.value
+        }
+      };
+  }
+}
+function parseJsonOrString(value) {
+  try {
+    const parsed = JSON.parse(value);
+    return isJsonValue3(parsed) ? parsed : value;
+  } catch {
+    return value;
+  }
+}
+function clientOutput(output, mapper) {
+  const mapped = mapper === void 0 ? isJsonValue3(output) ? output : void 0 : mapper(output);
+  if (mapped !== void 0 && !isJsonValue3(mapped)) {
+    throw new TypeError("mapOutput must return a strict JSON value or undefined.");
+  }
+  return mapped;
+}
+function valueFingerprint(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (Array.isArray(value)) return `[${value.map(valueFingerprint).join(",")}]`;
+  if (typeof value === "object") {
+    return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => `${JSON.stringify(key)}:${valueFingerprint(entry)}`).join(",")}}`;
+  }
+  return `${typeof value}:${JSON.stringify(value)}`;
+}
+function clientTrace(trace) {
+  const result = {
+    observer: trace.observer
+  };
+  if (trace.traceId !== void 0) result.traceId = trace.traceId;
+  if (trace.observationId !== void 0) result.observationId = trace.observationId;
+  return result;
+}
+function mapClientError(error, mapper) {
+  const mapped = mapper?.(error) ?? maskedClientError();
+  if (typeof mapped.message !== "string" || mapped.details !== void 0 && !isJsonValue3(mapped.details)) {
+    throw new TypeError("mapError must return a JSON-safe ClientStreamError.");
+  }
+  return mapped;
+}
+function clientEvent(state, event) {
+  return scopedEvent(state.runId, state.turn, state.scope, event);
+}
+function rootEvent(runId, event, scope) {
+  return scopedEvent(runId, void 0, scope, event);
+}
+function scopedEvent(runId, turn, scope, event) {
+  let scoped = { runId, ...event };
+  if (turn !== void 0) scoped = { ...scoped, turn };
+  if (scope !== void 0) scoped = { ...scoped, scope };
+  return scoped;
+}
+function scopeKey(scope) {
+  if (scope === void 0) return "root";
+  return [
+    scope.agentId,
+    scope.parentRunId,
+    scope.parentToolName,
+    scope.parentToolCallId,
+    scope.parentInternalToolCallId
+  ].join(":");
+}
+function isRootTerminalAgentEvent(event) {
+  return event.type === "final" || event.type === "error";
+}
+function propagateCancellation(source, transform) {
+  return {
+    [Symbol.asyncIterator]() {
+      const sourceIterator = source[Symbol.asyncIterator]();
+      const sharedSource = {
+        [Symbol.asyncIterator]: () => sourceIterator
+      };
+      const outputIterator = transform(sharedSource)[Symbol.asyncIterator]();
+      let returned = false;
+      return {
+        next: () => outputIterator.next(),
+        async return() {
+          if (returned) return { done: true, value: void 0 };
+          returned = true;
+          const sourceReturn = sourceIterator.return?.();
+          const outputReturn = outputIterator.return?.();
+          await Promise.all([sourceReturn, outputReturn]);
+          return { done: true, value: void 0 };
+        }
+      };
+    }
+  };
+}
+
+// src/client-transport.ts
+function createHttpClientTransport(options) {
+  const transport = createFetchEventTransport({
+    ...options,
+    mapEvent: (event) => parseClientStreamFrame(event, protocolOptions(options)),
+    validateResponse(response) {
+      if (response.headers.get("x-anvia-stream-protocol") !== CLIENT_STREAM_PROTOCOL) {
+        throw new ClientProtocolError(
+          `Expected x-anvia-stream-protocol: ${CLIENT_STREAM_PROTOCOL}.`
+        );
+      }
+    }
+  });
+  return {
+    async *send(sendOptions) {
+      const resume = sendOptions.resume ?? resumeCursorFromRequest(sendOptions.request);
+      yield* validateFrameSequence(transport.send(sendOptions), resume);
+    }
+  };
+}
+function createDirectClientTransport(options) {
+  return {
+    async *send(sendOptions) {
+      const resume = sendOptions.resume ?? resumeCursorFromRequest(sendOptions.request);
+      if (resume !== void 0) {
+        throw new ClientProtocolError("Direct client transports do not support resume cursors.");
+      }
+      const handlerOptions = {
+        request: sendOptions.request
+      };
+      if (sendOptions.abortSignal !== void 0) {
+        handlerOptions.abortSignal = sendOptions.abortSignal;
+      }
+      if (sendOptions.headers !== void 0) handlerOptions.headers = sendOptions.headers;
+      const events = await options.handler(handlerOptions);
+      const iterator = events[Symbol.asyncIterator]();
+      const streamId = createClientId("stream");
+      let eventId = 0;
+      yield {
+        type: "stream_start",
+        protocol: CLIENT_STREAM_PROTOCOL,
+        streamId,
+        eventId: 0,
+        resumable: false
+      };
+      let status = "completed";
+      try {
+        let closePromise;
+        const close = () => {
+          closePromise ??= Promise.resolve(iterator.return?.());
+          return closePromise;
+        };
+        const onAbort = () => {
+          void close();
+        };
+        sendOptions.abortSignal?.addEventListener("abort", onAbort, { once: true });
+        try {
+          while (!sendOptions.abortSignal?.aborted) {
+            const next = await iterator.next();
+            if (next.done) break;
+            const event = parseClientStreamEvent(
+              next.value,
+              protocolOptions(options)
+            );
+            eventId += 1;
+            yield { type: "stream_event", streamId, eventId, event };
+          }
+        } finally {
+          sendOptions.abortSignal?.removeEventListener("abort", onAbort);
+          await close();
+        }
+      } catch {
+        status = "error";
+      }
+      yield { type: "stream_end", streamId, eventId, status };
+    }
+  };
+}
+async function* validateFrameSequence(frames, resume) {
+  let streamId;
+  let lastEventId = resume?.after ?? 0;
+  let ended = false;
+  for await (const frame of frames) {
+    if (ended) throw new ClientProtocolError("Received a frame after stream_end.", frame);
+    if (streamId === void 0) {
+      if (frame.type !== "stream_start") {
+        throw new ClientProtocolError("The first client stream frame must be stream_start.", frame);
+      }
+      streamId = frame.streamId;
+      if (resume !== void 0 && frame.streamId !== resume.streamId) {
+        throw new ClientProtocolError("Resume response streamId does not match the cursor.", frame);
+      }
+      if (resume !== void 0 && !frame.resumable) {
+        throw new ClientProtocolError("Resume response must identify a resumable stream.", frame);
+      }
+    } else if (frame.type === "stream_start") {
+      throw new ClientProtocolError("Received more than one stream_start frame.", frame);
+    } else if (frame.streamId !== streamId) {
+      throw new ClientProtocolError("Client streamId changed during the response.", frame);
+    }
+    if (frame.type === "stream_event") {
+      if (frame.eventId !== lastEventId + 1) {
+        throw new ClientProtocolError("Client stream event IDs must be contiguous.", frame);
+      }
+      lastEventId = frame.eventId;
+    } else if (frame.type === "stream_end") {
+      if (frame.eventId !== lastEventId) {
+        throw new ClientProtocolError("stream_end has an invalid eventId.", frame);
+      }
+      ended = true;
+    }
+    yield frame;
+  }
+  if (streamId === void 0 || !ended) {
+    throw new ClientProtocolError("Client stream ended without a complete frame sequence.");
+  }
+}
+function protocolOptions(options) {
+  const result = {};
+  if (options.metadataSchema !== void 0) result.metadataSchema = options.metadataSchema;
+  if (options.dataSchemas !== void 0) result.dataSchemas = options.dataSchemas;
+  return result;
+}
+function resumeCursorFromRequest(value) {
+  if (typeof value !== "object" || value === null || !("resume" in value)) return void 0;
+  const resume = value.resume;
+  if (typeof resume !== "object" || resume === null) return void 0;
+  if (!("streamId" in resume) || !("after" in resume)) return void 0;
+  return typeof resume.streamId === "string" && typeof resume.after === "number" && Number.isSafeInteger(resume.after) && resume.after >= 0 ? { streamId: resume.streamId, after: resume.after } : void 0;
+}
+
+// src/reducer.ts
+import { isJsonValue as isJsonValue4 } from "@anvia/core/completion";
+function applyClientStreamEvent(messages, event) {
+  if (event.scope?.parentToolCallId !== void 0) {
+    return messages;
+  }
+  switch (event.type) {
+    case "message_start": {
+      if (messages.some((message2) => message2.id === event.messageId)) return messages;
+      let message = {
+        id: event.messageId,
+        role: event.role,
+        parts: []
+      };
+      if (event.metadata !== void 0) message = { ...message, metadata: event.metadata };
+      return [...messages, message];
+    }
+    case "text_start":
+      return upsertPart(messages, event.messageId, {
+        id: event.partId,
+        type: "text",
+        text: ""
+      });
+    case "text_delta":
+      return updatePart(messages, event.messageId, event.partId, (part) => ({
+        id: event.partId,
+        type: "text",
+        text: part?.type === "text" ? `${part.text}${event.delta}` : event.delta
+      }));
+    case "text_end":
+      return updatePart(messages, event.messageId, event.partId, (part) => {
+        const next = {
+          id: event.partId,
+          type: "text",
+          text: event.text ?? (part?.type === "text" ? part.text : "")
+        };
+        if (event.signature !== void 0) next.signature = event.signature;
+        return next;
+      });
+    case "reasoning_start": {
+      const reasoning = {
+        id: event.partId,
+        type: "reasoning",
+        text: ""
+      };
+      if (event.reasoningId !== void 0) reasoning.reasoningId = event.reasoningId;
+      return upsertPart(messages, event.messageId, reasoning);
+    }
+    case "reasoning_delta":
+      return updatePart(messages, event.messageId, event.partId, (part) => {
+        const reasoning = {
+          id: event.partId,
+          type: "reasoning",
+          text: part?.type === "reasoning" ? `${part.text}${event.delta}` : event.delta
+        };
+        if (part?.type === "reasoning" && part.reasoningId !== void 0) {
+          reasoning.reasoningId = part.reasoningId;
+        }
+        const content = appendReasoningContent(
+          part?.type === "reasoning" ? part.content : void 0,
+          event
+        );
+        if (content !== void 0) reasoning.content = content;
+        return reasoning;
+      });
+    case "reasoning_end":
+      return updatePart(messages, event.messageId, event.partId, (part) => {
+        const reasoning = {
+          id: event.partId,
+          type: "reasoning",
+          text: event.text ?? (part?.type === "reasoning" ? part.text : "")
+        };
+        if (part?.type === "reasoning" && part.reasoningId !== void 0) {
+          reasoning.reasoningId = part.reasoningId;
+        }
+        if (event.content !== void 0) {
+          reasoning.content = event.content;
+        } else if (part?.type === "reasoning" && part.content !== void 0) {
+          reasoning.content = part.content;
+        }
+        return reasoning;
+      });
+    case "tool_call_start": {
+      const part = {
+        id: event.partId,
+        type: "tool",
+        toolName: event.toolName ?? "",
+        toolCallId: event.toolCallId,
+        state: "input-streaming",
+        input: ""
+      };
+      if (event.callId !== void 0) part.callId = event.callId;
+      if (event.turn !== void 0) part.turn = event.turn;
+      return upsertPart(messages, event.messageId, part);
+    }
+    case "tool_call_delta":
+      return updatePart(messages, event.messageId, event.partId, (current) => {
+        const part = current?.type === "tool" ? toolPartBase(current) : {
+          id: event.partId,
+          type: "tool",
+          toolName: event.toolName ?? "",
+          toolCallId: event.toolCallId
+        };
+        const previous = current?.type === "tool" && typeof current.input === "string" ? current.input : "";
+        if (event.toolName !== void 0) part.toolName = event.toolName;
+        if (event.callId !== void 0) part.callId = event.callId;
+        if (event.signature !== void 0) part.signature = event.signature;
+        if (event.turn !== void 0) part.turn = event.turn;
+        return {
+          ...part,
+          state: "input-streaming",
+          input: event.mode === "replace" ? event.delta : `${previous}${event.delta}`
+        };
+      });
+    case "tool_call_end": {
+      const part = {
+        id: event.partId,
+        type: "tool",
+        toolName: event.toolName,
+        toolCallId: event.toolCallId,
+        state: "input-available",
+        input: event.input
+      };
+      if (event.callId !== void 0) part.callId = event.callId;
+      if (event.turn !== void 0) part.turn = event.turn;
+      if (event.signature !== void 0) part.signature = event.signature;
+      return upsertPart(messages, event.messageId, part);
+    }
+    case "tool_result":
+      return updatePart(messages, event.messageId, event.partId, (current) => {
+        const part = current?.type === "tool" ? toolPartBase(current) : {
+          id: event.partId,
+          type: "tool",
+          toolName: event.toolName,
+          toolCallId: event.toolCallId
+        };
+        if (event.callId !== void 0) part.callId = event.callId;
+        if (event.internalCallId !== void 0) part.internalCallId = event.internalCallId;
+        if (event.turn !== void 0) part.turn = event.turn;
+        if (event.result.status === "error") {
+          return {
+            ...part,
+            state: "error",
+            input: event.input,
+            error: event.result.error
+          };
+        }
+        const completed = {
+          ...part,
+          state: "output-available",
+          input: event.input,
+          output: event.result.output
+        };
+        if (event.result.content !== void 0) completed.resultContent = event.result.content;
+        return completed;
+      });
+    case "source":
+      return upsertPart(messages, event.messageId, {
+        id: event.partId,
+        type: "source",
+        source: event.source
+      });
+    case "attachment":
+      return upsertPart(messages, event.messageId, {
+        id: event.partId,
+        type: "attachment",
+        attachment: event.attachment
+      });
+    case "data":
+      if (event.transient === true) return messages;
+      return appendToLastAssistant(messages, {
+        id: createClientId("data"),
+        type: "data",
+        name: event.name,
+        data: event.data
+      });
+    case "message_end":
+      return messages.map((message) => {
+        if (message.id !== event.messageId) return message;
+        const metadata = mergeMetadata(message.metadata, event.metadata);
+        const generationUpdate = {
+          runId: event.runId
+        };
+        if (event.usage !== void 0) generationUpdate.usage = event.usage;
+        if (event.contextUsage !== void 0) {
+          generationUpdate.contextUsage = event.contextUsage;
+        }
+        const generation = mergeGeneration(message.generation, generationUpdate);
+        let updated = {
+          ...message,
+          generation
+        };
+        if (event.parts !== void 0) {
+          updated = { ...updated, parts: reconcileFinalParts(message.parts, event.parts) };
+        }
+        if (event.modelMessageId !== void 0) {
+          updated = { ...updated, modelMessageId: event.modelMessageId };
+        }
+        if (metadata !== void 0) updated = { ...updated, metadata };
+        return updated;
+      });
+    case "run_end": {
+      const generation = {
+        runId: event.runId,
+        status: event.status
+      };
+      if (event.usage !== void 0) generation.usage = event.usage;
+      if (event.contextUsage !== void 0) generation.contextUsage = event.contextUsage;
+      if (event.trace !== void 0) generation.trace = event.trace;
+      if (event.memoryCompaction !== void 0) {
+        generation.memoryCompaction = event.memoryCompaction;
+      }
+      return updateLastAssistantGeneration(messages, generation);
+    }
+    case "error":
+      return appendToLastAssistant(messages, {
+        id: createClientId("error"),
+        type: "error",
+        error: event.error
+      });
+    default:
+      return messages;
+  }
+}
+function toolPartBase(part) {
+  const base = {
+    id: part.id,
+    type: part.type,
+    toolName: part.toolName,
+    toolCallId: part.toolCallId
+  };
+  if (part.callId !== void 0) Object.assign(base, { callId: part.callId });
+  if (part.internalCallId !== void 0) {
+    Object.assign(base, { internalCallId: part.internalCallId });
+  }
+  if (part.turn !== void 0) Object.assign(base, { turn: part.turn });
+  if (part.signature !== void 0) Object.assign(base, { signature: part.signature });
+  return base;
+}
+function reconcileFinalParts(current, final) {
+  const clientOnly = current.filter(
+    (part) => part.type === "source" || part.type === "data" || part.type === "error"
+  );
+  return [...final, ...clientOnly];
+}
+function appendReasoningContent(current, event) {
+  if (event.contentType === void 0 && event.signature === void 0) return current;
+  const type = event.contentType ?? "text";
+  const next = [...current ?? []];
+  const last = next.at(-1);
+  if (type === "text") {
+    if (last?.type === "text" && last.signature === event.signature) {
+      next[next.length - 1] = { ...last, text: `${last.text}${event.delta}` };
+    } else {
+      let detail = {
+        type,
+        text: event.delta
+      };
+      if (event.signature !== void 0) detail = { ...detail, signature: event.signature };
+      next.push(detail);
+    }
+    return next;
+  }
+  if (type === "summary") {
+    if (last?.type === "summary") {
+      next[next.length - 1] = { ...last, text: `${last.text}${event.delta}` };
+    } else next.push({ type, text: event.delta });
+    return next;
+  }
+  if (type === "encrypted") {
+    if (last?.type === "encrypted") {
+      next[next.length - 1] = { ...last, data: `${last.data}${event.delta}` };
+    } else next.push({ type, data: event.delta });
+    return next;
+  }
+  if (last?.type === "redacted") {
+    next[next.length - 1] = { ...last, data: `${last.data}${event.delta}` };
+  } else next.push({ type, data: event.delta });
+  return next;
+}
+function messageText(message) {
+  return message.parts.flatMap((part) => part.type === "text" ? [part.text] : []).join("");
+}
+function assistantText(messages) {
+  const assistant = [...messages].reverse().find((message) => message.role === "assistant");
+  return assistant === void 0 ? "" : messageText(assistant);
+}
+function upsertPart(messages, messageId, part) {
+  return updatePart(messages, messageId, part.id, () => part);
+}
+function updatePart(messages, messageId, partId, update) {
+  const current = ensureAssistant(messages, messageId);
+  return current.map((message) => {
+    if (message.id !== messageId) return message;
+    const index = message.parts.findIndex((part) => part.id === partId);
+    if (index === -1) return { ...message, parts: [...message.parts, update(void 0)] };
+    const parts = [...message.parts];
+    parts[index] = update(parts[index]);
+    return { ...message, parts };
+  });
+}
+function ensureAssistant(messages, messageId) {
+  return messages.some((message) => message.id === messageId) ? messages : [...messages, { id: messageId, role: "assistant", parts: [] }];
+}
+function appendToLastAssistant(messages, part) {
+  const index = findLastIndex(messages, (message2) => message2.role === "assistant");
+  if (index === -1) {
+    return [...messages, { id: createClientId("msg"), role: "assistant", parts: [part] }];
+  }
+  const next = [...messages];
+  const message = next[index];
+  next[index] = { ...message, parts: [...message.parts, part] };
+  return next;
+}
+function updateLastAssistantGeneration(messages, value) {
+  const index = findLastIndex(messages, (message2) => message2.role === "assistant");
+  if (index === -1) return messages;
+  const next = [...messages];
+  const message = next[index];
+  next[index] = { ...message, generation: mergeGeneration(message.generation, value) };
+  return next;
+}
+function mergeMetadata(current, provided) {
+  if (provided === void 0) return current;
+  if (!isRecord2(current) || !isRecord2(provided)) return provided;
+  const next = { ...current, ...provided };
+  return isJsonValue4(next) ? next : provided;
+}
+function mergeGeneration(current, provided) {
+  return {
+    ...current,
+    ...Object.fromEntries(Object.entries(provided).filter(([, value]) => value !== void 0))
+  };
+}
+function findLastIndex(items, predicate) {
+  for (let index = items.length - 1; index >= 0; index -= 1) {
+    if (predicate(items[index])) return index;
+  }
+  return -1;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export {
+  CLIENT_STREAM_PROTOCOL,
+  ClientProtocolError,
+  agentToClientStream,
+  applyClientStreamEvent,
+  assistantText,
+  completionToClientStream,
+  createClientId,
+  createDirectClientTransport,
+  createHttpClientTransport,
+  customAgentEventsToClientStream,
+  maskedClientError,
+  messageText,
+  messagesToUIMessages,
+  normalizeClientError,
+  parseClientStreamEvent,
+  parseClientStreamFrame,
+  parseClientStreamRequest,
+  parseUIMessage,
+  parseUIMessages,
+  uiMessagesToMessages
+};
+//# sourceMappingURL=index.js.map