@costrict/csc 4.0.1

package/dist/chunk-56r79b2b.js

@@ -0,0 +1,69 @@
+// @bun
+import {
+  execSync_DEPRECATED,
+  init_execSyncWrapper
+} from "./chunk-nneembm7.js";
+import {
+  execa,
+  init_execa
+} from "./chunk-5z28bqne.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/which.ts
+async function whichNodeAsync(command) {
+  if (process.platform === "win32") {
+    const result2 = await execa(`where.exe ${command}`, {
+      shell: true,
+      stderr: "ignore",
+      reject: false
+    });
+    if (result2.exitCode !== 0 || !result2.stdout) {
+      return null;
+    }
+    return result2.stdout.trim().split(/\r?\n/)[0] || null;
+  }
+  const result = await execa(`which ${command}`, {
+    shell: true,
+    stderr: "ignore",
+    reject: false
+  });
+  if (result.exitCode !== 0 || !result.stdout) {
+    return null;
+  }
+  return result.stdout.trim();
+}
+function whichNodeSync(command) {
+  if (process.platform === "win32") {
+    try {
+      const result = execSync_DEPRECATED(`where.exe ${command}`, {
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"]
+      });
+      const output = result.toString().trim();
+      return output.split(/\r?\n/)[0] || null;
+    } catch {
+      return null;
+    }
+  }
+  try {
+    const result = execSync_DEPRECATED(`which ${command}`, {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return result.toString().trim() || null;
+  } catch {
+    return null;
+  }
+}
+var bunWhich, which, whichSync;
+var init_which = __esm(() => {
+  init_execa();
+  init_execSyncWrapper();
+  bunWhich = typeof Bun !== "undefined" && typeof Bun.which === "function" ? Bun.which : null;
+  which = bunWhich ? async (command) => bunWhich(command) : whichNodeAsync;
+  whichSync = bunWhich ?? whichNodeSync;
+});
+
+export { which, whichSync, init_which };

package/dist/chunk-57zse1aw.js

@@ -0,0 +1,393 @@
+// @bun
+import {
+  adaptOpenAIStreamToAnthropic,
+  anthropicToolChoiceToOpenAI,
+  anthropicToolsToOpenAI,
+  init_convertTools,
+  init_streamAdapter
+} from "./chunk-w32xjs44.js";
+import {
+  OpenAI,
+  addToTotalSessionCost,
+  anthropicMessagesToOpenAI,
+  createAssistantAPIErrorMessage,
+  init_api,
+  init_convertMessages,
+  init_cost_tracker,
+  init_messages1 as init_messages,
+  init_openai,
+  normalizeContentFromAPI,
+  normalizeMessagesForAPI,
+  toolToAPISchema
+} from "./chunk-97kwfkef.js";
+import"./chunk-4nspekjp.js";
+import"./chunk-s2jznn2t.js";
+import"./chunk-zejm280k.js";
+import"./chunk-var1et7e.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-enz148g9.js";
+import"./chunk-jmt3t5ka.js";
+import"./chunk-3x2jaxpw.js";
+import"./chunk-wm26jyc3.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-bxcfz5gy.js";
+import"./chunk-3vxgde8h.js";
+import"./chunk-9k8qsaph.js";
+import"./chunk-bnrctxq5.js";
+import"./chunk-9663bsk0.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-gr2j2pnw.js";
+import"./chunk-m7gb3xym.js";
+import"./chunk-zgjh33vv.js";
+import"./chunk-j5bth84e.js";
+import"./chunk-39jcea92.js";
+import"./chunk-reta5k4w.js";
+import"./chunk-3z9478wf.js";
+import"./chunk-ps49ymvj.js";
+import"./chunk-eq5csq9z.js";
+import"./chunk-qezabsdm.js";
+import"./chunk-p7vkh4wx.js";
+import"./chunk-3sj7jkgr.js";
+import"./chunk-62xkxk9z.js";
+import"./chunk-ers3hn71.js";
+import"./chunk-5krq9sjq.js";
+import"./chunk-85em0j2s.js";
+import"./chunk-dmfnhfbm.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-ew2qn2ct.js";
+import"./chunk-3bes9fg8.js";
+import"./chunk-ygj29dpk.js";
+import"./chunk-6km733xr.js";
+import"./chunk-mx28h61f.js";
+import"./chunk-z915v06p.js";
+import"./chunk-rw0b3wq4.js";
+import"./chunk-ms3y5kf0.js";
+import"./chunk-pfc94kdv.js";
+import"./chunk-kwdta9bw.js";
+import"./chunk-3dy7fxmg.js";
+import {
+  calculateUSDCost,
+  init_modelCost
+} from "./chunk-qp1047f9.js";
+import"./chunk-3ns6ys7f.js";
+import"./chunk-6aspnjtj.js";
+import {
+  getProxyFetchOptions,
+  init_proxy
+} from "./chunk-1dz5e26z.js";
+import"./chunk-1cwdhk7a.js";
+import"./chunk-j9gxwbe3.js";
+import"./chunk-64c1avct.js";
+import"./chunk-qbrsmra3.js";
+import"./chunk-8g5pe1gr.js";
+import"./chunk-5j8wked2.js";
+import"./chunk-v4t6dyyh.js";
+import"./chunk-4pbx3g7s.js";
+import"./chunk-26wtxbdc.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-qz2x630m.js";
+import"./chunk-xzc7k2hh.js";
+import"./chunk-rcpmj2s6.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-dkzwgrsa.js";
+import"./chunk-q82r31er.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-ztf1hdpb.js";
+import"./chunk-crmjpsqe.js";
+import"./chunk-fk80f449.js";
+import"./chunk-g338npwr.js";
+import"./chunk-f2mhrmww.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-yjkamwzv.js";
+import"./chunk-13hhjhs8.js";
+import"./chunk-rpmxbsc4.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-2wz9qb4j.js";
+import"./chunk-b81hd3m6.js";
+import"./chunk-ce2v5y9y.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-56r79b2b.js";
+import"./chunk-nneembm7.js";
+import"./chunk-5z28bqne.js";
+import"./chunk-qajrkk97.js";
+import {
+  init_debug,
+  logForDebugging
+} from "./chunk-ctya0ggm.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-z6e5jp2w.js";
+import"./chunk-h4b85amj.js";
+import"./chunk-07069jq1.js";
+import"./chunk-jaaxk89e.js";
+import"./chunk-vf612n57.js";
+import"./chunk-d4mdda98.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-nh3cd07f.js";
+import"./chunk-8pn8tvgg.js";
+import"./chunk-netzwgv1.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/services/api/grok/client.ts
+function getGrokClient(options) {
+  if (cachedClient)
+    return cachedClient;
+  const apiKey = process.env.GROK_API_KEY || process.env.XAI_API_KEY || "";
+  const baseURL = process.env.GROK_BASE_URL || DEFAULT_BASE_URL;
+  const client = new OpenAI({
+    apiKey,
+    baseURL,
+    maxRetries: options?.maxRetries ?? 0,
+    timeout: parseInt(process.env.API_TIMEOUT_MS || String(600 * 1000), 10),
+    dangerouslyAllowBrowser: true,
+    fetchOptions: getProxyFetchOptions({ forAnthropicAPI: false }),
+    ...options?.fetchOverride && { fetch: options.fetchOverride }
+  });
+  if (!options?.fetchOverride) {
+    cachedClient = client;
+  }
+  return client;
+}
+var DEFAULT_BASE_URL = "https://api.x.ai/v1", cachedClient = null;
+var init_client = __esm(() => {
+  init_openai();
+  init_proxy();
+});
+
+// src/services/api/grok/modelMapping.ts
+function getModelFamily(model) {
+  if (/haiku/i.test(model))
+    return "haiku";
+  if (/opus/i.test(model))
+    return "opus";
+  if (/sonnet/i.test(model))
+    return "sonnet";
+  return null;
+}
+function getUserModelMap() {
+  const raw = process.env.GROK_MODEL_MAP;
+  if (!raw)
+    return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {}
+  return null;
+}
+function resolveGrokModel(anthropicModel) {
+  if (process.env.GROK_MODEL) {
+    return process.env.GROK_MODEL;
+  }
+  const cleanModel = anthropicModel.replace(/\[1m\]$/, "");
+  const family = getModelFamily(cleanModel);
+  const userMap = getUserModelMap();
+  if (userMap && family && userMap[family]) {
+    return userMap[family];
+  }
+  if (family) {
+    const grokEnvVar = `GROK_DEFAULT_${family.toUpperCase()}_MODEL`;
+    const grokOverride = process.env[grokEnvVar];
+    if (grokOverride)
+      return grokOverride;
+    const anthropicEnvVar = `ANTHROPIC_DEFAULT_${family.toUpperCase()}_MODEL`;
+    const anthropicOverride = process.env[anthropicEnvVar];
+    if (anthropicOverride)
+      return anthropicOverride;
+  }
+  if (DEFAULT_MODEL_MAP[cleanModel]) {
+    return DEFAULT_MODEL_MAP[cleanModel];
+  }
+  if (family && DEFAULT_FAMILY_MAP[family]) {
+    return DEFAULT_FAMILY_MAP[family];
+  }
+  return cleanModel;
+}
+var DEFAULT_MODEL_MAP, DEFAULT_FAMILY_MAP;
+var init_modelMapping = __esm(() => {
+  DEFAULT_MODEL_MAP = {
+    "claude-sonnet-4-20250514": "grok-3-mini-fast",
+    "claude-sonnet-4-5-20250929": "grok-3-mini-fast",
+    "claude-sonnet-4-6": "grok-3-mini-fast",
+    "claude-opus-4-20250514": "grok-4.20-reasoning",
+    "claude-opus-4-1-20250805": "grok-4.20-reasoning",
+    "claude-opus-4-5-20251101": "grok-4.20-reasoning",
+    "claude-opus-4-6": "grok-4.20-reasoning",
+    "claude-haiku-4-5-20251001": "grok-3-mini-fast",
+    "claude-3-5-haiku-20241022": "grok-3-mini-fast",
+    "claude-3-7-sonnet-20250219": "grok-3-mini-fast",
+    "claude-3-5-sonnet-20241022": "grok-3-mini-fast"
+  };
+  DEFAULT_FAMILY_MAP = {
+    opus: "grok-4.20-reasoning",
+    sonnet: "grok-3-mini-fast",
+    haiku: "grok-3-mini-fast"
+  };
+});
+
+// src/services/api/grok/index.ts
+import { randomUUID } from "crypto";
+async function* queryModelGrok(messages, systemPrompt, tools, signal, options) {
+  try {
+    const grokModel = resolveGrokModel(options.model);
+    const messagesForAPI = normalizeMessagesForAPI(messages, tools);
+    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 openaiMessages = anthropicMessagesToOpenAI(messagesForAPI, systemPrompt);
+    const openaiTools = anthropicToolsToOpenAI(standardTools);
+    const openaiToolChoice = anthropicToolChoiceToOpenAI(options.toolChoice);
+    const client = getGrokClient({
+      maxRetries: 0,
+      fetchOverride: options.fetchOverride,
+      source: options.querySource
+    });
+    logForDebugging(`[Grok] Calling model=${grokModel}, messages=${openaiMessages.length}, tools=${openaiTools.length}`);
+    const stream = await client.chat.completions.create({
+      model: grokModel,
+      messages: openaiMessages,
+      ...openaiTools.length > 0 && {
+        tools: openaiTools,
+        ...openaiToolChoice && { tool_choice: openaiToolChoice }
+      },
+      stream: true,
+      stream_options: { include_usage: true },
+      ...options.temperatureOverride !== undefined && {
+        temperature: options.temperatureOverride
+      }
+    }, {
+      signal
+    });
+    const adaptedStream = adaptOpenAIStreamToAnthropic(stream, grokModel);
+    const contentBlocks = {};
+    let partialMessage = undefined;
+    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();
+    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: "" };
+          } 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") {
+            block.input = (block.input || "") + delta.partial_json;
+          } 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": {
+          const idx = event.index;
+          const block = contentBlocks[idx];
+          if (!block || !partialMessage)
+            break;
+          const m = {
+            message: {
+              ...partialMessage,
+              content: normalizeContentFromAPI([block], tools, options.agentId)
+            },
+            requestId: undefined,
+            type: "assistant",
+            uuid: randomUUID(),
+            timestamp: new Date().toISOString()
+          };
+          yield m;
+          break;
+        }
+        case "message_delta": {
+          const deltaUsage = event.usage;
+          if (deltaUsage) {
+            usage = { ...usage, ...deltaUsage };
+          }
+          break;
+        }
+        case "message_stop":
+          break;
+      }
+      if (event.type === "message_stop" && usage.input_tokens + usage.output_tokens > 0) {
+        const costUSD = calculateUSDCost(grokModel, usage);
+        addToTotalSessionCost(costUSD, usage, options.model);
+      }
+      yield {
+        type: "stream_event",
+        event,
+        ...event.type === "message_start" ? { ttftMs } : undefined
+      };
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logForDebugging(`[Grok] Error: ${errorMessage}`, { level: "error" });
+    yield createAssistantAPIErrorMessage({
+      content: `API Error: ${errorMessage}`,
+      apiError: "api_error",
+      error: error instanceof Error ? error : new Error(String(error))
+    });
+  }
+}
+var init_grok = __esm(() => {
+  init_client();
+  init_convertMessages();
+  init_convertTools();
+  init_streamAdapter();
+  init_modelMapping();
+  init_messages();
+  init_api();
+  init_debug();
+  init_cost_tracker();
+  init_modelCost();
+  init_messages();
+});
+init_grok();
+
+export {
+  queryModelGrok
+};

