@nyte-ai/ai 0.0.0-stage → 0.0.18

package/dist/chunks/account-limits-cache-fbkaq46e.js

@@ -0,0 +1,113 @@
+// src/utils/json-parse.ts
+import { parse as partialParse } from "partial-json";
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var ToolArgumentsSchema = Type.Record(Type.String(), Type.Unknown());
+var VALID_JSON_ESCAPES = new Set(['"', "\\", "/", "b", "f", "n", "r", "t", "u"]);
+function escapeControlCharacter(char) {
+  switch (char) {
+    case "\b":
+      return "\\b";
+    case "\f":
+      return "\\f";
+    case `
+`:
+      return "\\n";
+    case "\r":
+      return "\\r";
+    case "\t":
+      return "\\t";
+    default:
+      return `\\u${char.codePointAt(0)?.toString(16).padStart(4, "0") ?? "0000"}`;
+  }
+}
+function repairJson2(json) {
+  let repaired = "";
+  let inString = false;
+  for (let index = 0;index < json.length; index++) {
+    const char = json[index];
+    if (!inString) {
+      repaired += char;
+      if (char === '"') {
+        inString = true;
+      }
+      continue;
+    }
+    if (char === '"') {
+      repaired += char;
+      inString = false;
+      continue;
+    }
+    if (char === "\\") {
+      const nextChar = json[index + 1];
+      if (nextChar === undefined) {
+        repaired += "\\\\";
+        continue;
+      }
+      if (nextChar === "u") {
+        const unicodeDigits = json.slice(index + 2, index + 6);
+        if (/^[0-9a-fA-F]{4}$/.test(unicodeDigits)) {
+          repaired += `\\u${unicodeDigits}`;
+          index += 5;
+          continue;
+        }
+      }
+      if (VALID_JSON_ESCAPES.has(nextChar)) {
+        repaired += `\\${nextChar}`;
+        index += 1;
+        continue;
+      }
+      repaired += "\\\\";
+      continue;
+    }
+    const codePoint = char.codePointAt(0) ?? 32;
+    repaired += codePoint <= 31 ? escapeControlCharacter(char) : char;
+  }
+  return repaired;
+}
+function parseStreamingJson2(partialJson) {
+  if (!partialJson || partialJson.trim() === "")
+    return {};
+  let value;
+  try {
+    value = JSON.parse(partialJson);
+  } catch {
+    const repaired = repairJson2(partialJson);
+    try {
+      value = JSON.parse(repaired);
+    } catch {
+      try {
+        value = partialParse(repaired);
+      } catch {
+        return {};
+      }
+    }
+  }
+  return Value.Check(ToolArgumentsSchema, value) ? value : {};
+}
+function parseToolCallArguments2(json) {
+  if (!json || json.trim() === "")
+    return { arguments: {} };
+  let value;
+  try {
+    value = JSON.parse(json);
+  } catch (error) {
+    try {
+      value = JSON.parse(repairJson2(json));
+    } catch {
+      return unparsedToolCallArguments(error instanceof Error ? error.message : String(error), json);
+    }
+  }
+  return Value.Check(ToolArgumentsSchema, value) ? { arguments: value } : unparsedToolCallArguments("Tool arguments must be a JSON object", json);
+}
+function unfinishedToolCallArguments2(json) {
+  return unparsedToolCallArguments("The response ended before this tool call finished", json);
+}
+function unparsedToolCallArguments(reason, json) {
+  return { arguments: {}, argumentsError: `${reason}
+
+Received arguments:
+${json}` };
+}
+
+export { repairJson2, parseStreamingJson2, parseToolCallArguments2, unfinishedToolCallArguments2 };

package/dist/chunks/account-limits-cache-fdwad56n.js

