@costrict/csc 4.1.2 → 4.1.4

package/dist/chunk-bpj3247f.js

@@ -0,0 +1,750 @@
+// @bun
+import {
+  init_requestBody,
+  isOpenAIThinkingEnabled,
+  resolveOpenAIMaxTokens
+} from "./chunk-thjhg2me.js";
+import {
+  OpenAI,
+  addToTotalSessionCost,
+  createAssistantAPIErrorMessage,
+  createCoStrictFetch,
+  ensureToolResultPairing,
+  init_api,
+  init_cost_tracker,
+  init_fetch,
+  init_messages1 as init_messages,
+  init_openai,
+  normalizeContentFromAPI,
+  normalizeMessagesForAPI,
+  toolToAPISchema
+} from "./chunk-jdx6pqay.js";
+import"./chunk-j7g5prq1.js";
+import"./chunk-gkfhy27z.js";
+import"./chunk-et824jj8.js";
+import"./chunk-x8g49rpq.js";
+import"./chunk-dj0c74sd.js";
+import"./chunk-7cpxexw0.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-6t7858mm.js";
+import"./chunk-my2v9ayn.js";
+import"./chunk-mb7ne7fv.js";
+import"./chunk-y3h553se.js";
+import {
+  adaptOpenAIStreamToAnthropic,
+  anthropicMessagesToOpenAI,
+  anthropicToolChoiceToOpenAI,
+  anthropicToolsToOpenAI,
+  init_src
+} from "./chunk-wz2q3pmg.js";
+import"./chunk-454ty3a9.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-x6pa9me9.js";
+import"./chunk-2f6hs25r.js";
+import"./chunk-5kwvenz7.js";
+import"./chunk-axh75nac.js";
+import"./chunk-9663bsk0.js";
+import"./chunk-e1rckp3d.js";
+import"./chunk-hnms0snx.js";
+import"./chunk-wx81sgv6.js";
+import"./chunk-dg8c6j5q.js";
+import"./chunk-3ft93eyw.js";
+import"./chunk-qzp51m93.js";
+import"./chunk-mzv3b466.js";
+import"./chunk-yat2gecz.js";
+import"./chunk-pdkfgve3.js";
+import"./chunk-a97kj439.js";
+import"./chunk-tq15k5ay.js";
+import"./chunk-5s1cmr4k.js";
+import"./chunk-t4kcvmes.js";
+import"./chunk-ee23jajz.js";
+import"./chunk-dx4aw2jf.js";
+import"./chunk-5511t18e.js";
+import"./chunk-14ya36qs.js";
+import"./chunk-edqtm6y0.js";
+import"./chunk-yrc25q6d.js";
+import"./chunk-4vbza3s0.js";
+import"./chunk-p6r9kbzs.js";
+import"./chunk-gh3sxpqt.js";
+import"./chunk-xcxcysx3.js";
+import"./chunk-4jm600zv.js";
+import {
+  getCoStrictBaseURL,
+  init_auth
+} from "./chunk-ztetpy4q.js";
+import {
+  init_credentials,
+  loadCoStrictCredentials
+} from "./chunk-mh90mtzg.js";
+import"./chunk-awsqxad3.js";
+import"./chunk-z08t19e5.js";
+import"./chunk-qy6y2jh6.js";
+import"./chunk-0k1kkyw8.js";
+import"./chunk-fm1cnxaj.js";
+import"./chunk-2dtsff0m.js";
+import"./chunk-2w8qb2c2.js";
+import"./chunk-26jcng1n.js";
+import"./chunk-h6hgwf7t.js";
+import"./chunk-sq54cby2.js";
+import"./chunk-y01apqxs.js";
+import"./chunk-1xdybmyp.js";
+import"./chunk-8ye7m55r.js";
+import"./chunk-47mtpn1d.js";
+import"./chunk-nvce80tx.js";
+import {
+  calculateUSDCost,
+  getModelMaxOutputTokens,
+  getUserAgent,
+  init_context,
+  init_http,
+  init_modelCost,
+  init_modelMapping,
+  resolveCoStrictModel
+} from "./chunk-t55pghx5.js";
+import"./chunk-fs34dpdm.js";
+import"./chunk-9dwdn2sk.js";
+import"./chunk-zwarn9h7.js";
+import"./chunk-00e8e1k5.js";
+import"./chunk-rzrm7j9x.js";
+import {
+  getProxyFetchOptions,
+  init_proxy
+} from "./chunk-4bvckeaj.js";
+import"./chunk-jakx4th4.js";
+import"./chunk-pe9b769s.js";
+import"./chunk-64c1avct.js";
+import"./chunk-8g5pe1gr.js";
+import"./chunk-nq504fa3.js";
+import {
+  fetchCoStrictModels,
+  init_models
+} from "./chunk-ehc914vn.js";
+import"./chunk-qxp3d963.js";
+import"./chunk-6dpcm4za.js";
+import"./chunk-p26t5d5e.js";
+import"./chunk-hs71mwbj.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-j9zpgw9b.js";
+import"./chunk-xhesahm0.js";
+import"./chunk-rh5a2rg9.js";
+import"./chunk-npgyhaqc.js";
+import"./chunk-6ws6m83v.js";
+import"./chunk-a4wjqc9g.js";
+import"./chunk-0f6syxra.js";
+import"./chunk-4f8eq6n2.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-x7hqhzet.js";
+import"./chunk-crmjpsqe.js";
+import"./chunk-96012zrd.js";
+import"./chunk-64k6ybmm.js";
+import"./chunk-qr5vq8ys.js";
+import"./chunk-f2mhrmww.js";
+import"./chunk-kenv28g4.js";
+import"./chunk-nbq5dw92.js";
+import"./chunk-ckq5d8ev.js";
+import"./chunk-vacje5g9.js";
+import"./chunk-nrcew0nb.js";
+import"./chunk-gagn0nrq.js";
+import"./chunk-qwtfyr6d.js";
+import"./chunk-ftfz2eh3.js";
+import"./chunk-vtcqe66h.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-my6j0dd8.js";
+import"./chunk-84a2gymg.js";
+import"./chunk-5z28bqne.js";
+import"./chunk-qajrkk97.js";
+import {
+  init_debug,
+  logForDebugging
+} from "./chunk-dea6k409.js";
+import"./chunk-fbv4apne.js";
+import {
+  getActiveSkillName,
+  getMainThreadAgentType,
+  init_state
+} from "./chunk-rcxtkewg.js";
+import"./chunk-50dgek10.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-hxhwzgnn.js";
+import"./chunk-qx8z601m.js";
+import"./chunk-cgm6758j.js";
+import"./chunk-ncpa00h9.js";
+import"./chunk-8pn8tvgg.js";
+import"./chunk-netzwgv1.js";
+import {
+  __commonJS,
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/partial-json@0.1.7/node_modules/partial-json/dist/options.js
+var require_options = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.Allow = exports.ALL = exports.COLLECTION = exports.ATOM = exports.SPECIAL = exports.INF = exports._INFINITY = exports.INFINITY = exports.NAN = exports.BOOL = exports.NULL = exports.OBJ = exports.ARR = exports.NUM = exports.STR = undefined;
+  exports.STR = 1;
+  exports.NUM = 2;
+  exports.ARR = 4;
+  exports.OBJ = 8;
+  exports.NULL = 16;
+  exports.BOOL = 32;
+  exports.NAN = 64;
+  exports.INFINITY = 128;
+  exports._INFINITY = 256;
+  exports.INF = exports.INFINITY | exports._INFINITY;
+  exports.SPECIAL = exports.NULL | exports.BOOL | exports.INF | exports.NAN;
+  exports.ATOM = exports.STR | exports.NUM | exports.SPECIAL;
+  exports.COLLECTION = exports.ARR | exports.OBJ;
+  exports.ALL = exports.ATOM | exports.COLLECTION;
+  exports.Allow = { STR: exports.STR, NUM: exports.NUM, ARR: exports.ARR, OBJ: exports.OBJ, NULL: exports.NULL, BOOL: exports.BOOL, NAN: exports.NAN, INFINITY: exports.INFINITY, _INFINITY: exports._INFINITY, INF: exports.INF, SPECIAL: exports.SPECIAL, ATOM: exports.ATOM, COLLECTION: exports.COLLECTION, ALL: exports.ALL };
+  exports.default = exports.Allow;
+});
+
+// node_modules/.bun/partial-json@0.1.7/node_modules/partial-json/dist/index.js
+var require_dist = __commonJS((exports) => {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+    for (var p in m)
+      if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+        __createBinding(exports2, m, p);
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.Allow = exports.MalformedJSON = exports.PartialJSON = exports.parseJSON = exports.parse = undefined;
+  var options_1 = require_options();
+  Object.defineProperty(exports, "Allow", { enumerable: true, get: function() {
+    return options_1.Allow;
+  } });
+  __exportStar(require_options(), exports);
+
+  class PartialJSON extends Error {
+  }
+  exports.PartialJSON = PartialJSON;
+
+  class MalformedJSON extends Error {
+  }
+  exports.MalformedJSON = MalformedJSON;
+  function parseJSON(jsonString, allowPartial = options_1.Allow.ALL) {
+    if (typeof jsonString !== "string") {
+      throw new TypeError(`expecting str, got ${typeof jsonString}`);
+    }
+    if (!jsonString.trim()) {
+      throw new Error(`${jsonString} is empty`);
+    }
+    return _parseJSON(jsonString.trim(), allowPartial);
+  }
+  exports.parseJSON = parseJSON;
+  var _parseJSON = (jsonString, allow) => {
+    const length = jsonString.length;
+    let index = 0;
+    const markPartialJSON = (msg) => {
+      throw new PartialJSON(`${msg} at position ${index}`);
+    };
+    const throwMalformedError = (msg) => {
+      throw new MalformedJSON(`${msg} at position ${index}`);
+    };
+    const parseAny = () => {
+      skipBlank();
+      if (index >= length)
+        markPartialJSON("Unexpected end of input");
+      if (jsonString[index] === '"')
+        return parseStr();
+      if (jsonString[index] === "{")
+        return parseObj();
+      if (jsonString[index] === "[")
+        return parseArr();
+      if (jsonString.substring(index, index + 4) === "null" || options_1.Allow.NULL & allow && length - index < 4 && "null".startsWith(jsonString.substring(index))) {
+        index += 4;
+        return null;
+      }
+      if (jsonString.substring(index, index + 4) === "true" || options_1.Allow.BOOL & allow && length - index < 4 && "true".startsWith(jsonString.substring(index))) {
+        index += 4;
+        return true;
+      }
+      if (jsonString.substring(index, index + 5) === "false" || options_1.Allow.BOOL & allow && length - index < 5 && "false".startsWith(jsonString.substring(index))) {
+        index += 5;
+        return false;
+      }
+      if (jsonString.substring(index, index + 8) === "Infinity" || options_1.Allow.INFINITY & allow && length - index < 8 && "Infinity".startsWith(jsonString.substring(index))) {
+        index += 8;
+        return Infinity;
+      }
+      if (jsonString.substring(index, index + 9) === "-Infinity" || options_1.Allow._INFINITY & allow && 1 < length - index && length - index < 9 && "-Infinity".startsWith(jsonString.substring(index))) {
+        index += 9;
+        return -Infinity;
+      }
+      if (jsonString.substring(index, index + 3) === "NaN" || options_1.Allow.NAN & allow && length - index < 3 && "NaN".startsWith(jsonString.substring(index))) {
+        index += 3;
+        return NaN;
+      }
+      return parseNum();
+    };
+    const parseStr = () => {
+      const start = index;
+      let escape = false;
+      index++;
+      while (index < length && (jsonString[index] !== '"' || escape && jsonString[index - 1] === "\\")) {
+        escape = jsonString[index] === "\\" ? !escape : false;
+        index++;
+      }
+      if (jsonString.charAt(index) == '"') {
+        try {
+          return JSON.parse(jsonString.substring(start, ++index - Number(escape)));
+        } catch (e) {
+          throwMalformedError(String(e));
+        }
+      } else if (options_1.Allow.STR & allow) {
+        try {
+          return JSON.parse(jsonString.substring(start, index - Number(escape)) + '"');
+        } catch (e) {
+          return JSON.parse(jsonString.substring(start, jsonString.lastIndexOf("\\")) + '"');
+        }
+      }
+      markPartialJSON("Unterminated string literal");
+    };
+    const parseObj = () => {
+      index++;
+      skipBlank();
+      const obj = {};
+      try {
+        while (jsonString[index] !== "}") {
+          skipBlank();
+          if (index >= length && options_1.Allow.OBJ & allow)
+            return obj;
+          const key = parseStr();
+          skipBlank();
+          index++;
+          try {
+            const value = parseAny();
+            obj[key] = value;
+          } catch (e) {
+            if (options_1.Allow.OBJ & allow)
+              return obj;
+            else
+              throw e;
+          }
+          skipBlank();
+          if (jsonString[index] === ",")
+            index++;
+        }
+      } catch (e) {
+        if (options_1.Allow.OBJ & allow)
+          return obj;
+        else
+          markPartialJSON("Expected '}' at end of object");
+      }
+      index++;
+      return obj;
+    };
+    const parseArr = () => {
+      index++;
+      const arr = [];
+      try {
+        while (jsonString[index] !== "]") {
+          arr.push(parseAny());
+          skipBlank();
+          if (jsonString[index] === ",") {
+            index++;
+          }
+        }
+      } catch (e) {
+        if (options_1.Allow.ARR & allow) {
+          return arr;
+        }
+        markPartialJSON("Expected ']' at end of array");
+      }
+      index++;
+      return arr;
+    };
+    const parseNum = () => {
+      if (index === 0) {
+        if (jsonString === "-")
+          throwMalformedError("Not sure what '-' is");
+        try {
+          return JSON.parse(jsonString);
+        } catch (e) {
+          if (options_1.Allow.NUM & allow)
+            try {
+              return JSON.parse(jsonString.substring(0, jsonString.lastIndexOf("e")));
+            } catch (e2) {}
+          throwMalformedError(String(e));
+        }
+      }
+      const start = index;
+      if (jsonString[index] === "-")
+        index++;
+      while (jsonString[index] && ",]}".indexOf(jsonString[index]) === -1)
+        index++;
+      if (index == length && !(options_1.Allow.NUM & allow))
+        markPartialJSON("Unterminated number literal");
+      try {
+        return JSON.parse(jsonString.substring(start, index));
+      } catch (e) {
+        if (jsonString.substring(start, index) === "-")
+          markPartialJSON("Not sure what '-' is");
+        try {
+          return JSON.parse(jsonString.substring(start, jsonString.lastIndexOf("e")));
+        } catch (e2) {
+          throwMalformedError(String(e2));
+        }
+      }
+    };
+    const skipBlank = () => {
+      while (index < length && ` 
+\r	`.includes(jsonString[index])) {
+        index++;
+      }
+    };
+    return parseAny();
+  };
+  var parse = parseJSON;
+  exports.parse = parse;
+});
+
+// src/costrict/provider/index.ts
+import { randomUUID } from "crypto";
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isPlainRecord(value) {
+  return isRecord(value);
+}
+function tryParsePartialToolInput(rawInput) {
+  try {
+    const parsed = import_partial_json.parse(rawInput);
+    return isPlainRecord(parsed) ? parsed : undefined;
+  } catch {
+    return;
+  }
+}
+function getInvalidToolInputMessage(toolName) {
+  return `Model response error: invalid tool call arguments for ${toolName}. The tool call was not executed.`;
+}
+function contentContainsImage(content) {
+  if (!Array.isArray(content))
+    return false;
+  return content.some((block) => {
+    if (!isRecord(block))
+      return false;
+    if (block.type === "image")
+      return true;
+    if (block.type === "tool_result") {
+      return contentContainsImage(block.content);
+    }
+    return false;
+  });
+}
+function messagesContainImages(messages) {
+  return messages.some((message) => {
+    if (message.type !== "user")
+      return false;
+    if (!message.message)
+      return false;
+    return contentContainsImage(message.message.content);
+  });
+}
+function isNonMultimodalModelError(message) {
+  const normalized = message.toLowerCase();
+  return normalized.includes("not a multimodal model") || normalized.includes("does not support image") || normalized.includes("does not support images");
+}
+async function* queryModelCoStrict(messages, systemPrompt, tools, signal, options) {
+  try {
+    const costrictModel = resolveCoStrictModel(options.model);
+    const creds = await loadCoStrictCredentials();
+    const baseUrl = getCoStrictBaseURL(creds?.base_url);
+    const chatBaseURL = `${baseUrl}/chat-rag/api/v1`;
+    let defaultMaxTokens = getModelMaxOutputTokens(costrictModel).upperLimit;
+    let maxTokensParamKey = "max_tokens";
+    let modelInfo;
+    if (creds?.access_token) {
+      try {
+        const modelList = await fetchCoStrictModels(baseUrl, creds.access_token);
+        modelInfo = modelList.find((m) => m.id === costrictModel);
+        if (modelInfo) {
+          maxTokensParamKey = modelInfo.maxTokensKey || "max_tokens";
+          if (modelInfo.maxTokens != null) {
+            defaultMaxTokens = modelInfo.maxTokens;
+          }
+        }
+      } catch {}
+    }
+    const maxTokensValue = resolveOpenAIMaxTokens(defaultMaxTokens, options.maxOutputTokensOverride);
+    const messagesForAPI = ensureToolResultPairing(normalizeMessagesForAPI(messages, tools));
+    if (modelInfo?.supportsImages === false && messagesContainImages(messagesForAPI)) {
+      yield createAssistantAPIErrorMessage({
+        content: `CoStrict API Error: Model ${costrictModel} does not support image input. Switch to a multimodal or vision-capable model and try again.`,
+        apiError: "api_error"
+      });
+      return;
+    }
+    const toolSchemas = await Promise.all(tools.map((tool) => toolToAPISchema(tool, {
+      getToolPermissionContext: options.getToolPermissionContext,
+      tools,
+      agents: options.agents,
+      allowedAgentTypes: options.allowedAgentTypes,
+      model: options.model
+    })));
+    const standardTools = toolSchemas.filter((t) => {
+      const anyT = t;
+      return anyT.type !== "advisor_20260301" && anyT.type !== "computer_20250124";
+    });
+    const enableThinking = isOpenAIThinkingEnabled(costrictModel);
+    const openaiMessages = anthropicMessagesToOpenAI(messagesForAPI, systemPrompt, { enableThinking });
+    const openaiTools = anthropicToolsToOpenAI(standardTools);
+    const openaiToolChoice = anthropicToolChoiceToOpenAI(options.toolChoice);
+    const costrictFetch = createCoStrictFetch({
+      agentType: getMainThreadAgentType() ?? getActiveSkillName()
+    });
+    const client = new OpenAI({
+      apiKey: "costrict-managed",
+      baseURL: chatBaseURL,
+      maxRetries: 0,
+      timeout: parseInt(process.env.API_TIMEOUT_MS || String(600 * 1000), 10),
+      dangerouslyAllowBrowser: true,
+      fetchOptions: getProxyFetchOptions({
+        forAnthropicAPI: false
+      }),
+      fetch: costrictFetch,
+      defaultHeaders: { "User-Agent": getUserAgent() }
+    });
+    logForDebugging(`[CoStrict] model=${costrictModel}, baseURL=${chatBaseURL}, messages=${openaiMessages.length}, tools=${openaiTools.length}`);
+    const requestBody = {
+      model: costrictModel,
+      messages: openaiMessages,
+      ...openaiTools.length > 0 && {
+        tools: openaiTools,
+        ...openaiToolChoice && {
+          tool_choice: openaiToolChoice
+        }
+      },
+      stream: true,
+      stream_options: { include_usage: true },
+      [maxTokensParamKey]: maxTokensValue,
+      ...enableThinking && {
+        thinking: { type: "enabled" },
+        enable_thinking: true,
+        chat_template_kwargs: { thinking: true }
+      },
+      ...!enableThinking && options.temperatureOverride !== undefined && {
+        temperature: options.temperatureOverride
+      }
+    };
+    const stream = await client.chat.completions.create(requestBody, { signal });
+    const adaptedStream = adaptOpenAIStreamToAnthropic(stream, costrictModel);
+    const contentBlocks = {};
+    const toolCallStates = new Map;
+    let partialMessage;
+    let stopReason = null;
+    let usage = {
+      input_tokens: 0,
+      output_tokens: 0,
+      cache_creation_input_tokens: 0,
+      cache_read_input_tokens: 0
+    };
+    let ttftMs = 0;
+    const start = Date.now();
+    const finalizeToolCallStates = () => {
+      for (const state of toolCallStates.values()) {
+        try {
+          const parsed = JSON.parse(state.rawInput);
+          if (!isPlainRecord(parsed)) {
+            state.finalParseError = getInvalidToolInputMessage(state.name);
+          }
+        } catch {
+          state.finalParseError = getInvalidToolInputMessage(state.name);
+        }
+      }
+    };
+    const assembleFinalAssistantOutputs = () => {
+      const outputs = [];
+      if (!partialMessage)
+        return outputs;
+      const allBlocksWithIndices = Object.keys(contentBlocks).sort((a, b) => Number(a) - Number(b)).map((k) => ({ index: Number(k), block: contentBlocks[Number(k)] })).filter((entry) => Boolean(entry.block));
+      const allBlocks = allBlocksWithIndices.map((entry) => entry.block);
+      if (allBlocks.length > 0) {
+        for (const { index, block } of allBlocksWithIndices) {
+          if (block?.type !== "tool_use")
+            continue;
+          const state = toolCallStates.get(index);
+          if (!state)
+            continue;
+          block.input = state.rawInput;
+          if (state.finalParseError) {
+            block.invalidToolCallError = state.finalParseError;
+          }
+        }
+        outputs.push({
+          message: {
+            ...partialMessage,
+            content: normalizeContentFromAPI(allBlocks, tools, options.agentId, { preserveInvalidToolCall: true }),
+            usage,
+            stop_reason: stopReason,
+            stop_sequence: null
+          },
+          requestId: undefined,
+          type: "assistant",
+          uuid: randomUUID(),
+          timestamp: new Date().toISOString()
+        });
+      }
+      if (stopReason === "max_tokens") {
+        outputs.push(createAssistantAPIErrorMessage({
+          content: `Output truncated: response exceeded the ${maxTokensValue} token limit. ` + `Set OPENAI_MAX_TOKENS or CLAUDE_CODE_MAX_OUTPUT_TOKENS to override.`,
+          apiError: "max_output_tokens",
+          error: "max_output_tokens"
+        }));
+      }
+      return outputs;
+    };
+    for await (const event of adaptedStream) {
+      switch (event.type) {
+        case "message_start": {
+          partialMessage = event.message;
+          ttftMs = Date.now() - start;
+          if (event.message?.usage) {
+            usage = { ...usage, ...event.message.usage };
+          }
+          break;
+        }
+        case "content_block_start": {
+          const idx = event.index;
+          const cb = event.content_block;
+          if (cb.type === "tool_use") {
+            contentBlocks[idx] = { ...cb, input: "" };
+            toolCallStates.set(idx, {
+              index: idx,
+              id: String(cb.id ?? ""),
+              name: typeof cb.name === "string" ? cb.name : "",
+              rawInput: ""
+            });
+          } else if (cb.type === "text") {
+            contentBlocks[idx] = { ...cb, text: "" };
+          } else if (cb.type === "thinking") {
+            contentBlocks[idx] = { ...cb, thinking: "", signature: "" };
+          } else {
+            contentBlocks[idx] = { ...cb };
+          }
+          break;
+        }
+        case "content_block_delta": {
+          const idx = event.index;
+          const delta = event.delta;
+          const block = contentBlocks[idx];
+          if (!block)
+            break;
+          if (delta.type === "text_delta") {
+            block.text = (block.text || "") + delta.text;
+          } else if (delta.type === "input_json_delta") {
+            const fragment = String(delta.partial_json ?? "");
+            block.input = (block.input || "") + fragment;
+            const state = toolCallStates.get(idx);
+            if (state) {
+              state.rawInput += fragment;
+              const partialInput = tryParsePartialToolInput(state.rawInput);
+              if (partialInput) {
+                state.partialInput = partialInput;
+                delta.parsed_tool_input = partialInput;
+              }
+            }
+          } else if (delta.type === "thinking_delta") {
+            block.thinking = (block.thinking || "") + delta.thinking;
+          } else if (delta.type === "signature_delta") {
+            block.signature = delta.signature;
+          }
+          break;
+        }
+        case "content_block_stop": {
+          break;
+        }
+        case "message_delta": {
+          const deltaUsage = event.usage;
+          if (deltaUsage)
+            usage = { ...usage, ...deltaUsage };
+          if (event.delta?.stop_reason != null) {
+            stopReason = event.delta.stop_reason;
+          }
+          break;
+        }
+        case "message_stop": {
+          if (partialMessage) {
+            finalizeToolCallStates();
+            for (const output of assembleFinalAssistantOutputs()) {
+              yield output;
+            }
+            partialMessage = null;
+            toolCallStates.clear();
+          }
+          break;
+        }
+      }
+      if (event.type === "message_stop" && usage.input_tokens + usage.output_tokens > 0) {
+        const costUSD = calculateUSDCost(costrictModel, usage);
+        addToTotalSessionCost(costUSD, usage, options.model);
+      }
+      yield {
+        type: "stream_event",
+        event,
+        ...event.type === "message_start" ? { ttftMs } : undefined
+      };
+    }
+    if (partialMessage) {
+      finalizeToolCallStates();
+      for (const output of assembleFinalAssistantOutputs()) {
+        yield output;
+      }
+    }
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    logForDebugging(`[CoStrict] Error: ${errorMsg}`, { level: "error" });
+    yield createAssistantAPIErrorMessage({
+      content: isNonMultimodalModelError(errorMsg) ? "CoStrict API Error: The current model does not support image input. Switch to a multimodal or vision-capable model and try again." : `CoStrict API Error: ${errorMsg}`,
+      apiError: "api_error",
+      error: error instanceof Error ? error : undefined
+    });
+  }
+}
+var import_partial_json;
+var init_provider = __esm(() => {
+  init_openai();
+  init_proxy();
+  init_http();
+  init_src();
+  init_messages();
+  init_api();
+  init_debug();
+  init_cost_tracker();
+  init_modelCost();
+  init_messages();
+  init_fetch();
+  init_modelMapping();
+  init_auth();
+  init_credentials();
+  init_requestBody();
+  init_models();
+  init_state();
+  init_context();
+  import_partial_json = __toESM(require_dist(), 1);
+});
+init_provider();
+
+export {
+  queryModelCoStrict
+};
+
+//# debugId=4367DA0D6FA0B4D064756E2164756E21
+//# sourceMappingURL=chunk-bpj3247f.js.map