@yourgpt/llm-sdk 2.6.0-beta.2 → 2.6.0

package/dist/index.js

@@ -3,6 +3,56 @@
 var hono = require('hono');
 var cors = require('hono/cors');
 
+// src/core/openai-responses.ts
+function responseReplayMetadata(metadata) {
+  const response = metadata?.openai?.response;
+  if (!response) return metadata;
+  const output = response.output.map((item) => {
+    const fields = ["type", "id", "status"];
+    switch (item.type) {
+      case "reasoning":
+        fields.push("encrypted_content");
+        break;
+      case "message":
+        fields.push("role", "phase");
+        break;
+      case "function_call":
+        fields.push("call_id", "name", "namespace", "arguments");
+        break;
+      case "tool_search_call":
+        fields.push("call_id", "execution", "arguments");
+        break;
+      case "tool_search_output":
+        fields.push("call_id", "tools");
+        break;
+      case "web_search_call":
+        fields.push("action");
+        break;
+      default:
+        return stripItemDiagnostics(item);
+    }
+    const replay = Object.fromEntries(
+      fields.filter((key) => item[key] !== void 0).map((key) => [key, item[key]])
+    );
+    if (item.type === "reasoning") replay.summary = [];
+    if (item.type === "message")
+      replay.content = Array.isArray(item.content) ? item.content.flatMap(
+        (part) => part?.type === "output_text" && typeof part.text === "string" ? [{ type: "output_text", text: part.text, annotations: [] }] : part?.type === "refusal" && typeof part.refusal === "string" ? [{ type: "refusal", refusal: part.refusal }] : []
+      ) : [];
+    return stripItemDiagnostics(replay);
+  });
+  return { openai: { response: { output, refusals: [] } } };
+}
+function stripItemDiagnostics(item) {
+  const {
+    usage: _usage,
+    logprobs: _logprobs,
+    metadata: _metadata,
+    ...state
+  } = item;
+  return state;
+}
+
 // src/core/tool-output.ts
 var imageTypes = /* @__PURE__ */ new Set([
   "image/png",
@@ -102,7 +152,22 @@ function zodToJsonSchema(schema) {
     case "ZodString":
       return { type: "string", description };
     case "ZodNumber":
-      return { type: "number", description };
+      return {
+        type: def.checks?.some(
+          (check) => check.kind === "int"
+        ) ? "integer" : "number",
+        description
+      };
+    case "ZodNull":
+      return { type: "null", description };
+    case "ZodAny":
+    case "ZodUnknown":
+      return { description };
+    case "ZodEffects":
+      return {
+        ...zodToJsonSchema(def.schema),
+        ...description ? { description } : {}
+      };
     case "ZodBoolean":
       return { type: "boolean", description };
     case "ZodEnum": {
@@ -123,10 +188,13 @@ function zodToJsonSchema(schema) {
       const properties = {};
       const required = [];
       for (const [key, value] of Object.entries(shapeObj)) {
-        properties[key] = zodToJsonSchema(value);
-        const valueDef = value._def;
-        const isOptional = valueDef.typeName === "ZodOptional" || valueDef.typeName === "ZodNullable" || valueDef.typeName === "ZodDefault";
-        if (!isOptional) {
+        Object.defineProperty(properties, key, {
+          value: zodToJsonSchema(value),
+          enumerable: true,
+          configurable: true,
+          writable: true
+        });
+        if (!acceptsMissingInput(value)) {
           required.push(key);
         }
       }
@@ -137,8 +205,13 @@ function zodToJsonSchema(schema) {
         description
       };
     }
-    case "ZodOptional":
     case "ZodNullable": {
+      return {
+        anyOf: [zodToJsonSchema(def.innerType), { type: "null" }],
+        description
+      };
+    }
+    case "ZodOptional": {
       const innerType = def.innerType;
       return zodToJsonSchema(innerType);
     }
@@ -148,6 +221,7 @@ function zodToJsonSchema(schema) {
     }
     case "ZodLiteral": {
       const value = def.value;
+      if (value === null) return { type: "null", description };
       if (typeof value === "string") {
         return { type: "string", enum: [value], description };
       }
@@ -171,12 +245,21 @@ function zodToJsonSchema(schema) {
       if (stringLiterals.length === options.length) {
         return { type: "string", enum: stringLiterals, description };
       }
-      return zodToJsonSchema(options[0]);
+      return { anyOf: options.map(zodToJsonSchema), description };
     }
     default:
       return { type: "string", description };
   }
 }
+function acceptsMissingInput(schema) {
+  const def = schema._def;
+  if (["ZodOptional", "ZodDefault", "ZodAny", "ZodUnknown"].includes(def.typeName))
+    return true;
+  if (def.typeName === "ZodNullable") return acceptsMissingInput(def.innerType);
+  if (def.typeName === "ZodEffects") return acceptsMissingInput(def.schema);
+  if (def.typeName === "ZodUnion") return def.options.some(acceptsMissingInput);
+  return false;
+}
 function formatToolsForOpenAI(tools) {
   return Object.entries(tools).map(([name, toolDef]) => ({
     type: "function",
@@ -207,6 +290,27 @@ function formatToolsForGoogle(tools) {
 }
 
 // src/core/provider-error.ts
+function invalidProviderResponse(message) {
+  return Object.assign(new Error(message), {
+    name: "InvalidProviderResponseError",
+    status: 502,
+    code: "INVALID_PROVIDER_RESPONSE"
+  });
+}
+function providerErrorEvent(error, code) {
+  const details = error ?? {};
+  const event = {
+    type: "error",
+    message: error instanceof Error ? error.message : String(error),
+    code,
+    ...typeof details.status === "number" ? { status: details.status } : {},
+    ...typeof details.code === "string" ? { providerCode: details.code } : {},
+    ...typeof details.param === "string" ? { param: details.param } : {},
+    ...typeof details.request_id === "string" ? { requestId: details.request_id } : {}
+  };
+  Object.defineProperty(event, "cause", { value: error, enumerable: false });
+  return event;
+}
 function throwIfAborted(signal) {
   if (!signal?.aborted) return;
   const error = new Error("The operation was aborted");
@@ -214,9 +318,42 @@ function throwIfAborted(signal) {
   throw error;
 }
 
+// src/core/tool-validation.ts
+function parseToolArguments(value) {
+  let args = value;
+  if (typeof value === "string") {
+    try {
+      args = JSON.parse(value || "{}");
+    } catch {
+      throw invalidProviderResponse("Tool arguments are not valid JSON");
+    }
+  }
+  if (args === null || typeof args !== "object" || Array.isArray(args))
+    throw invalidProviderResponse("Tool arguments must be a JSON object");
+  return args;
+}
+function validateToolCalls(calls) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const call of calls) {
+    if (!call || typeof call.id !== "string" || !call.id || typeof call.name !== "string" || !call.name || ids.has(call.id))
+      throw invalidProviderResponse(
+        "Tool calls have missing or duplicate identities"
+      );
+    ids.add(call.id);
+    if (typeof call.args === "string")
+      throw invalidProviderResponse("Parsed tool arguments must be an object");
+    parseToolArguments(call.args);
+  }
+}
+function validateMaxSteps(value) {
+  if (!Number.isSafeInteger(value) || value < 1)
+    throw new Error("maxSteps must be a positive safe integer");
+}
+
 // src/core/generate-text.ts
 async function generateText(params) {
   const { model, tools, maxSteps = 1, signal } = params;
+  validateMaxSteps(maxSteps);
   if (params.responseFormat && model.capabilities.supportsJsonMode === false) {
     console.warn(
       `[llm-sdk] ${model.provider}/${model.modelId} does not support structured output (responseFormat); the request will be sent but the provider may ignore it.`
@@ -240,12 +377,14 @@ async function generateText(params) {
       signal
     });
     throwIfAborted(signal);
+    const toolCalls = result.toolCalls ?? [];
+    validateToolCalls(toolCalls);
+    allToolCalls.push(...toolCalls);
     const stepToolResults = [];
-    if (result.toolCalls && result.toolCalls.length > 0 && tools) {
-      allToolCalls.push(...result.toolCalls);
-      for (const call of result.toolCalls) {
+    if (toolCalls.length > 0 && tools) {
+      for (const call of toolCalls) {
         throwIfAborted(signal);
-        const toolDef = tools[call.name];
+        const toolDef = Object.prototype.hasOwnProperty.call(tools, call.name) ? tools[call.name] : void 0;
         if (!toolDef) {
           const errorResult = {
             toolCallId: call.id,
@@ -288,7 +427,8 @@ async function generateText(params) {
     }
     steps.push({
       text: result.text,
-      toolCalls: result.toolCalls,
+      ...result.reasoningText !== void 0 ? { reasoningText: result.reasoningText } : {},
+      toolCalls,
       toolResults: stepToolResults,
       finishReason: result.finishReason,
       usage: result.usage,
@@ -297,16 +437,16 @@ async function generateText(params) {
     const assistantMessage = {
       role: "assistant",
       content: result.text || null,
-      ...result.toolCalls.length ? { toolCalls: result.toolCalls } : {},
-      ...result.providerMetadata ? { providerMetadata: result.providerMetadata } : {}
+      ...toolCalls.length ? { toolCalls } : {},
+      ...result.providerMetadata ? { providerMetadata: responseReplayMetadata(result.providerMetadata) } : {}
     };
     messages = [...messages, assistantMessage];
-    if (!result.toolCalls || result.toolCalls.length === 0) break;
+    if (toolCalls.length === 0 || !tools) break;
     for (const tr of stepToolResults) {
       const toolMessage = {
         role: "tool",
         toolCallId: tr.toolCallId,
-        content: tr.modelOutput ? "[Tool returned content]" : JSON.stringify(tr.result),
+        content: tr.modelOutput ? "[Tool returned content]" : JSON.stringify(tr.result ?? null),
         ...tr.modelOutput ? { modelOutput: tr.modelOutput } : {}
       };
       messages = [...messages, toolMessage];
@@ -315,6 +455,7 @@ async function generateText(params) {
   const lastStep = steps[steps.length - 1];
   return {
     text: lastStep?.text ?? "",
+    ...lastStep?.reasoningText !== void 0 ? { reasoningText: lastStep.reasoningText } : {},
     providerMetadata: lastStep?.providerMetadata,
     usage: sumUsage(steps),
     finishReason: lastStep?.finishReason ?? "stop",
@@ -361,9 +502,250 @@ function sumUsage(steps) {
   );
 }
 
+// src/core/image.ts
+async function generateImage({
+  model,
+  ...options
+}) {
+  options.signal?.throwIfAborted();
+  if (typeof options.prompt !== "string" || !options.prompt.trim())
+    throw new MediaAPIError("Image prompt must not be empty", "invalid_input");
+  const result = await model.doGenerate(options);
+  options.signal?.throwIfAborted();
+  if (!result.images?.length || result.images.some(
+    (image) => !(image.uint8Array instanceof Uint8Array) || !image.uint8Array.length
+  ))
+    throw new MediaAPIError(
+      "Image provider returned empty images",
+      "invalid_response"
+    );
+  return result;
+}
+var marker = /* @__PURE__ */ Symbol.for("@yourgpt/llm-sdk/MediaAPIError");
+var _a;
+var MediaAPIError = class extends Error {
+  constructor(message, code, status, requestId) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.requestId = requestId;
+    this[_a] = true;
+    this.name = "MediaAPIError";
+  }
+  static [(_a = marker, Symbol.hasInstance)](value) {
+    return !!value && typeof value === "object" && value[marker] === true;
+  }
+};
+
+// src/core/decision-validation.ts
+function decisionInputError(message) {
+  throw new DecisionAPIError(message, "invalid_input");
+}
+function decisionResponseError(message) {
+  throw new DecisionAPIError(message, "invalid_response");
+}
+function isDecisionRecord(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function json(value, seen = /* @__PURE__ */ new Set(), depth = 0) {
+  if (depth > 64) return false;
+  if (value === null || typeof value === "string" || typeof value === "boolean")
+    return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (typeof value !== "object" || !Array.isArray(value) && !isDecisionRecord(value) || seen.has(value))
+    return false;
+  seen.add(value);
+  const valid = Object.getOwnPropertySymbols(value).length === 0 && (Array.isArray(value) ? Array.from(value) : Object.values(value)).every(
+    (item) => json(item, seen, depth + 1)
+  );
+  seen.delete(value);
+  return valid;
+}
+function input(value) {
+  return (typeof value === "string" || Array.isArray(value) || isDecisionRecord(value)) && json(value);
+}
+function assertDecisionKeys(value, allowed, label) {
+  if (Object.keys(value).some((key) => !allowed.includes(key)))
+    decisionInputError(`${label} contains an unsupported field`);
+}
+function validateDecisionInput(options) {
+  if (!isDecisionRecord(options))
+    decisionInputError("Decisions options must be an object");
+  assertDecisionKeys(
+    options,
+    ["state", "questions", "images", "signal", "timeoutMs", "providerOptions"],
+    "Decisions options"
+  );
+  if (!input(options.state))
+    decisionInputError(
+      "state must be finite, acyclic JSON text, object, or array (maximum depth 64)"
+    );
+  if (!isDecisionRecord(options.questions) || Object.keys(options.questions).length === 0)
+    decisionInputError("questions must be a nonempty map");
+  for (const [id, question] of Object.entries(options.questions)) {
+    if (!id.length || !isDecisionRecord(question) || !input(question.instructions))
+      decisionInputError(
+        "Every question needs a nonempty ID and JSON-compatible instructions"
+      );
+    assertDecisionKeys(
+      question,
+      ["type", "instructions", "criteria"],
+      "Question"
+    );
+    if (question.type === "boolean") {
+      if (question.criteria !== void 0 && (!isDecisionRecord(question.criteria) || Object.entries(question.criteria).some(
+        ([key, value]) => !["true", "false"].includes(key) || !input(value)
+      )))
+        decisionInputError("Boolean criteria may describe only true and false");
+    } else if (question.type === "choice") {
+      if (!isDecisionRecord(question.criteria) || Object.keys(question.criteria).length < 2 || Object.keys(question.criteria).length > 255 || Object.entries(question.criteria).some(
+        ([key, value]) => !key.length || value !== null && !input(value)
+      ))
+        decisionInputError(
+          "Choice criteria require 2\u2013255 named options with JSON descriptions or null"
+        );
+    } else if (question.type === "score") {
+      if (!Array.isArray(question.criteria) || question.criteria.length < 2 || !Array.from(question.criteria).every(input))
+        decisionInputError(
+          "Score criteria require at least two ordered JSON descriptions"
+        );
+    } else
+      decisionInputError("Question type must be boolean, choice, or score");
+  }
+  if (options.timeoutMs !== void 0 && (!Number.isInteger(options.timeoutMs) || options.timeoutMs < 1 || options.timeoutMs > 2147483647))
+    decisionInputError("timeoutMs must be a positive 32-bit integer");
+  if (options.providerOptions !== void 0 && (!isDecisionRecord(options.providerOptions) || !json(options.providerOptions)))
+    decisionInputError("providerOptions must be a JSON object");
+  if (options.images !== void 0 && (!Array.isArray(options.images) || !Array.from(options.images).every(
+    (image) => isDecisionRecord(image) && image.data instanceof Uint8Array
+  )))
+    decisionInputError(
+      "Decision images must contain encoded bytes; hosted image URLs are unsupported"
+    );
+}
+function probability(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
+}
+function exactKeys(value, keys) {
+  return Object.keys(value).length === keys.length && keys.every((key) => Object.prototype.hasOwnProperty.call(value, key));
+}
+function validateDecisionResult(questions, result) {
+  if (!isDecisionRecord(result) || !isDecisionRecord(result.answers) || !exactKeys(result.answers, Object.keys(questions)))
+    decisionResponseError(
+      "Decisions must return exactly one answer per question"
+    );
+  const rounding = result.rounding;
+  let pError = 0, sError = 0;
+  if (rounding !== void 0) {
+    if (!isDecisionRecord(rounding) || ![rounding.probabilityDecimals, rounding.scoreDecimals].every(
+      (v) => typeof v === "number" && Number.isInteger(v) && v >= 0 && v <= 15
+    ))
+      decisionResponseError("Invalid decision rounding precision");
+    pError = 0.5 * 10 ** -rounding.probabilityDecimals;
+    sError = 0.5 * 10 ** -rounding.scoreDecimals;
+  }
+  const epsilon = 1e-6;
+  for (const [id, question] of Object.entries(questions)) {
+    const answer = result.answers[id];
+    if (!isDecisionRecord(answer))
+      decisionResponseError("Invalid decision answer");
+    if (answer.type === "refusal") continue;
+    if (answer.type !== question.type)
+      decisionResponseError("Decision answer type does not match its question");
+    if (answer.confidence !== void 0 && !probability(answer.confidence))
+      decisionResponseError(
+        "Confidence must be finite and between zero and one"
+      );
+    if (question.type === "boolean") {
+      if (!probability(answer.probability))
+        decisionResponseError(
+          "Boolean probability must be between zero and one"
+        );
+      continue;
+    }
+    const keys = question.type === "choice" ? Object.keys(question.criteria) : question.criteria.map((_, index) => String(index));
+    if (question.type === "choice" && (typeof answer.choice !== "string" || !keys.includes(answer.choice)))
+      decisionResponseError("Decision selected an unknown choice");
+    if (question.type === "score" && (typeof answer.score !== "number" || !Number.isFinite(answer.score) || answer.score < 0 || answer.score > keys.length - 1))
+      decisionResponseError("Decision score is outside its ordered levels");
+    if (answer.probabilities === void 0) continue;
+    const distribution = answer.probabilities;
+    if (!isDecisionRecord(distribution) || !exactKeys(distribution, keys) || !Object.values(distribution).every(probability))
+      decisionResponseError(
+        "Decision distribution must contain every option exactly once with finite probabilities"
+      );
+    const values = Object.values(distribution);
+    if (Math.abs(values.reduce((a, b) => a + b, 0) - 1) > epsilon + keys.length * pError)
+      decisionResponseError("Decision probabilities do not sum to one");
+    if (question.type === "choice") {
+      if (values.some(
+        (v) => v > distribution[answer.choice] + epsilon + 2 * pError
+      ))
+        decisionResponseError(
+          "Decision choice is not a highest-probability option"
+        );
+    } else {
+      const mean = keys.reduce(
+        (sum, key) => sum + Number(key) * distribution[key],
+        0
+      );
+      const tolerance = epsilon + sError + pError * keys.reduce((sum, key) => sum + Number(key), 0);
+      if (Math.abs(answer.score - mean) > tolerance)
+        decisionResponseError(
+          "Decision score does not match its probability-weighted levels"
+        );
+    }
+  }
+}
+
+// src/core/decisions.ts
+var decisionErrorMarker = /* @__PURE__ */ Symbol.for("yourgpt.llm-sdk.DecisionAPIError");
+var _a2, _b;
+var DecisionAPIError = class extends (_b = Error, _a2 = decisionErrorMarker, _b) {
+  constructor(message, code, status, requestId) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.requestId = requestId;
+    this.name = "DecisionAPIError";
+    this[_a2] = true;
+  }
+  /** Works across CJS/ESM and separately bundled provider entry points. */
+  static isInstance(error) {
+    return typeof error === "object" && error !== null && /* @__PURE__ */ Symbol.for("yourgpt.llm-sdk.DecisionAPIError") in error;
+  }
+  /** Advisory only: this SDK does not retry Decisions automatically. */
+  get retryable() {
+    return this.code === "network_error" || this.code === "http_error" && (this.status === 408 || this.status === 429 || this.status != null && this.status >= 500);
+  }
+};
+async function experimental_decide(options) {
+  const { model, ...request } = options;
+  validateDecisionInput(request);
+  request.signal?.throwIfAborted();
+  const result = await model.doDecide(request);
+  request.signal?.throwIfAborted();
+  validateDecisionResult(request.questions, result);
+  return result;
+}
+
 // src/core/stream-text.ts
 async function streamText(params) {
-  const { model, tools, maxSteps = 1, signal } = params;
+  const { model, tools, maxSteps = 1, signal: callerSignal } = params;
+  validateMaxSteps(maxSteps);
+  const controller = new AbortController();
+  const signal = controller.signal;
+  const relayAbort = () => controller.abort(callerSignal?.reason);
+  if (callerSignal?.aborted) relayAbort();
+  else callerSignal?.addEventListener("abort", relayAbort, { once: true });
+  const cleanup = () => callerSignal?.removeEventListener("abort", relayAbort);
+  const cancel = () => {
+    controller.abort();
+    cleanup();
+  };
   if (params.responseFormat && model.capabilities.supportsJsonMode === false) {
     console.warn(
       `[llm-sdk] ${model.provider}/${model.modelId} does not support structured output (responseFormat); the request will be sent but the provider may ignore it.`
@@ -390,6 +772,7 @@ async function streamText(params) {
       let stepProviderMetadata;
       const toolCalls = [];
       let stepFinishReason = "stop";
+      let receivedFinish = false;
       try {
         for await (const chunk of model.doStream({
           messages,
@@ -403,6 +786,9 @@ async function streamText(params) {
         })) {
           throwIfAborted(signal);
           switch (chunk.type) {
+            case "reasoning-delta":
+              yield chunk;
+              break;
             case "text-delta":
               stepText += chunk.text;
               fullText += chunk.text;
@@ -416,6 +802,11 @@ async function streamText(params) {
               };
               break;
             case "finish":
+              if (receivedFinish)
+                throw invalidProviderResponse(
+                  "Model stream returned multiple finish events"
+                );
+              receivedFinish = true;
               stepProviderMetadata = chunk.providerMetadata;
               finalProviderMetadata = chunk.providerMetadata;
               stepFinishReason = chunk.finishReason;
@@ -433,6 +824,12 @@ async function streamText(params) {
               return;
           }
         }
+        throwIfAborted(signal);
+        if (!receivedFinish)
+          throw invalidProviderResponse(
+            "Model stream ended without a finish event"
+          );
+        validateToolCalls(toolCalls);
       } catch (error) {
         yield {
           type: "error",
@@ -452,13 +849,13 @@ async function streamText(params) {
           role: "assistant",
           content: stepText || null,
           ...toolCalls.length ? { toolCalls } : {},
-          ...stepProviderMetadata ? { providerMetadata: stepProviderMetadata } : {}
+          ...stepProviderMetadata ? { providerMetadata: responseReplayMetadata(stepProviderMetadata) } : {}
         }
       ];
       if (toolCalls.length === 0 || !tools) break;
       for (const call of toolCalls) {
         throwIfAborted(signal);
-        const toolDef = tools[call.name];
+        const toolDef = Object.prototype.hasOwnProperty.call(tools, call.name) ? tools[call.name] : void 0;
         if (!toolDef) {
           const errorResult = { error: `Tool not found: ${call.name}` };
           yield {
@@ -499,7 +896,7 @@ async function streamText(params) {
             {
               role: "tool",
               toolCallId: call.id,
-              content: modelOutput ? "[Tool returned content]" : JSON.stringify(result),
+              content: modelOutput ? "[Tool returned content]" : JSON.stringify(result ?? null),
               ...modelOutput ? { modelOutput } : {}
             }
           ];
@@ -541,11 +938,17 @@ async function streamText(params) {
       pending = (async () => {
         try {
           const next = await source.next();
-          if (next.done) finished = true;
-          else parts.push(next.value);
+          if (next.done) {
+            finished = true;
+            cleanup();
+          } else {
+            parts.push(next.value);
+            if (next.value.type === "error") cleanup();
+          }
         } catch (error) {
           failure = error;
           finished = true;
+          cleanup();
         }
       })();
     }
@@ -596,7 +999,7 @@ async function streamText(params) {
       return consumeStream().then(() => finalFinishReason);
     },
     toTextStreamResponse(options) {
-      const stream = createTextStreamReadable(createTextStream());
+      const stream = createTextStreamReadable(createTextStream(), cancel);
       return new Response(stream, {
         status: options?.status ?? 200,
         headers: {
@@ -608,7 +1011,7 @@ async function streamText(params) {
       });
     },
     toDataStreamResponse(options) {
-      const stream = createDataStreamReadable(sharedStream());
+      const stream = createDataStreamReadable(sharedStream(), cancel);
       return new Response(stream, {
         status: options?.status ?? 200,
         headers: {
@@ -645,35 +1048,51 @@ function formatToolsForProvider2(tools, provider) {
       return formatToolsForOpenAI(tools);
   }
 }
-function createTextStreamReadable(textStream) {
+function createTextStreamReadable(textStream, abort) {
   const encoder = new TextEncoder();
+  const iterator = textStream[Symbol.asyncIterator]();
+  let cancelled = false;
   return new ReadableStream({
-    async start(controller) {
+    async pull(controller) {
       try {
-        for await (const text of textStream) {
-          controller.enqueue(encoder.encode(text));
-        }
-        controller.close();
+        const next = await iterator.next();
+        if (cancelled) return;
+        if (next.done) controller.close();
+        else controller.enqueue(encoder.encode(next.value));
       } catch (error) {
-        controller.error(error);
+        if (!cancelled) controller.error(error);
       }
+    },
+    cancel() {
+      cancelled = true;
+      abort();
+      void iterator.return?.().catch(() => {
+      });
     }
   });
 }
-function createDataStreamReadable(fullStream) {
+function createDataStreamReadable(fullStream, abort) {
   const encoder = new TextEncoder();
+  const iterator = fullStream[Symbol.asyncIterator]();
+  let cancelled = false;
   return new ReadableStream({
-    async start(controller) {
+    async pull(controller) {
       try {
-        for await (const part of fullStream) {
-          const data = JSON.stringify(part);
-          controller.enqueue(encoder.encode(`data: ${data}
-
-`));
+        const next = await iterator.next();
+        if (cancelled) return;
+        if (next.done) {
+          controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+          controller.close();
+          return;
         }
-        controller.enqueue(encoder.encode("data: [DONE]\n\n"));
-        controller.close();
+        if (next.value.type === "error") throw next.value.error;
+        controller.enqueue(
+          encoder.encode(`data: ${JSON.stringify(next.value)}
+
+`)
+        );
       } catch (error) {
+        if (cancelled) return;
         const errorData = JSON.stringify({
           type: "error",
           error: error instanceof Error ? error.message : String(error)
@@ -682,7 +1101,15 @@ function createDataStreamReadable(fullStream) {
 
 `));
         controller.close();
+        void iterator.return?.().catch(() => {
+        });
       }
+    },
+    cancel() {
+      cancelled = true;
+      abort();
+      void iterator.return?.().catch(() => {
+      });
     }
   });
 }
@@ -784,17 +1211,32 @@ function createTextStreamHeaders() {
   };
 }
 function formatSSEData(event) {
-  return `data: ${JSON.stringify(event)}
+  const safeEvent = { ...event };
+  if ("providerMetadata" in safeEvent)
+    safeEvent.providerMetadata = responseReplayMetadata(
+      safeEvent.providerMetadata
+    );
+  if (safeEvent.type === "done" && safeEvent.messages)
+    safeEvent.messages = safeEvent.messages.map((message) => ({
+      ...message,
+      ...message.providerMetadata ? { providerMetadata: responseReplayMetadata(message.providerMetadata) } : {}
+    }));
+  return `data: ${JSON.stringify(safeEvent)}
 
 `;
 }
-function createEventStream(generator) {
+function createEventStream(generator, options) {
   const encoder = new TextEncoder();
   return new ReadableStream({
     async start(controller) {
       try {
         for await (const event of generator) {
-          const data = formatSSEData(event);
+          let clientEvent = event;
+          if (event.type === "done" && !options?.includeUsage) {
+            const { usage: _usage, ...withoutUsage } = event;
+            clientEvent = withoutUsage;
+          }
+          const data = formatSSEData(clientEvent);
           controller.enqueue(encoder.encode(data));
         }
       } catch (error) {
@@ -935,7 +1377,9 @@ var StreamResult = class {
       ...createSSEHeaders(),
       ...options?.headers
     };
-    return new Response(createEventStream(this.generator), { headers });
+    return new Response(createEventStream(this.generator, options), {
+      headers
+    });
   }
   /**
    * Alias for toResponse() - returns SSE Response
@@ -1201,6 +1645,9 @@ var StreamResult = class {
         }
         break;
       }
+      case "error":
+        collected.error = { message: event.message, code: event.code };
+        break;
       case "done":
         if (event.messages) {
           collected.messages.push(...event.messages);
@@ -1667,7 +2114,7 @@ function buildToolResultForAI(tool2, result, args) {
       return aiContext ?? `[Tool ${tool2?.name ?? "unknown"} executed successfully]`;
     case "full":
     default:
-      const fullData = JSON.stringify(result);
+      const fullData = JSON.stringify(result ?? null);
       return aiContext ? `${aiContext}
 
 Full data: ${fullData}` : fullData;
@@ -2347,7 +2794,8 @@ var Runtime = class {
     const systemPrompt = request.systemPrompt || this.config.systemPrompt || "";
     let accumulatedText = "";
     const toolCalls = [];
-    let currentToolCall = null;
+    const pendingToolCalls = /* @__PURE__ */ new Map();
+    const endedToolIds = /* @__PURE__ */ new Set();
     const serverToolResults = [];
     const toolContextData = "toolContext" in this.config ? this.config.toolContext : void 0;
     let adapterProviderMetadata;
@@ -2372,142 +2820,151 @@ var Runtime = class {
       debug
     };
     const stream = this.adapter.stream(completionRequest);
-    for await (const event of stream) {
-      switch (event.type) {
-        case "message:start":
-          yield event;
-          break;
-        case "message:end":
-          yield event;
-          break;
-        case "message:delta":
-          accumulatedText += event.content;
-          yield event;
-          break;
-        case "action:start":
-          currentToolCall = {
-            id: event.id,
-            name: event.name,
-            args: "",
-            ...event.extra_content ? { extra_content: event.extra_content } : {}
-          };
-          if (debug) {
-            console.log(`[Copilot SDK] Tool call started: ${event.name}`);
+    try {
+      for await (const event of stream) {
+        throwIfAborted(signal);
+        switch (event.type) {
+          case "message:start":
+            yield event;
+            break;
+          case "message:end":
+            yield {
+              ...event,
+              providerMetadata: responseReplayMetadata(event.providerMetadata)
+            };
+            break;
+          case "message:delta":
+            accumulatedText += event.content;
+            yield event;
+            break;
+          case "action:start":
+            if (!event.id || !event.name || pendingToolCalls.has(event.id) || toolCalls.some((call) => call.id === event.id))
+              throw invalidProviderResponse(
+                "Tool calls have missing or duplicate identities"
+              );
+            pendingToolCalls.set(event.id, {
+              id: event.id,
+              name: event.name,
+              ...event.extra_content ? { extra_content: event.extra_content } : {}
+            });
+            if (debug) {
+              console.log(`[Copilot SDK] Tool call started: ${event.name}`);
+            }
+            yield event;
+            break;
+          case "action:args": {
+            const current = pendingToolCalls.get(event.id);
+            if (!current)
+              throw invalidProviderResponse(
+                "Tool arguments have no matching call"
+              );
+            toolCalls.push({
+              ...current,
+              args: parseToolArguments(event.args)
+            });
+            pendingToolCalls.delete(event.id);
+            yield event;
+            break;
           }
-          yield event;
-          break;
-        case "action:args":
-          if (currentToolCall) {
-            try {
-              const parsedArgs = JSON.parse(event.args || "{}");
+          case "action:end": {
+            const tc = toolCalls.find((t) => t.id === event.id);
+            const eventName = event.name;
+            if (!tc || eventName && eventName !== tc.name || endedToolIds.has(event.id))
+              throw invalidProviderResponse(
+                "Tool completion has no matching unexecuted call"
+              );
+            endedToolIds.add(event.id);
+            const toolName = tc.name;
+            const tool2 = toolName ? selectedToolMap.get(toolName) : void 0;
+            if (tool2?.location === "server" && tool2.handler) {
               if (debug) {
                 console.log(
-                  `[Copilot SDK] Tool args for ${currentToolCall.name}:`,
-                  parsedArgs
+                  `[Copilot SDK] Executing server-side tool: ${toolName}`
                 );
               }
-              toolCalls.push({
-                id: currentToolCall.id,
-                name: currentToolCall.name,
-                args: parsedArgs,
-                ...currentToolCall.extra_content ? { extra_content: currentToolCall.extra_content } : {}
-              });
-            } catch (e) {
-              console.error(
-                "[Copilot SDK] Failed to parse tool args:",
-                event.args,
-                e
+              const args = tc.args;
+              const toolContext = buildToolContext(
+                event.id,
+                signal,
+                request.threadId,
+                _httpRequest,
+                toolContextData
               );
-              toolCalls.push({
-                id: currentToolCall.id,
-                name: currentToolCall.name,
-                args: {},
-                ...currentToolCall.extra_content ? { extra_content: currentToolCall.extra_content } : {}
-              });
+              try {
+                throwIfAborted(signal);
+                const result = await tool2.handler(args, toolContext);
+                throwIfAborted(signal);
+                const modelOutput = resolveToolOutput(
+                  result,
+                  tool2.toModelOutput?.(result)
+                );
+                serverToolResults.push({
+                  id: event.id,
+                  name: toolName,
+                  args,
+                  result,
+                  modelOutput,
+                  tool: tool2
+                });
+                yield {
+                  type: "action:end",
+                  id: event.id,
+                  name: toolName,
+                  result,
+                  modelOutput
+                };
+              } catch (error) {
+                throwIfAborted(signal);
+                const errorResult = {
+                  success: false,
+                  error: error instanceof Error ? error.message : "Tool execution failed"
+                };
+                serverToolResults.push({
+                  id: event.id,
+                  name: toolName,
+                  args,
+                  result: errorResult,
+                  tool: tool2
+                });
+                yield {
+                  type: "action:end",
+                  id: event.id,
+                  name: toolName,
+                  error: error instanceof Error ? error.message : "Tool execution failed"
+                };
+              }
+            } else {
+              yield event;
             }
-            currentToolCall = null;
+            break;
           }
-          yield event;
-          break;
-        case "action:end": {
-          const toolName = event.name;
-          const tool2 = toolName ? selectedToolMap.get(toolName) : void 0;
-          if (tool2?.location === "server" && tool2.handler) {
-            if (debug) {
-              console.log(
-                `[Copilot SDK] Executing server-side tool: ${toolName}`
-              );
-            }
-            const tc = toolCalls.find((t) => t.id === event.id);
-            const args = tc?.args ?? {};
-            const toolContext = buildToolContext(
-              event.id,
-              signal,
-              request.threadId,
-              _httpRequest,
-              toolContextData
+          case "citation":
+            yield event;
+            break;
+          case "error":
+            yield event;
+            return;
+          // Exit on error
+          case "done":
+            adapterProviderMetadata = responseReplayMetadata(
+              event.providerMetadata
             );
-            try {
-              const result = await tool2.handler(args, toolContext);
-              const modelOutput = resolveToolOutput(
-                result,
-                tool2.toModelOutput?.(result)
-              );
-              serverToolResults.push({
-                id: event.id,
-                name: toolName,
-                args,
-                result,
-                modelOutput,
-                tool: tool2
-              });
-              yield {
-                type: "action:end",
-                id: event.id,
-                name: toolName,
-                result,
-                modelOutput
-              };
-            } catch (error) {
-              const errorResult = {
-                success: false,
-                error: error instanceof Error ? error.message : "Tool execution failed"
-              };
-              serverToolResults.push({
-                id: event.id,
-                name: toolName,
-                args,
-                result: errorResult,
-                tool: tool2
-              });
-              yield {
-                type: "action:end",
-                id: event.id,
-                name: toolName,
-                error: error instanceof Error ? error.message : "Tool execution failed"
-              };
+            if (event.usage) {
+              adapterUsage = event.usage;
             }
-          } else {
+            break;
+          default:
             yield event;
-          }
-          break;
         }
-        case "citation":
-          yield event;
-          break;
-        case "error":
-          yield event;
-          return;
-        // Exit on error
-        case "done":
-          adapterProviderMetadata = event.providerMetadata;
-          if (event.usage) {
-            adapterUsage = event.usage;
-          }
-          break;
-        default:
-          yield event;
       }
+      throwIfAborted(signal);
+      if (pendingToolCalls.size || toolCalls.some((call) => !endedToolIds.has(call.id)))
+        throw invalidProviderResponse(
+          "Stream ended with incomplete tool calls"
+        );
+    } catch (error) {
+      yield providerErrorEvent(error, "RUNTIME_STREAM_ERROR");
+      return;
     }
     if (toolCalls.length > 0) {
       if (debug) {
@@ -2616,7 +3073,18 @@ var Runtime = class {
           nextToolSearchState,
           _iteration + 1
         )) {
-          yield event;
+          if (event.type === "done" && adapterUsage) {
+            const promptTokens = adapterUsage.prompt_tokens + (event.usage?.prompt_tokens ?? 0);
+            const completionTokens = adapterUsage.completion_tokens + (event.usage?.completion_tokens ?? 0);
+            yield {
+              ...event,
+              usage: {
+                prompt_tokens: promptTokens,
+                completion_tokens: completionTokens,
+                total_tokens: (adapterUsage.total_tokens ?? adapterUsage.prompt_tokens + adapterUsage.completion_tokens) + (event.usage?.total_tokens ?? (event.usage?.prompt_tokens ?? 0) + (event.usage?.completion_tokens ?? 0))
+              }
+            };
+          } else yield event;
         }
         return;
       }
@@ -2752,6 +3220,8 @@ var Runtime = class {
       };
       try {
         const result = await this.adapter.complete(completionRequest);
+        throwIfAborted(signal);
+        validateToolCalls(result.toolCalls);
         if (result.usage) {
           accumulatedUsage.prompt_tokens += result.usage.promptTokens;
           accumulatedUsage.completion_tokens += result.usage.completionTokens;
@@ -2771,7 +3241,7 @@ var Runtime = class {
         }
         yield {
           type: "message:end",
-          providerMetadata: result.providerMetadata
+          providerMetadata: responseReplayMetadata(result.providerMetadata)
         };
         if (result.toolCalls.length > 0) {
           const serverToolCalls = [];
@@ -2805,6 +3275,7 @@ var Runtime = class {
           const serverToolResults = [];
           const toolContextData = "toolContext" in this.config ? this.config.toolContext : void 0;
           for (const tc of serverToolCalls) {
+            throwIfAborted(signal);
             const tool2 = selectedToolMap.get(tc.name);
             if (tool2?.handler) {
               if (debug) {
@@ -2819,6 +3290,7 @@ var Runtime = class {
               );
               try {
                 const toolResult = await tool2.handler(tc.args, toolContext);
+                throwIfAborted(signal);
                 const modelOutput = resolveToolOutput(
                   toolResult,
                   tool2.toModelOutput?.(toolResult)
@@ -2839,6 +3311,7 @@ var Runtime = class {
                   modelOutput
                 };
               } catch (error) {
+                throwIfAborted(signal);
                 const errorResult = {
                   success: false,
                   error: error instanceof Error ? error.message : "Tool execution failed"
@@ -2872,7 +3345,11 @@ var Runtime = class {
             const assistantMessage = {
               role: "assistant",
               content: result.content || null,
-              ...result.providerMetadata ? { providerMetadata: result.providerMetadata } : {},
+              ...result.providerMetadata ? {
+                providerMetadata: responseReplayMetadata(
+                  result.providerMetadata
+                )
+              } : {},
               tool_calls: result.toolCalls.map((tc) => ({
                 id: tc.id,
                 type: "function",
@@ -2902,7 +3379,11 @@ var Runtime = class {
             const assistantWithToolCalls = {
               role: "assistant",
               content: result.content || null,
-              ...result.providerMetadata ? { providerMetadata: result.providerMetadata } : {},
+              ...result.providerMetadata ? {
+                providerMetadata: responseReplayMetadata(
+                  result.providerMetadata
+                )
+              } : {},
               tool_calls: result.toolCalls.map((tc) => ({
                 id: tc.id,
                 type: "function",
@@ -2934,7 +3415,11 @@ var Runtime = class {
             const assistantMessage = {
               role: "assistant",
               content: result.content || null,
-              ...result.providerMetadata ? { providerMetadata: result.providerMetadata } : {},
+              ...result.providerMetadata ? {
+                providerMetadata: responseReplayMetadata(
+                  result.providerMetadata
+                )
+              } : {},
               tool_calls: clientToolCalls.map((tc) => ({
                 id: tc.id,
                 type: "function",
@@ -2964,7 +3449,11 @@ var Runtime = class {
           newMessages.push({
             role: "assistant",
             content: result.content,
-            ...result.providerMetadata ? { providerMetadata: result.providerMetadata } : {}
+            ...result.providerMetadata ? {
+              providerMetadata: responseReplayMetadata(
+                result.providerMetadata
+              )
+            } : {}
           });
         }
         if (debug) {
@@ -3485,20 +3974,11 @@ function parseToolCalls(response) {
   const message = choices?.[0]?.message;
   const toolCalls = message?.tool_calls || [];
   return toolCalls.map((tc) => {
-    let input = {};
-    try {
-      input = JSON.parse(tc.function.arguments);
-    } catch (e) {
-      console.error(
-        "Failed to parse tool arguments:",
-        tc.function.arguments,
-        e
-      );
-    }
+    const input2 = parseToolArguments(tc.function.arguments);
     return {
       id: tc.id,
       name: tc.function.name,
-      input
+      input: input2
     };
   });
 }
@@ -3579,7 +4059,7 @@ function parseToolCalls2(response) {
   return content.filter((block) => block?.type === "tool_use").map((block) => ({
     id: block.id,
     name: block.name,
-    input: block.input || {}
+    input: parseToolArguments(block.input)
   }));
 }
 function extractTextContent2(response) {
@@ -3913,7 +4393,11 @@ async function* runAgentLoop(options) {
         providerTools,
         providerToolOptions
       );
+      throwIfAborted(signal);
       const toolCalls = formatter.parseToolCalls(response);
+      validateToolCalls(
+        toolCalls.map((call) => ({ ...call, args: call.input }))
+      );
       const textContent = formatter.extractTextContent(response);
       if (textContent) {
         const messageId = generateMessageId();
@@ -3928,15 +4412,13 @@ async function* runAgentLoop(options) {
             toolCalls.map((tc) => tc.name)
           );
         }
-        const results = await executeToolCalls(
+        const results = yield* executeToolCalls(
           toolCalls,
           effectiveSelectedTools,
           executeServerTool,
           waitForClientToolResult,
-          function* (event) {
-            yield event;
-          },
-          debug
+          debug,
+          signal
         );
         for (const result of results) {
           const toolCall = toolCalls.find((tc) => tc.id === result.toolCallId);
@@ -4025,9 +4507,10 @@ function buildConversation(messages, systemPrompt) {
   }
   return conversation;
 }
-async function executeToolCalls(toolCalls, tools, executeServerTool, waitForClientToolResult, emitEvent, debug) {
+async function* executeToolCalls(toolCalls, tools, executeServerTool, waitForClientToolResult, debug, signal) {
   const results = [];
   for (const toolCall of toolCalls) {
+    throwIfAborted(signal);
     const tool2 = tools.find((t) => t.name === toolCall.name);
     if (!tool2) {
       if (debug) {
@@ -4044,22 +4527,26 @@ async function executeToolCalls(toolCalls, tools, executeServerTool, waitForClie
       });
       continue;
     }
-    emitEvent?.({
+    yield {
       type: "action:start",
       id: toolCall.id,
       name: toolCall.name,
       hidden: tool2.hidden ?? false
-    });
-    emitEvent?.({
+    };
+    yield {
       type: "action:args",
       id: toolCall.id,
       args: JSON.stringify(toolCall.input)
-    });
+    };
     try {
       let response;
+      throwIfAborted(signal);
       if (tool2.location === "server") {
         if (tool2.handler) {
-          response = await tool2.handler(toolCall.input);
+          response = await tool2.handler(toolCall.input, {
+            signal,
+            toolCallId: toolCall.id
+          });
         } else if (executeServerTool) {
           response = await executeServerTool(toolCall.name, toolCall.input);
         } else {
@@ -4082,12 +4569,13 @@ async function executeToolCalls(toolCalls, tools, executeServerTool, waitForClie
           };
         }
       }
-      emitEvent?.({
+      throwIfAborted(signal);
+      yield {
         type: "action:end",
         id: toolCall.id,
         name: toolCall.name,
         result: response
-      });
+      };
       results.push({
         toolCallId: toolCall.id,
         content: JSON.stringify(response),
@@ -4095,13 +4583,14 @@ async function executeToolCalls(toolCalls, tools, executeServerTool, waitForClie
         error: response.error
       });
     } catch (error) {
+      throwIfAborted(signal);
       const errorMessage = error instanceof Error ? error.message : "Tool execution failed";
-      emitEvent?.({
+      yield {
         type: "action:end",
         id: toolCall.id,
         name: toolCall.name,
         error: errorMessage
-      });
+      };
       results.push({
         toolCallId: toolCall.id,
         content: JSON.stringify({
@@ -4118,17 +4607,17 @@ async function executeToolCalls(toolCalls, tools, executeServerTool, waitForClie
 
 // src/core/audio.ts
 var audioErrorMarker = /* @__PURE__ */ Symbol.for("@yourgpt/llm-sdk/AudioAPIError");
-var _a;
+var _a3;
 var AudioAPIError = class extends Error {
   constructor(message, code, status, requestId) {
     super(message);
     this.code = code;
     this.status = status;
     this.requestId = requestId;
-    this[_a] = true;
+    this[_a3] = true;
     this.name = "AudioAPIError";
   }
-  static [(_a = audioErrorMarker, Symbol.hasInstance)](value) {
+  static [(_a3 = audioErrorMarker, Symbol.hasInstance)](value) {
     return !!value && typeof value === "object" && value[audioErrorMarker] === true;
   }
 };
@@ -4166,7 +4655,9 @@ async function transcribe({
 exports.AudioAPIError = AudioAPIError;
 exports.DEFAULT_CAPABILITIES = DEFAULT_CAPABILITIES;
 exports.DEFAULT_MAX_ITERATIONS = DEFAULT_MAX_ITERATIONS;
+exports.DecisionAPIError = DecisionAPIError;
 exports.GenerateResult = GenerateResult;
+exports.MediaAPIError = MediaAPIError;
 exports.Runtime = Runtime;
 exports.StreamResult = StreamResult;
 exports.buildProviderToolOptions = buildProviderToolOptions;
@@ -4182,11 +4673,13 @@ exports.createSSEResponse = createSSEResponse;
 exports.createStreamResult = createStreamResult;
 exports.createTextStreamHeaders = createTextStreamHeaders;
 exports.createTextStreamResponse = createTextStreamResponse;
+exports.experimental_decide = experimental_decide;
 exports.extractInputMessages = extractInputMessages;
 exports.formatSSEData = formatSSEData;
 exports.formatToolsForAnthropic = formatToolsForAnthropic;
 exports.formatToolsForGoogle = formatToolsForGoogle;
 exports.formatToolsForOpenAI = formatToolsForOpenAI;
+exports.generateImage = generateImage;
 exports.generateMessageId = generateMessageId;
 exports.generateSpeech = generateSpeech;
 exports.generateText = generateText;