@@ -0,0 +1,399 @@
+import {
+  shortHash2
+} from "./account-limits-cache-0af5gqeg.js";
+import {
+  sanitizeSurrogates2
+} from "./account-limits-cache-eqwweapz.js";
+import {
+  getSystemMessageText2,
+  renderSystemMessageUpdate2
+} from "./account-limits-cache-b4edaybk.js";
+import {
+  resolveTranscript2,
+  resolveTranscriptTools2
+} from "./account-limits-cache-6250ykn6.js";
+import {
+  getJsonSchemaToolParameters2,
+  getGrammarToolInput2,
+  resolveJsonSchemaStrictSampling2,
+  resolveGrammarConstrainedSampling2
+} from "./account-limits-cache-h92bzz1j.js";
+import {
+  transformMessages2
+} from "./account-limits-cache-8qzk56vj.js";
+import {
+  parseOpenAIReasoningDetails2,
+  parseLegacyEncryptedReasoningDetail2,
+  OpenAICompletionsReasoningFieldSchema2,
+  parseCopilotReasoningOpaque2
+} from "./account-limits-cache-hj1h48sc.js";
+
+// src/api/openai-completions-convert.ts
+import { Value } from "typebox/value";
+var DEFAULT_COMPAT = {
+  supportsStore: true,
+  supportsDeveloperRole: true,
+  supportsReasoningEffort: true,
+  supportsUsageInStreaming: true,
+  supportsFinishReason: true,
+  maxTokensField: "max_completion_tokens",
+  requiresToolResultName: false,
+  requiresAssistantAfterToolResult: false,
+  requiresThinkingAsText: false,
+  requiresReasoningContentOnAssistantMessages: false,
+  thinkingFormat: "openai",
+  openRouterRouting: {},
+  vercelGatewayRouting: {},
+  chatTemplateKwargs: {},
+  chatTemplateArgs: {},
+  zaiToolStream: false,
+  supportsStrictMode: false,
+  supportsOpenAIGrammarTools: false,
+  sendSessionAffinityHeaders: false,
+  sessionAffinityFormat: "openai",
+  supportsLongCacheRetention: true
+};
+function resolveCompat2(model) {
+  return { ...DEFAULT_COMPAT, ...model.compat };
+}
+function kimiToolSystemMessage(tools, compat) {
+  return {
+    role: "system",
+    tools: convertTools2(tools, compat)
+  };
+}
+function getToolsByName(tools, names) {
+  if (!tools)
+    return [];
+  const toolsByName = new Map(tools.map((tool) => [tool.name, tool]));
+  return Array.from(names).map((name) => toolsByName.get(name)).filter((tool) => tool !== undefined);
+}
+function getCompatCacheControl2(compat, cacheRetention) {
+  if (compat.cacheControlFormat !== "anthropic" || cacheRetention === "none") {
+    return;
+  }
+  const cacheControl = { type: "ephemeral" };
+  if (cacheRetention === "long" && compat.supportsLongCacheRetention)
+    cacheControl.ttl = "1h";
+  return cacheControl;
+}
+function applyAnthropicCacheControl2(messages, tools, cacheControl) {
+  addCacheControlToSystemPrompt(messages, cacheControl);
+  addCacheControlToLastTool(tools, cacheControl);
+  addCacheControlToLastConversationMessage(messages, cacheControl);
+}
+function addCacheControlToSystemPrompt(messages, cacheControl) {
+  for (const message of messages) {
+    if (message.role === "system" || message.role === "developer") {
+      addCacheControlToTextContent(message, cacheControl);
+      return;
+    }
+  }
+}
+function addCacheControlToLastConversationMessage(messages, cacheControl) {
+  for (let i = messages.length - 1;i >= 0; i--) {
+    const message = messages[i];
+    if (message.role === "user" || message.role === "assistant" || message.role === "tool") {
+      if (addCacheControlToMessage(message, cacheControl)) {
+        return;
+      }
+    }
+  }
+}
+function addCacheControlToLastTool(tools, cacheControl) {
+  if (!tools || tools.length === 0) {
+    return;
+  }
+  Object.assign(tools[tools.length - 1], { cache_control: cacheControl });
+}
+function addCacheControlToMessage(message, cacheControl) {
+  if (message.role === "user" || message.role === "assistant" || message.role === "tool") {
+    return addCacheControlToTextContent(message, cacheControl);
+  }
+  return false;
+}
+function addCacheControlToTextContent(message, cacheControl) {
+  const content = message.content;
+  if (Array.isArray(content)) {
+    const textPart = content.findLast((part) => part?.type === "text");
+    if (textPart === undefined)
+      return false;
+    Object.assign(textPart, { cache_control: cacheControl });
+    return true;
+  }
+  if (!content) {
+    return false;
+  }
+  const textPart = {
+    type: "text",
+    text: content,
+    cache_control: cacheControl
+  };
+  message.content = [textPart];
+  return true;
+}
+function normalizeToolCallId(id, provider) {
+  if (id.includes("|")) {
+    const [rawCallId, ...itemParts] = id.split("|");
+    const callId = rawCallId.replace(/[^a-zA-Z0-9_-]/g, "_");
+    const itemId = itemParts.join("|").replace(/[^a-zA-Z0-9_-]/g, "_");
+    const combinedId = itemId.length > 0 ? `${callId}_${itemId}` : callId;
+    if (combinedId.length <= 40) {
+      return combinedId;
+    }
+    const hash = shortHash2(id).slice(0, 8);
+    const prefix = callId.slice(0, Math.max(1, 40 - hash.length - 1));
+    return `${prefix}_${hash}`;
+  }
+  if (provider === "openai")
+    return id.length > 40 ? id.slice(0, 40) : id;
+  return id;
+}
+function convertMessages2(model, context, compat, options) {
+  const normalizedContext = resolveTranscript2(context, compat.supportsMidConvoSystemMessages);
+  const params = [];
+  const transformedMessages = transformMessages2(normalizedContext.messages, model, (id) => normalizeToolCallId(id, model.provider));
+  const transcriptTools = resolveTranscriptTools2(normalizedContext.messages, compat.supportsMidConvoSystemMessages === true && compat.supportsMidConvoToolAdditions === true);
+  const requestTools = compat.deferredToolsMode === "kimi" ? transcriptTools.requestTools : [];
+  const instructionRole = model.reasoning && compat.supportsDeveloperRole ? "developer" : "system";
+  let lastRole = null;
+  for (let i = 0;i < transformedMessages.length; i++) {
+    const msg = transformedMessages[i];
+    if (compat.requiresAssistantAfterToolResult && lastRole === "toolResult" && msg.role === "user") {
+      params.push({
+        role: "assistant",
+        content: "I have processed the tool results."
+      });
+    }
+    if (msg.role === "system") {
+      const addedTools = i > 0 && transcriptTools.anchorsAdditions ? msg.toolsAdded ?? [] : [];
+      if (addedTools.length > 0) {
+        params.push(kimiToolSystemMessage(addedTools, compat));
+      }
+      const text = i === 0 ? getSystemMessageText2(msg) : renderSystemMessageUpdate2(msg);
+      if (text.length > 0) {
+        params.push({ role: instructionRole, content: sanitizeSurrogates2(text) });
+      }
+    } else if (msg.role === "user") {
+      if (!Array.isArray(msg.content)) {
+        params.push({
+          role: "user",
+          content: sanitizeSurrogates2(msg.content)
+        });
+      } else {
+        const content = msg.content.filter((item) => item.type !== "text" || item.text.length > 0).map((item) => {
+          if (item.type === "text") {
+            return {
+              type: "text",
+              text: sanitizeSurrogates2(item.text)
+            };
+          } else {
+            return {
+              type: "image_url",
+              image_url: {
+                url: `data:${item.mimeType};base64,${item.data}`
+              }
+            };
+          }
+        });
+        if (content.length === 0)
+          continue;
+        params.push({
+          role: "user",
+          content
+        });
+      }
+    } else if (msg.role === "assistant") {
+      const assistantMsg = {
+        role: "assistant",
+        content: compat.requiresAssistantAfterToolResult ? "" : null
+      };
+      const assistantTextParts = msg.content.filter((block) => block.type === "text").filter((block) => block.text.trim().length > 0).map((block) => ({
+        type: "text",
+        text: sanitizeSurrogates2(block.text)
+      }));
+      const assistantText = assistantTextParts.map((part) => part.text).join("");
+      const thinkingBlocks = msg.content.filter((block) => block.type === "thinking");
+      const toolCalls = msg.content.filter((block) => block.type === "toolCall");
+      const signedReasoningDetails = thinkingBlocks.map((block) => parseOpenAIReasoningDetails2(block.thinkingSignature)).find((details) => details !== undefined);
+      const legacyReasoningDetails = toolCalls.map((toolCall) => parseLegacyEncryptedReasoningDetail2(toolCall.thoughtSignature)).filter((detail) => detail !== undefined);
+      const preservedReasoningDetails = signedReasoningDetails ?? (legacyReasoningDetails.length > 0 ? legacyReasoningDetails : undefined);
+      const nonEmptyThinkingBlocks = thinkingBlocks.filter((block) => block.thinking.trim().length > 0);
+      const copilotReasoningOpaque = model.provider === "github-copilot" ? thinkingBlocks.map((block) => parseCopilotReasoningOpaque2(block.thinkingSignature)).find((opaque) => opaque !== undefined) : undefined;
+      if (model.provider === "github-copilot") {
+        if (assistantText.length > 0) {
+          assistantMsg.content = assistantText;
+        }
+        if (copilotReasoningOpaque !== undefined) {
+          assistantMsg.reasoning_opaque = copilotReasoningOpaque;
+          if (nonEmptyThinkingBlocks.length > 0) {
+            assistantMsg.reasoning_text = nonEmptyThinkingBlocks.map((block) => block.thinking).join(`
+`);
+          }
+        }
+      } else if (nonEmptyThinkingBlocks.length > 0) {
+        if (compat.requiresThinkingAsText) {
+          const thinkingText = nonEmptyThinkingBlocks.map((block) => sanitizeSurrogates2(block.thinking)).join(`
+
+`);
+          assistantMsg.content = [{ type: "text", text: thinkingText }, ...assistantTextParts];
+        } else {
+          if (assistantText.length > 0) {
+            assistantMsg.content = assistantText;
+          }
+          if (!preservedReasoningDetails) {
+            let signature = nonEmptyThinkingBlocks[0].thinkingSignature;
+            if (model.provider === "opencode-go" && signature === "reasoning") {
+              signature = "reasoning_content";
+            }
+            if (signature && Value.Check(OpenAICompletionsReasoningFieldSchema2, signature)) {
+              assistantMsg[signature] = nonEmptyThinkingBlocks.map((block) => block.thinking).join(`
+`);
+            }
+          }
+        }
+      } else if (assistantText.length > 0) {
+        assistantMsg.content = assistantText;
+      }
+      if (toolCalls.length > 0) {
+        assistantMsg.tool_calls = toolCalls.map((tc) => {
+          const customInputProperty = options?.grammarToolInputProperties?.get(tc.name);
+          if (customInputProperty !== undefined) {
+            return {
+              id: tc.id,
+              type: "custom",
+              custom: {
+                name: tc.name,
+                input: sanitizeSurrogates2(getGrammarToolInput2(tc.name, tc.arguments, customInputProperty))
+              }
+            };
+          }
+          return {
+            id: tc.id,
+            type: "function",
+            function: {
+              name: tc.name,
+              arguments: JSON.stringify(tc.arguments)
+            }
+          };
+        });
+      }
+      if (preservedReasoningDetails) {
+        assistantMsg.reasoning_details = preservedReasoningDetails;
+      }
+      if (compat.requiresReasoningContentOnAssistantMessages && model.reasoning && assistantMsg.reasoning_content === undefined) {
+        assistantMsg.reasoning_content = "";
+      }
+      const content = assistantMsg.content;
+      const hasContent = content !== null && content !== undefined && content.length > 0;
+      if (!hasContent && !assistantMsg.tool_calls) {
+        continue;
+      }
+      params.push(assistantMsg);
+    } else if (msg.role === "toolResult") {
+      const imageBlocks = [];
+      const deferredToolNames = new Set;
+      let j = i;
+      for (;j < transformedMessages.length; j++) {
+        const toolMsg = transformedMessages[j];
+        if (toolMsg.role !== "toolResult")
+          break;
+        const textResult = toolMsg.content.filter((block) => block.type === "text").map((block) => block.text).join(`
+`);
+        const hasImages = toolMsg.content.some((c) => c.type === "image");
+        const hasText = textResult.length > 0;
+        const toolResultText = hasText ? textResult : hasImages ? "(see attached image)" : "(no tool output)";
+        const toolResultMsg = {
+          role: "tool",
+          content: sanitizeSurrogates2(toolResultText),
+          tool_call_id: toolMsg.toolCallId
+        };
+        if (compat.requiresToolResultName && toolMsg.toolName) {
+          toolResultMsg.name = toolMsg.toolName;
+        }
+        params.push(toolResultMsg);
+        if (compat.deferredToolsMode === "kimi") {
+          for (const name of toolMsg.addedToolNames ?? []) {
+            deferredToolNames.add(name);
+          }
+        }
+        if (hasImages && model.input.includes("image")) {
+          for (const block of toolMsg.content) {
+            if (block.type === "image") {
+              imageBlocks.push({
+                type: "image_url",
+                image_url: {
+                  url: `data:${block.mimeType};base64,${block.data}`
+                }
+              });
+            }
+          }
+        }
+      }
+      i = j - 1;
+      if (imageBlocks.length > 0) {
+        if (compat.requiresAssistantAfterToolResult) {
+          params.push({
+            role: "assistant",
+            content: "I have processed the tool results."
+          });
+        }
+        params.push({
+          role: "user",
+          content: [
+            {
+              type: "text",
+              text: "Attached image(s) from tool result:"
+            },
+            ...imageBlocks
+          ]
+        });
+        lastRole = "user";
+      } else {
+        lastRole = "toolResult";
+      }
+      if (deferredToolNames.size > 0) {
+        const deferredTools = getToolsByName(requestTools, deferredToolNames);
+        if (deferredTools.length > 0) {
+          params.push(kimiToolSystemMessage(deferredTools, compat));
+        }
+      }
+      continue;
+    }
+    lastRole = msg.role;
+  }
+  return params;
+}
+function convertTools2(tools, compat) {
+  return tools.map((tool) => {
+    const grammar = resolveGrammarConstrainedSampling2(tool, compat.supportsOpenAIGrammarTools);
+    if (grammar) {
+      return {
+        type: "custom",
+        custom: {
+          name: tool.name,
+          description: tool.description,
+          format: {
+            type: "grammar",
+            grammar: {
+              syntax: grammar.format,
+              definition: grammar.definition
+            }
+          }
+        }
+      };
+    }
+    const strict = resolveJsonSchemaStrictSampling2(tool, compat.supportsStrictMode !== false);
+    return {
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: getJsonSchemaToolParameters2(tool, strict),
+        ...compat.supportsStrictMode !== false && { strict: strict ?? false }
+      }
+    };
+  });
+}
+
+export { resolveCompat2, getCompatCacheControl2, applyAnthropicCacheControl2, convertMessages2, convertTools2 };