package/dist/chunk-5c5xde65.js

@@ -0,0 +1,229 @@
+// @bun
+import {
+  EXIT_PLAN_MODE_V2_TOOL_NAME,
+  createAssistantMessage,
+  getPlan,
+  init_constants2 as init_constants,
+  init_messages1 as init_messages,
+  init_plans
+} from "./chunk-97kwfkef.js";
+import {
+  init_strip_ansi,
+  stripAnsi
+} from "./chunk-fk80f449.js";
+import {
+  LOCAL_COMMAND_STDERR_TAG,
+  LOCAL_COMMAND_STDOUT_TAG,
+  init_xml
+} from "./chunk-ce2v5y9y.js";
+import {
+  getSessionId,
+  init_state
+} from "./chunk-h4b85amj.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/messages/mappers.ts
+import { randomUUID } from "crypto";
+function toInternalMessages(messages) {
+  return messages.flatMap((message) => {
+    switch (message.type) {
+      case "assistant":
+        return [
+          {
+            type: "assistant",
+            message: message.message,
+            uuid: message.uuid,
+            requestId: undefined,
+            timestamp: new Date().toISOString()
+          }
+        ];
+      case "user":
+        return [
+          {
+            type: "user",
+            message: message.message,
+            uuid: message.uuid ?? randomUUID(),
+            timestamp: message.timestamp ?? new Date().toISOString(),
+            isMeta: message.isSynthetic
+          }
+        ];
+      case "system":
+        if (message.subtype === "compact_boundary") {
+          const compactMsg = message;
+          return [
+            {
+              type: "system",
+              content: "Conversation compacted",
+              level: "info",
+              subtype: "compact_boundary",
+              compactMetadata: fromSDKCompactMetadata(compactMsg.compact_metadata),
+              uuid: message.uuid,
+              timestamp: new Date().toISOString()
+            }
+          ];
+        }
+        return [];
+      default:
+        return [];
+    }
+  });
+}
+function toSDKCompactMetadata(meta) {
+  const seg = meta.preservedSegment;
+  return {
+    trigger: meta.trigger,
+    pre_tokens: meta.preTokens,
+    ...seg && {
+      preserved_segment: {
+        head_uuid: seg.headUuid,
+        anchor_uuid: seg.anchorUuid,
+        tail_uuid: seg.tailUuid
+      }
+    }
+  };
+}
+function fromSDKCompactMetadata(meta) {
+  const m = meta;
+  const seg = m.preserved_segment;
+  return {
+    trigger: m.trigger,
+    preTokens: m.pre_tokens,
+    ...seg && {
+      preservedSegment: {
+        headUuid: seg.head_uuid,
+        anchorUuid: seg.anchor_uuid,
+        tailUuid: seg.tail_uuid
+      }
+    }
+  };
+}
+function toSDKMessages(messages) {
+  return messages.flatMap((message) => {
+    switch (message.type) {
+      case "assistant":
+        return [
+          {
+            type: "assistant",
+            message: normalizeAssistantMessageForSDK(message),
+            session_id: getSessionId(),
+            parent_tool_use_id: null,
+            uuid: message.uuid,
+            error: message.error
+          }
+        ];
+      case "user":
+        return [
+          {
+            type: "user",
+            message: message.message,
+            session_id: getSessionId(),
+            parent_tool_use_id: null,
+            uuid: message.uuid,
+            timestamp: message.timestamp,
+            isSynthetic: message.isMeta || message.isVisibleInTranscriptOnly,
+            ...message.toolUseResult !== undefined ? { tool_use_result: message.toolUseResult } : {}
+          }
+        ];
+      case "system":
+        if (message.subtype === "compact_boundary" && message.compactMetadata) {
+          return [
+            {
+              type: "system",
+              subtype: "compact_boundary",
+              session_id: getSessionId(),
+              uuid: message.uuid,
+              compact_metadata: toSDKCompactMetadata(message.compactMetadata)
+            }
+          ];
+        }
+        if (message.subtype === "local_command" && (message.content.includes(`<${LOCAL_COMMAND_STDOUT_TAG}>`) || message.content.includes(`<${LOCAL_COMMAND_STDERR_TAG}>`))) {
+          return [
+            localCommandOutputToSDKAssistantMessage(message.content, message.uuid)
+          ];
+        }
+        return [];
+      default:
+        return [];
+    }
+  });
+}
+function localCommandOutputToSDKAssistantMessage(rawContent, uuid) {
+  const cleanContent = stripAnsi(rawContent).replace(/<local-command-stdout>([\s\S]*?)<\/local-command-stdout>/, "$1").replace(/<local-command-stderr>([\s\S]*?)<\/local-command-stderr>/, "$1").trim();
+  const synthetic = createAssistantMessage({ content: cleanContent });
+  return {
+    type: "assistant",
+    content: synthetic.message?.content,
+    message: synthetic.message,
+    parent_tool_use_id: null,
+    session_id: getSessionId(),
+    uuid
+  };
+}
+function toSDKRateLimitInfo(limits) {
+  if (!limits) {
+    return;
+  }
+  return {
+    type: "rate_limit",
+    status: limits.status,
+    ...limits.resetsAt !== undefined && { resetsAt: limits.resetsAt },
+    ...limits.rateLimitType !== undefined && {
+      rateLimitType: limits.rateLimitType
+    },
+    ...limits.utilization !== undefined && {
+      utilization: limits.utilization
+    },
+    ...limits.overageStatus !== undefined && {
+      overageStatus: limits.overageStatus
+    },
+    ...limits.overageResetsAt !== undefined && {
+      overageResetsAt: limits.overageResetsAt
+    },
+    ...limits.overageDisabledReason !== undefined && {
+      overageDisabledReason: limits.overageDisabledReason
+    },
+    ...limits.isUsingOverage !== undefined && {
+      isUsingOverage: limits.isUsingOverage
+    },
+    ...limits.surpassedThreshold !== undefined && {
+      surpassedThreshold: limits.surpassedThreshold
+    }
+  };
+}
+function normalizeAssistantMessageForSDK(message) {
+  const content = message.message.content;
+  if (!Array.isArray(content)) {
+    return message.message;
+  }
+  const normalizedContent = content.map((block) => {
+    if (block.type !== "tool_use") {
+      return block;
+    }
+    if (block.name === EXIT_PLAN_MODE_V2_TOOL_NAME) {
+      const plan = getPlan();
+      if (plan) {
+        return {
+          ...block,
+          input: { ...block.input, plan }
+        };
+      }
+    }
+    return block;
+  });
+  return {
+    ...message.message,
+    content: normalizedContent
+  };
+}
+var init_mappers = __esm(() => {
+  init_state();
+  init_xml();
+  init_constants();
+  init_strip_ansi();
+  init_messages();
+  init_plans();
+});
+
+export { toInternalMessages, toSDKCompactMetadata, fromSDKCompactMetadata, toSDKMessages, localCommandOutputToSDKAssistantMessage, toSDKRateLimitInfo, init_mappers };