@caspian2026/agent-sdk 0.0.2

package/dist/chunk-qj2e1apf.js

@@ -0,0 +1,471 @@
+// @bun
+import {
+  OpenAI,
+  adaptOpenAIStreamToAnthropic,
+  anthropicMessagesToOpenAI,
+  anthropicToolChoiceToOpenAI,
+  anthropicToolsToOpenAI,
+  init_convertMessages,
+  init_convertTools,
+  init_openai,
+  init_streamAdapter
+} from "./chunk-mw1kpeg9.js";
+import {
+  addToTotalSessionCost,
+  createAssistantAPIErrorMessage,
+  extractDiscoveredToolNames,
+  getEmptyToolPermissionContext,
+  init_Tool,
+  init_api,
+  init_cost_tracker,
+  init_messages1 as init_messages,
+  init_toolSearch,
+  isToolSearchEnabled,
+  normalizeContentFromAPI,
+  normalizeMessagesForAPI,
+  toolMatchesName,
+  toolToAPISchema
+} from "./chunk-vzgkedm9.js";
+import"./chunk-46hdszda.js";
+import"./chunk-hwfknpxv.js";
+import"./chunk-4nspekjp.js";
+import"./chunk-jzthz1bx.js";
+import"./chunk-1gx78081.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-68w91pzt.js";
+import"./chunk-s4cb0bcb.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-bxcfz5gy.js";
+import"./chunk-nebezy1d.js";
+import"./chunk-wayfjcwt.js";
+import"./chunk-kbm69rtz.js";
+import"./chunk-j5bth84e.js";
+import"./chunk-nxgsnh2y.js";
+import"./chunk-68ffk5qa.js";
+import"./chunk-ps49ymvj.js";
+import"./chunk-bmbq6nt1.js";
+import {
+  TOOL_SEARCH_TOOL_NAME,
+  init_prompt,
+  isDeferredTool
+} from "./chunk-15sfg4bs.js";
+import"./chunk-p7vkh4wx.js";
+import"./chunk-b0qptb1k.js";
+import"./chunk-m87bhhqv.js";
+import"./chunk-j3zhb8vv.js";
+import"./chunk-b2fd462a.js";
+import"./chunk-c11swzas.js";
+import"./chunk-chsyvavm.js";
+import"./chunk-5rv9c8yd.js";
+import {
+  calculateUSDCost,
+  getModelMaxOutputTokens,
+  init_context,
+  init_modelCost
+} from "./chunk-tp2jxmcx.js";
+import"./chunk-z19sd3bt.js";
+import"./chunk-1ax1znzj.js";
+import {
+  getProxyFetchOptions,
+  init_proxy
+} from "./chunk-wha6v7za.js";
+import"./chunk-6nsd9606.js";
+import"./chunk-xp61y5ba.js";
+import"./chunk-64c1avct.js";
+import"./chunk-8g5pe1gr.js";
+import"./chunk-4cp6193g.js";
+import"./chunk-8g747a8x.js";
+import"./chunk-d7886r6a.js";
+import"./chunk-yvtzznds.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-qz2x630m.js";
+import"./chunk-2f21meep.js";
+import"./chunk-nrtksr2p.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-s3hsqf80.js";
+import"./chunk-yyf72f78.js";
+import"./chunk-cdz5yb0r.js";
+import"./chunk-c7jwbe76.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-7sgtxrsc.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-x8d2ehd7.js";
+import"./chunk-15m49c67.js";
+import"./chunk-tdbz9gbm.js";
+import"./chunk-0awwmrwr.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-70eey1nh.js";
+import"./chunk-1nk93fqz.js";
+import"./chunk-s8kj6ajy.js";
+import"./chunk-eenq3avg.js";
+import"./chunk-7mqab3z7.js";
+import"./chunk-5z28bqne.js";
+import"./chunk-qajrkk97.js";
+import {
+  init_debug,
+  logForDebugging
+} from "./chunk-phd1qfpc.js";
+import"./chunk-fbv4apne.js";
+import {
+  init_envUtils,
+  isEnvDefinedFalsy,
+  isEnvTruthy
+} from "./chunk-jaaxk89e.js";
+import"./chunk-k8vp0atq.js";
+import"./chunk-vf612n57.js";
+import"./chunk-07069jq1.js";
+import"./chunk-d4mdda98.js";
+import"./chunk-55raexh7.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-b0kf00ff.js";
+import"./chunk-netzwgv1.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/services/api/openai/client.ts
+function getOpenAIClient(options) {
+  if (cachedClient)
+    return cachedClient;
+  const apiKey = process.env.OPENAI_API_KEY || "";
+  const baseURL = process.env.OPENAI_BASE_URL;
+  const client = new OpenAI({
+    apiKey,
+    ...baseURL && { baseURL },
+    maxRetries: options?.maxRetries ?? 0,
+    timeout: parseInt(process.env.API_TIMEOUT_MS || String(600 * 1000), 10),
+    dangerouslyAllowBrowser: true,
+    ...process.env.OPENAI_ORG_ID && { organization: process.env.OPENAI_ORG_ID },
+    ...process.env.OPENAI_PROJECT_ID && { project: process.env.OPENAI_PROJECT_ID },
+    fetchOptions: getProxyFetchOptions({ forAnthropicAPI: false }),
+    ...options?.fetchOverride && { fetch: options.fetchOverride }
+  });
+  if (!options?.fetchOverride) {
+    cachedClient = client;
+  }
+  return client;
+}
+var cachedClient = null;
+var init_client = __esm(() => {
+  init_openai();
+  init_proxy();
+});
+
+// src/services/api/openai/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 resolveOpenAIModel(anthropicModel) {
+  if (process.env.OPENAI_MODEL) {
+    return process.env.OPENAI_MODEL;
+  }
+  const cleanModel = anthropicModel.replace(/\[1m\]$/, "");
+  const family = getModelFamily(cleanModel);
+  if (family) {
+    const openaiEnvVar = `OPENAI_DEFAULT_${family.toUpperCase()}_MODEL`;
+    const openaiOverride = process.env[openaiEnvVar];
+    if (openaiOverride)
+      return openaiOverride;
+    const anthropicEnvVar = `ANTHROPIC_DEFAULT_${family.toUpperCase()}_MODEL`;
+    const anthropicOverride = process.env[anthropicEnvVar];
+    if (anthropicOverride)
+      return anthropicOverride;
+  }
+  return DEFAULT_MODEL_MAP[cleanModel] ?? cleanModel;
+}
+var DEFAULT_MODEL_MAP;
+var init_modelMapping = __esm(() => {
+  DEFAULT_MODEL_MAP = {
+    "claude-sonnet-4-20250514": "gpt-4o",
+    "claude-sonnet-4-5-20250929": "gpt-4o",
+    "claude-sonnet-4-6": "gpt-4o",
+    "claude-opus-4-20250514": "o3",
+    "claude-opus-4-1-20250805": "o3",
+    "claude-opus-4-5-20251101": "o3",
+    "claude-opus-4-6": "o3",
+    "claude-haiku-4-5-20251001": "gpt-4o-mini",
+    "claude-3-5-haiku-20241022": "gpt-4o-mini",
+    "claude-3-7-sonnet-20250219": "gpt-4o",
+    "claude-3-5-sonnet-20241022": "gpt-4o"
+  };
+});
+
+// src/services/api/openai/index.ts
+import { randomUUID } from "crypto";
+function isOpenAIThinkingEnabled(model) {
+  if (isEnvDefinedFalsy(process.env.OPENAI_ENABLE_THINKING))
+    return false;
+  if (isEnvTruthy(process.env.OPENAI_ENABLE_THINKING))
+    return true;
+  const modelLower = model.toLowerCase();
+  return modelLower.includes("deepseek-reasoner") || modelLower.includes("deepseek-v3.2");
+}
+function buildOpenAIRequestBody(params) {
+  const { model, messages, tools, toolChoice, enableThinking, maxTokens, temperatureOverride } = params;
+  return {
+    model,
+    messages,
+    max_tokens: maxTokens,
+    ...tools.length > 0 && {
+      tools,
+      ...toolChoice && { tool_choice: toolChoice }
+    },
+    stream: true,
+    stream_options: { include_usage: true },
+    ...enableThinking && {
+      thinking: { type: "enabled" },
+      enable_thinking: true,
+      chat_template_kwargs: { thinking: true }
+    },
+    ...!enableThinking && temperatureOverride !== undefined && {
+      temperature: temperatureOverride
+    }
+  };
+}
+function assembleFinalAssistantOutputs(params) {
+  const { partialMessage, contentBlocks, tools, agentId, usage, stopReason, maxTokens } = params;
+  const outputs = [];
+  const allBlocks = Object.keys(contentBlocks).sort((a, b) => Number(a) - Number(b)).map((k) => contentBlocks[Number(k)]).filter(Boolean);
+  if (allBlocks.length > 0) {
+    outputs.push({
+      message: {
+        ...partialMessage,
+        content: normalizeContentFromAPI(allBlocks, tools, agentId),
+        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 ${maxTokens} token limit. ` + `Set CLAUDE_CODE_MAX_OUTPUT_TOKENS to override.`,
+      apiError: "max_output_tokens",
+      error: "max_output_tokens"
+    }));
+  }
+  return outputs;
+}
+async function* queryModelOpenAI(messages, systemPrompt, tools, signal, options) {
+  try {
+    const openaiModel = resolveOpenAIModel(options.model);
+    const messagesForAPI = normalizeMessagesForAPI(messages, tools);
+    const useToolSearch = await isToolSearchEnabled(options.model, tools, options.getToolPermissionContext || (async () => getEmptyToolPermissionContext()), options.agents || [], options.querySource);
+    const deferredToolNames = new Set;
+    if (useToolSearch) {
+      for (const t of tools) {
+        if (isDeferredTool(t))
+          deferredToolNames.add(t.name);
+      }
+    }
+    let filteredTools = tools;
+    if (useToolSearch && deferredToolNames.size > 0) {
+      const discoveredToolNames = extractDiscoveredToolNames(messages);
+      filteredTools = tools.filter((tool) => {
+        if (!deferredToolNames.has(tool.name))
+          return true;
+        if (toolMatchesName(tool, TOOL_SEARCH_TOOL_NAME))
+          return true;
+        return discoveredToolNames.has(tool.name);
+      });
+    }
+    const toolSchemas = await Promise.all(filteredTools.map((tool) => toolToAPISchema(tool, {
+      getToolPermissionContext: options.getToolPermissionContext,
+      tools,
+      agents: options.agents,
+      allowedAgentTypes: options.allowedAgentTypes,
+      model: options.model,
+      deferLoading: useToolSearch && deferredToolNames.has(tool.name)
+    })));
+    const standardTools = toolSchemas.filter((t) => {
+      const anyT = t;
+      return anyT.type !== "advisor_20260301" && anyT.type !== "computer_20250124";
+    });
+    const enableThinking = isOpenAIThinkingEnabled(openaiModel);
+    const openaiMessages = anthropicMessagesToOpenAI(messagesForAPI, systemPrompt, {
+      enableThinking
+    });
+    const openaiTools = anthropicToolsToOpenAI(standardTools);
+    const openaiToolChoice = anthropicToolChoiceToOpenAI(options.toolChoice);
+    if (useToolSearch) {
+      const includedDeferredTools = filteredTools.filter((t) => deferredToolNames.has(t.name)).length;
+      logForDebugging(`[OpenAI] Tool search enabled: ${includedDeferredTools}/${deferredToolNames.size} deferred tools included, total tools=${openaiTools.length}`);
+    } else {
+      logForDebugging(`[OpenAI] Tool search disabled, total tools=${openaiTools.length}`);
+    }
+    const { upperLimit } = getModelMaxOutputTokens(openaiModel);
+    const maxTokens = options.maxOutputTokensOverride ?? upperLimit;
+    const client = getOpenAIClient({
+      maxRetries: 0,
+      fetchOverride: options.fetchOverride,
+      source: options.querySource
+    });
+    logForDebugging(`[OpenAI] Calling model=${openaiModel}, messages=${openaiMessages.length}, tools=${openaiTools.length}, thinking=${enableThinking}`);
+    const requestBody = buildOpenAIRequestBody({
+      model: openaiModel,
+      messages: openaiMessages,
+      tools: openaiTools,
+      toolChoice: openaiToolChoice,
+      enableThinking,
+      maxTokens,
+      temperatureOverride: options.temperatureOverride
+    });
+    const stream = await client.chat.completions.create(requestBody, { signal });
+    const adaptedStream = adaptOpenAIStreamToAnthropic(stream, openaiModel);
+    const contentBlocks = {};
+    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();
+    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": {
+          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) {
+            for (const output of assembleFinalAssistantOutputs({
+              partialMessage,
+              contentBlocks,
+              tools,
+              agentId: options.agentId,
+              usage,
+              stopReason,
+              maxTokens
+            })) {
+              yield output;
+            }
+            partialMessage = null;
+          }
+          if (usage.input_tokens + usage.output_tokens > 0) {
+            const costUSD = calculateUSDCost(openaiModel, usage);
+            addToTotalSessionCost(costUSD, usage, options.model);
+          }
+          break;
+        }
+      }
+      yield {
+        type: "stream_event",
+        event,
+        ...event.type === "message_start" ? { ttftMs } : undefined
+      };
+    }
+    if (partialMessage) {
+      for (const output of assembleFinalAssistantOutputs({
+        partialMessage,
+        contentBlocks,
+        tools,
+        agentId: options.agentId,
+        usage,
+        stopReason,
+        maxTokens
+      })) {
+        yield output;
+      }
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logForDebugging(`[OpenAI] Error: ${errorMessage}`, { level: "error" });
+    yield createAssistantAPIErrorMessage({
+      content: `API Error: ${errorMessage}`,
+      apiError: "api_error",
+      error: error instanceof Error ? error : new Error(String(error))
+    });
+  }
+}
+var init_openai2 = __esm(() => {
+  init_client();
+  init_convertMessages();
+  init_convertTools();
+  init_streamAdapter();
+  init_modelMapping();
+  init_messages();
+  init_api();
+  init_Tool();
+  init_debug();
+  init_cost_tracker();
+  init_modelCost();
+  init_envUtils();
+  init_context();
+  init_messages();
+  init_toolSearch();
+  init_prompt();
+});
+init_openai2();
+
+export {
+  queryModelOpenAI,
+  isOpenAIThinkingEnabled,
+  buildOpenAIRequestBody
+};

package/dist/chunk-qj2mk79w.js

@@ -0,0 +1,111 @@
+// @bun
+import {
+  Select,
+  init_CustomSelect
+} from "./chunk-vzgkedm9.js";
+import {
+  init_config,
+  saveGlobalConfig
+} from "./chunk-tp2jxmcx.js";
+import {
+  Dialog,
+  ThemedText,
+  init_src
+} from "./chunk-c7jwbe76.js";
+import {
+  require_jsx_dev_runtime
+} from "./chunk-7sgtxrsc.js";
+import {
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/components/ApproveApiKey.tsx
+init_src();
+init_config();
+init_CustomSelect();
+var jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+function ApproveApiKey({
+  customApiKeyTruncated,
+  onDone
+}) {
+  function onChange(value) {
+    switch (value) {
+      case "yes": {
+        saveGlobalConfig((current) => ({
+          ...current,
+          customApiKeyResponses: {
+            ...current.customApiKeyResponses,
+            approved: [
+              ...current.customApiKeyResponses?.approved ?? [],
+              customApiKeyTruncated
+            ]
+          }
+        }));
+        onDone(true);
+        break;
+      }
+      case "no": {
+        saveGlobalConfig((current) => ({
+          ...current,
+          customApiKeyResponses: {
+            ...current.customApiKeyResponses,
+            rejected: [
+              ...current.customApiKeyResponses?.rejected ?? [],
+              customApiKeyTruncated
+            ]
+          }
+        }));
+        onDone(false);
+        break;
+      }
+    }
+  }
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Dialog, {
+    title: "Detected a custom API key in your environment",
+    color: "warning",
+    onCancel: () => onChange("no"),
+    children: [
+      /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+            bold: true,
+            children: "ANTHROPIC_API_KEY"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+            children: [
+              ": sk-ant-...",
+              customApiKeyTruncated
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+        children: "Do you want to use this API key?"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Select, {
+        defaultValue: "no",
+        defaultFocusValue: "no",
+        options: [
+          { label: "Yes", value: "yes" },
+          {
+            label: /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+              children: [
+                "No (",
+                /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+                  bold: true,
+                  children: "recommended"
+                }, undefined, false, undefined, this),
+                ")"
+              ]
+            }, undefined, true, undefined, this),
+            value: "no"
+          }
+        ],
+        onChange: (value) => onChange(value),
+        onCancel: () => onChange("no")
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+export { ApproveApiKey };