package/dist/chunks/account-limits-cache-fht68jp2.js

@@ -0,0 +1,22 @@
+// src/providers/opencode-headers.ts
+var OPENCODE_SESSION_HEADER = "x-opencode-session";
+function withSessionHeader(options) {
+  if (!options?.sessionId)
+    return options;
+  const overridden = Object.keys(options.headers ?? {}).some((key) => key.toLowerCase() === OPENCODE_SESSION_HEADER);
+  if (overridden)
+    return options;
+  return {
+    ...options,
+    headers: { ...options.headers, [OPENCODE_SESSION_HEADER]: options.sessionId }
+  };
+}
+function withOpenCodeSessionHeader2(streams) {
+  return {
+    ...streams,
+    stream: (model, context, options) => streams.stream(model, context, withSessionHeader(options)),
+    streamSimple: (model, context, options) => streams.streamSimple(model, context, withSessionHeader(options))
+  };
+}
+
+export { withOpenCodeSessionHeader2 };

package/dist/chunks/account-limits-cache-fp03ztsw.js

@@ -0,0 +1,17 @@
+import {
+  providerRequest2
+} from "./account-limits-cache-031vfpt3.js";
+
+// src/api/deferred.ts
+async function compactOpenAICodexContext2(selected, context, selectedOptions) {
+  const api = await import("../src/api/openai-codex-compact.js");
+  const { model, options } = providerRequest2(selected, selectedOptions);
+  return api.compactOpenAICodexContext(model, context, options);
+}
+async function compactOpenAIResponsesContext2(selected, context, selectedOptions) {
+  const api = await import("../src/api/openai-responses.js");
+  const { model, options } = providerRequest2(selected, selectedOptions);
+  return api.compactOpenAIResponsesContext(model, context, options);
+}
+
+export { compactOpenAICodexContext2, compactOpenAIResponsesContext2 };

package/dist/chunks/account-limits-cache-fsktnetm.js

@@ -0,0 +1,69 @@
+import {
+  normalizeProviderError2,
+  formatProviderError2
+} from "./account-limits-cache-zcbkmrvy.js";
+import {
+  AssistantMessageEventStream2
+} from "./account-limits-cache-a6cgeagz.js";
+
+// src/api/assistant-stream.ts
+function emptyCost2() {
+  return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 };
+}
+function emptyUsage() {
+  return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: emptyCost2() };
+}
+function emptyAssistantOutput2(model) {
+  return {
+    role: "assistant",
+    content: [],
+    api: model.api,
+    provider: model.provider,
+    model: model.id,
+    usage: emptyUsage(),
+    stopReason: "pending",
+    timestamp: Date.now()
+  };
+}
+function stripStreamingScratchState2(content) {
+  for (const block of content) {
+    if ("partialJson" in block)
+      delete block.partialJson;
+    if ("partialArgs" in block)
+      delete block.partialArgs;
+    if ("customInput" in block)
+      delete block.customInput;
+    if ("streamIndex" in block)
+      delete block.streamIndex;
+  }
+}
+function formatStreamError(error) {
+  return formatProviderError2(normalizeProviderError2(error));
+}
+function runAssistantStream2(model, signal, label, body, formatError = formatStreamError) {
+  const stream = new AssistantMessageEventStream2;
+  const output = emptyAssistantOutput2(model);
+  (async () => {
+    try {
+      await body(output, stream);
+      if (signal?.aborted)
+        throw new Error("Request was aborted");
+      if (output.stopReason === "pending") {
+        throw new Error(`${label} stream ended without a stop reason`);
+      }
+      if (output.stopReason === "aborted" || output.stopReason === "error") {
+        throw new Error(output.errorMessage || "An unknown error occurred");
+      }
+      stream.push({ type: "done", reason: output.stopReason, message: output });
+    } catch (error) {
+      stripStreamingScratchState2(output.content);
+      output.stopReason = signal?.aborted ? "aborted" : "error";
+      output.errorMessage = formatError(error);
+      stream.push({ type: "error", reason: output.stopReason, error: output });
+    }
+    stream.end();
+  })();
+  return stream;
+}
+
+export { emptyCost2, emptyAssistantOutput2, stripStreamingScratchState2, runAssistantStream2 };