deepseek-toolkit 0.1.0

package/dist/index.cjs

@@ -0,0 +1,742 @@
+'use strict';
+
+var OpenAI = require('openai');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var OpenAI__default = /*#__PURE__*/_interopDefault(OpenAI);
+
+// src/client.ts
+
+// src/errors.ts
+var DeepSeekError = class extends Error {
+  constructor(message, status, code) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "DeepSeekError";
+  }
+  status;
+  code;
+};
+var BraveSearchError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "BraveSearchError";
+  }
+  status;
+};
+var ToolError = class extends Error {
+  constructor(message, toolName) {
+    super(message);
+    this.toolName = toolName;
+    this.name = "ToolError";
+  }
+  toolName;
+};
+var ToolLoopError = class extends Error {
+  constructor(message, iterations) {
+    super(message);
+    this.iterations = iterations;
+    this.name = "ToolLoopError";
+  }
+  iterations;
+};
+var ConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigError";
+  }
+};
+
+// src/types/models.ts
+var DEEPSEEK_MODELS = {
+  V4_PRO: "deepseek-v4-pro",
+  V4_FLASH: "deepseek-v4-flash"
+};
+var DEEPSEEK_BASE_URL = "https://api.deepseek.com";
+var DEEPSEEK_BETA_BASE_URL = "https://api.deepseek.com/beta";
+var BRAVE_WEB_SEARCH_URL = "https://api.search.brave.com/res/v1/web/search";
+var BRAVE_LLM_CONTEXT_URL = "https://api.search.brave.com/res/v1/llm/context";
+var DEFAULT_MAX_TOOL_LOOP_ITERATIONS = 10;
+
+// src/brave-search.ts
+var BraveSearchClient = class {
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+  apiKey;
+  async webSearch(query, options = {}) {
+    const params = new URLSearchParams();
+    params.set("q", query);
+    if (options.country) params.set("country", options.country);
+    if (options.searchLang) params.set("search_lang", options.searchLang);
+    if (options.safesearch) params.set("safesearch", options.safesearch);
+    if (options.freshness) params.set("freshness", options.freshness);
+    if (options.count !== void 0)
+      params.set("count", String(options.count));
+    if (options.offset !== void 0)
+      params.set("offset", String(options.offset));
+    if (options.extraSnippets)
+      params.set("extra_snippets", "true");
+    const url = `${BRAVE_WEB_SEARCH_URL}?${params.toString()}`;
+    const response = await fetch(url, {
+      headers: {
+        "X-Subscription-Token": this.apiKey,
+        Accept: "application/json"
+      }
+    });
+    if (!response.ok) {
+      throw new BraveSearchError(
+        `Brave Web Search failed: ${response.status} ${response.statusText}`,
+        response.status
+      );
+    }
+    return response.json();
+  }
+  async llmContext(query, options = {}) {
+    const params = new URLSearchParams();
+    params.set("q", query);
+    if (options.country) params.set("country", options.country);
+    if (options.searchLang) params.set("search_lang", options.searchLang);
+    if (options.freshness) params.set("freshness", options.freshness);
+    if (options.count !== void 0)
+      params.set("count", String(options.count));
+    if (options.maxUrls !== void 0)
+      params.set("maximum_number_of_urls", String(options.maxUrls));
+    if (options.maxTokens !== void 0)
+      params.set("maximum_number_of_tokens", String(options.maxTokens));
+    if (options.maxSnippets !== void 0)
+      params.set("maximum_number_of_snippets", String(options.maxSnippets));
+    if (options.maxTokensPerUrl !== void 0)
+      params.set(
+        "maximum_number_of_tokens_per_url",
+        String(options.maxTokensPerUrl)
+      );
+    if (options.maxSnippetsPerUrl !== void 0)
+      params.set(
+        "maximum_number_of_snippets_per_url",
+        String(options.maxSnippetsPerUrl)
+      );
+    if (options.contextThresholdMode)
+      params.set("context_threshold_mode", options.contextThresholdMode);
+    if (options.enableLocal !== void 0 && options.enableLocal !== null)
+      params.set("enable_local", String(options.enableLocal));
+    if (options.safesearch) params.set("safesearch", options.safesearch);
+    const url = `${BRAVE_LLM_CONTEXT_URL}?${params.toString()}`;
+    const response = await fetch(url, {
+      headers: {
+        "X-Subscription-Token": this.apiKey,
+        Accept: "application/json"
+      }
+    });
+    if (!response.ok) {
+      throw new BraveSearchError(
+        `Brave LLM Context failed: ${response.status} ${response.statusText}`,
+        response.status
+      );
+    }
+    return response.json();
+  }
+};
+
+// src/tool-manager.ts
+var ToolManager = class {
+  tools = /* @__PURE__ */ new Map();
+  addTool(definition, handler) {
+    const name = definition.function.name;
+    if (this.tools.has(name)) {
+      throw new ToolError(`Tool "${name}" is already registered`, name);
+    }
+    this.tools.set(name, { definition, handler });
+  }
+  addTools(tools) {
+    for (const tool of tools) {
+      this.addTool(tool.definition, tool.handler);
+    }
+  }
+  removeTool(name) {
+    return this.tools.delete(name);
+  }
+  getTool(name) {
+    return this.tools.get(name);
+  }
+  hasTool(name) {
+    return this.tools.has(name);
+  }
+  getToolDefinitions() {
+    return Array.from(this.tools.values()).map((t) => t.definition);
+  }
+  getHandler(name) {
+    return this.tools.get(name)?.handler;
+  }
+  hasHandler(name) {
+    const tool = this.tools.get(name);
+    return tool !== void 0 && tool.handler !== void 0;
+  }
+  async executeToolCall(name, args, toolCallId) {
+    const handler = this.getHandler(name);
+    if (!handler) {
+      throw new ToolError(
+        `No handler registered for tool "${name}". Provide a handler via addTool() to enable automatic execution.`,
+        name
+      );
+    }
+    const result = await handler(args);
+    return {
+      tool_call_id: toolCallId,
+      role: "tool",
+      content: typeof result === "string" ? result : JSON.stringify(result)
+    };
+  }
+  get registeredCount() {
+    return this.tools.size;
+  }
+  get registeredNames() {
+    return Array.from(this.tools.keys());
+  }
+  clear() {
+    this.tools.clear();
+  }
+};
+
+// src/reasoning.ts
+var ReasoningState = class {
+  activeToolCall = false;
+  startToolCallTurn() {
+    this.activeToolCall = true;
+  }
+  endToolCallTurn() {
+    this.activeToolCall = false;
+  }
+  shouldIncludeReasoning() {
+    return this.activeToolCall;
+  }
+  reset() {
+    this.activeToolCall = false;
+  }
+  cleanMessageForContext(message) {
+    if (this.activeToolCall) {
+      return message;
+    }
+    if (message.reasoning_content && !message.tool_calls?.length) {
+      const { reasoning_content: _, ...rest } = message;
+      return rest;
+    }
+    return message;
+  }
+};
+
+// src/tool-loop.ts
+var ToolLoop = class {
+  constructor(openai, config, toolManager) {
+    this.openai = openai;
+    this.config = config;
+    this.toolManager = toolManager;
+    this.reasoning = new ReasoningState();
+  }
+  openai;
+  config;
+  toolManager;
+  reasoning;
+  async run(messages, tools, toolChoice, callbacks) {
+    const allTools = [
+      ...this.toolManager.getToolDefinitions(),
+      ...tools ?? []
+    ];
+    let response = await this.makeRequest(messages, allTools, toolChoice);
+    let iterations = 0;
+    while (this.hasToolCalls(response) && iterations < this.config.maxToolLoopIterations) {
+      iterations++;
+      this.reasoning.startToolCallTurn();
+      const choice = response.choices[0];
+      if (!choice) break;
+      const toolCalls = choice.message.tool_calls ?? [];
+      const toolResults = await this.executeToolCalls(toolCalls, callbacks);
+      messages.push(choice.message);
+      for (const tr of toolResults) {
+        messages.push(tr);
+      }
+      response = await this.makeRequest(messages, allTools, toolChoice);
+      this.reasoning.endToolCallTurn();
+    }
+    if (iterations >= this.config.maxToolLoopIterations) {
+      const lastChoice = response.choices[0];
+      if (lastChoice && this.hasToolCallsInChoice(response)) {
+        throw new ToolLoopError(
+          `Tool call loop exceeded maximum iterations (${this.config.maxToolLoopIterations})`,
+          iterations
+        );
+      }
+    }
+    return response;
+  }
+  async runStream(messages, tools, toolChoice, callbacks) {
+    const allTools = [
+      ...this.toolManager.getToolDefinitions(),
+      ...tools ?? []
+    ];
+    let streamResult = await this.makeStreamRequest(messages, allTools, toolChoice);
+    let iterations = 0;
+    let accumulatedToolCalls = [];
+    let finalChunks = [];
+    for await (const chunk of streamResult) {
+      const delta = chunk.choices[0]?.delta;
+      if (delta?.tool_calls) {
+        for (const tc of delta.tool_calls) {
+          if (tc.id) {
+            accumulatedToolCalls.push({
+              id: tc.id,
+              name: tc.function?.name ?? "",
+              arguments: tc.function?.arguments ?? ""
+            });
+          } else if (tc.function?.arguments) {
+            const existing = accumulatedToolCalls[accumulatedToolCalls.length - 1];
+            if (existing) {
+              existing.arguments += tc.function.arguments;
+            }
+          }
+        }
+      }
+      finalChunks.push(chunk);
+    }
+    if (accumulatedToolCalls.length > 0 && iterations < this.config.maxToolLoopIterations) {
+      this.reasoning.startToolCallTurn();
+      const toolResults = await this.executeToolCalls(
+        accumulatedToolCalls.map((tc) => ({
+          id: tc.id,
+          type: "function",
+          function: { name: tc.name, arguments: tc.arguments }
+        })),
+        callbacks
+      );
+      const assistantMsg = {
+        role: "assistant",
+        content: null,
+        tool_calls: accumulatedToolCalls.map((tc) => ({
+          id: tc.id,
+          type: "function",
+          function: { name: tc.name, arguments: tc.arguments }
+        }))
+      };
+      messages.push(assistantMsg);
+      for (const tr of toolResults) {
+        messages.push(tr);
+      }
+      const nextResponse = await this.makeStreamRequest(messages, allTools, toolChoice);
+      this.reasoning.endToolCallTurn();
+      return nextResponse;
+    }
+    return this.chunksToAsyncIterable(finalChunks);
+  }
+  async makeRequest(messages, tools, toolChoice) {
+    const params = {
+      model: this.config.model,
+      messages,
+      reasoning_effort: this.config.reasoningEffort,
+      thinking: this.config.thinking
+    };
+    if (tools && tools.length > 0) {
+      params.tools = tools;
+      params.tool_choice = toolChoice ?? "auto";
+    }
+    if (this.config.maxTokens !== void 0) params.max_tokens = this.config.maxTokens;
+    if (this.config.temperature !== void 0) params.temperature = this.config.temperature;
+    if (this.config.topP !== void 0) params.top_p = this.config.topP;
+    const result = await this.openai.chat.completions.create(params);
+    return result;
+  }
+  async makeStreamRequest(messages, tools, toolChoice) {
+    const params = {
+      model: this.config.model,
+      messages,
+      stream: true,
+      reasoning_effort: this.config.reasoningEffort,
+      thinking: this.config.thinking
+    };
+    if (tools && tools.length > 0) {
+      params.tools = tools;
+      params.tool_choice = toolChoice ?? "auto";
+    }
+    if (this.config.maxTokens !== void 0) params.max_tokens = this.config.maxTokens;
+    if (this.config.temperature !== void 0) params.temperature = this.config.temperature;
+    if (this.config.topP !== void 0) params.top_p = this.config.topP;
+    const stream = await this.openai.chat.completions.create(params);
+    return stream;
+  }
+  async executeToolCalls(toolCalls, callbacks) {
+    const results = [];
+    for (const tc of toolCalls) {
+      const name = tc.function.name;
+      let args = {};
+      try {
+        args = JSON.parse(tc.function.arguments);
+      } catch {
+        args = {};
+      }
+      if (callbacks?.onToolCall) {
+        const result = await callbacks.onToolCall(name, args, tc.id);
+        results.push({
+          tool_call_id: tc.id,
+          role: "tool",
+          content: result
+        });
+        callbacks.onToolResult?.(name, result);
+      } else if (this.toolManager.hasHandler(name)) {
+        const tr = await this.toolManager.executeToolCall(name, args, tc.id);
+        results.push(tr);
+        callbacks?.onToolResult?.(name, tr.content);
+      } else {
+        results.push({
+          tool_call_id: tc.id,
+          role: "tool",
+          content: `Tool "${name}" has no handler registered. Register a handler to enable automatic execution.`
+        });
+      }
+    }
+    return results;
+  }
+  hasToolCalls(response) {
+    return this.hasToolCallsInChoice(response);
+  }
+  hasToolCallsInChoice(response) {
+    const choice = response.choices[0];
+    if (!choice) return false;
+    return choice.finish_reason === "tool_calls" && (choice.message.tool_calls?.length ?? 0) > 0;
+  }
+  async *chunksToAsyncIterable(chunks) {
+    for (const chunk of chunks) {
+      yield chunk;
+    }
+  }
+  get reasoningState() {
+    return this.reasoning;
+  }
+  resetReasoning() {
+    this.reasoning.reset();
+  }
+};
+
+// src/defaults.ts
+var DEFAULT_CONFIG = {
+  model: DEEPSEEK_MODELS.V4_PRO,
+  baseURL: DEEPSEEK_BASE_URL,
+  thinking: { type: "enabled" },
+  reasoningEffort: "high",
+  braveSearch: {
+    safesearch: "off",
+    freshness: void 0,
+    country: "US",
+    searchLang: "en",
+    count: 10
+  },
+  maxToolLoopIterations: DEFAULT_MAX_TOOL_LOOP_ITERATIONS
+};
+var BRAVE_WEB_SEARCH_TOOL_DEFINITION = {
+  type: "function",
+  function: {
+    name: "brave_web_search",
+    description: "Search the web using Brave Search. Returns web page results with titles, URLs, and descriptions. Use this to find current information, news, documentation, or any web content.",
+    parameters: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "The search query"
+        },
+        freshness: {
+          type: "string",
+          enum: ["pd", "pw", "pm", "py"],
+          description: "Filter results by freshness: pd (24h), pw (7 days), pm (month), py (year)"
+        },
+        count: {
+          type: "integer",
+          minimum: 1,
+          maximum: 20,
+          description: "Number of results (max 20)"
+        },
+        safesearch: {
+          type: "string",
+          enum: ["off", "moderate", "strict"],
+          description: "Content filter level"
+        }
+      },
+      required: ["query"]
+    }
+  }
+};
+var BRAVE_LLM_CONTEXT_TOOL_DEFINITION = {
+  type: "function",
+  function: {
+    name: "brave_llm_context",
+    description: "Search the web and get content optimized for AI consumption. Returns pre-extracted text snippets from web pages, ideal for grounding responses in current information.",
+    parameters: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "The search query"
+        },
+        freshness: {
+          type: "string",
+          enum: ["pd", "pw", "pm", "py"],
+          description: "Filter results by freshness: pd (24h), pw (7 days), pm (month), py (year)"
+        },
+        maxTokens: {
+          type: "integer",
+          minimum: 1024,
+          maximum: 32768,
+          description: "Max tokens in context (default 8192)"
+        },
+        maxUrls: {
+          type: "integer",
+          minimum: 1,
+          maximum: 50,
+          description: "Maximum URLs to include (default 20)"
+        }
+      },
+      required: ["query"]
+    }
+  }
+};
+function resolveConfig(config) {
+  return {
+    deepseekApiKey: config.deepseekApiKey,
+    braveSearchApiKey: config.braveSearchApiKey,
+    model: config.model ?? DEFAULT_CONFIG.model,
+    baseURL: config.baseURL ?? DEFAULT_CONFIG.baseURL,
+    thinking: config.thinking ?? DEFAULT_CONFIG.thinking,
+    reasoningEffort: config.reasoningEffort ?? DEFAULT_CONFIG.reasoningEffort,
+    braveSearch: {
+      safesearch: config.braveSearch?.safesearch ?? DEFAULT_CONFIG.braveSearch.safesearch,
+      freshness: config.braveSearch?.freshness ?? DEFAULT_CONFIG.braveSearch.freshness,
+      country: config.braveSearch?.country ?? DEFAULT_CONFIG.braveSearch.country,
+      searchLang: config.braveSearch?.searchLang ?? DEFAULT_CONFIG.braveSearch.searchLang,
+      count: config.braveSearch?.count ?? DEFAULT_CONFIG.braveSearch.count
+    },
+    maxTokens: config.maxTokens,
+    temperature: config.temperature,
+    topP: config.topP,
+    maxToolLoopIterations: config.maxToolLoopIterations ?? DEFAULT_CONFIG.maxToolLoopIterations
+  };
+}
+
+// src/client.ts
+var DeepSeekClient = class {
+  config;
+  openai;
+  braveSearch;
+  toolManager;
+  toolLoop;
+  constructor(config) {
+    if (!config.deepseekApiKey) {
+      throw new ConfigError("deepseekApiKey is required");
+    }
+    this.config = resolveConfig(config);
+    this.openai = new OpenAI__default.default({
+      apiKey: this.config.deepseekApiKey,
+      baseURL: this.config.baseURL
+    });
+    if (config.braveSearchApiKey) {
+      this.braveSearch = new BraveSearchClient(config.braveSearchApiKey);
+    }
+    this.toolManager = new ToolManager();
+    this.toolLoop = new ToolLoop(this.openai, this.config, this.toolManager);
+    this.registerBuiltinTools();
+  }
+  registerBuiltinTools() {
+    if (this.braveSearch) {
+      this.toolManager.addTool(
+        BRAVE_WEB_SEARCH_TOOL_DEFINITION,
+        async (args) => {
+          const result = await this.braveSearch.webSearch(
+            args.query,
+            {
+              freshness: args.freshness,
+              safesearch: args.safesearch ?? this.config.braveSearch.safesearch,
+              count: args.count ?? this.config.braveSearch.count,
+              country: this.config.braveSearch.country,
+              searchLang: this.config.braveSearch.searchLang
+            }
+          );
+          return JSON.stringify(result);
+        }
+      );
+      this.toolManager.addTool(
+        BRAVE_LLM_CONTEXT_TOOL_DEFINITION,
+        async (args) => {
+          const result = await this.braveSearch.llmContext(
+            args.query,
+            {
+              freshness: args.freshness,
+              maxTokens: args.maxTokens,
+              maxUrls: args.maxUrls,
+              country: this.config.braveSearch.country,
+              searchLang: this.config.braveSearch.searchLang,
+              safesearch: this.config.braveSearch.safesearch
+            }
+          );
+          return JSON.stringify(result);
+        }
+      );
+    }
+  }
+  async chat(messages, options) {
+    const prevModel = this.config.model;
+    const prevThinking = this.config.thinking;
+    const prevEffort = this.config.reasoningEffort;
+    const prevMaxTokens = this.config.maxTokens;
+    const prevTemp = this.config.temperature;
+    const prevTopP = this.config.topP;
+    if (options?.model) this.config.model = options.model;
+    if (options?.thinking) this.config.thinking = options.thinking;
+    if (options?.reasoningEffort)
+      this.config.reasoningEffort = options.reasoningEffort;
+    if (options?.maxTokens !== void 0)
+      this.config.maxTokens = options.maxTokens;
+    if (options?.temperature !== void 0)
+      this.config.temperature = options.temperature;
+    if (options?.topP !== void 0) this.config.topP = options.topP;
+    try {
+      return await this.toolLoop.run(
+        messages,
+        options?.tools,
+        options?.toolChoice,
+        {
+          onToolCall: options?.onToolCall,
+          onToolResult: options?.onToolResult
+        }
+      );
+    } finally {
+      this.config.model = prevModel;
+      this.config.thinking = prevThinking;
+      this.config.reasoningEffort = prevEffort;
+      this.config.maxTokens = prevMaxTokens;
+      this.config.temperature = prevTemp;
+      this.config.topP = prevTopP;
+    }
+  }
+  async chatStream(messages, options) {
+    const prevModel = this.config.model;
+    const prevThinking = this.config.thinking;
+    const prevEffort = this.config.reasoningEffort;
+    const prevMaxTokens = this.config.maxTokens;
+    const prevTemp = this.config.temperature;
+    const prevTopP = this.config.topP;
+    if (options?.model) this.config.model = options.model;
+    if (options?.thinking) this.config.thinking = options.thinking;
+    if (options?.reasoningEffort)
+      this.config.reasoningEffort = options.reasoningEffort;
+    if (options?.maxTokens !== void 0)
+      this.config.maxTokens = options.maxTokens;
+    if (options?.temperature !== void 0)
+      this.config.temperature = options.temperature;
+    if (options?.topP !== void 0) this.config.topP = options.topP;
+    try {
+      return await this.toolLoop.runStream(
+        messages,
+        options?.tools,
+        options?.toolChoice,
+        {
+          onToolCall: options?.onToolCall,
+          onToolResult: options?.onToolResult
+        }
+      );
+    } finally {
+      this.config.model = prevModel;
+      this.config.thinking = prevThinking;
+      this.config.reasoningEffort = prevEffort;
+      this.config.maxTokens = prevMaxTokens;
+      this.config.temperature = prevTemp;
+      this.config.topP = prevTopP;
+    }
+  }
+  addTool(definition, handler) {
+    this.toolManager.addTool(definition, handler);
+  }
+  addTools(tools) {
+    this.toolManager.addTools(tools);
+  }
+  removeTool(name) {
+    return this.toolManager.removeTool(name);
+  }
+  getTools() {
+    return this.toolManager.getToolDefinitions().map((d) => {
+      const registered = this.toolManager.getTool(d.function.name);
+      return registered;
+    });
+  }
+  hasTool(name) {
+    return this.toolManager.hasTool(name);
+  }
+  async executeToolCall(name, args, toolCallId) {
+    return this.toolManager.executeToolCall(name, args, toolCallId);
+  }
+  async search(query, options) {
+    if (!this.braveSearch) {
+      throw new ConfigError(
+        "Brave Search is not configured. Provide braveSearchApiKey in config."
+      );
+    }
+    return this.braveSearch.webSearch(query, options ?? {});
+  }
+  async searchAsContext(query, options) {
+    if (!this.braveSearch) {
+      throw new ConfigError(
+        "Brave Search is not configured. Provide braveSearchApiKey in config."
+      );
+    }
+    return this.braveSearch.llmContext(query, options ?? {});
+  }
+  get model() {
+    return this.config.model;
+  }
+  set model(m) {
+    this.config.model = m;
+  }
+  get thinking() {
+    return this.config.thinking;
+  }
+  set thinking(t) {
+    this.config.thinking = t;
+  }
+  get reasoningEffort() {
+    return this.config.reasoningEffort;
+  }
+  set reasoningEffort(r) {
+    this.config.reasoningEffort = r;
+  }
+  get braveSearchDefaults() {
+    return this.config.braveSearch;
+  }
+  set braveSearchDefaults(d) {
+    this.config.braveSearch = { ...this.config.braveSearch, ...d };
+  }
+  get openaiClient() {
+    return this.openai;
+  }
+};
+
+exports.BRAVE_LLM_CONTEXT_TOOL_DEFINITION = BRAVE_LLM_CONTEXT_TOOL_DEFINITION;
+exports.BRAVE_LLM_CONTEXT_URL = BRAVE_LLM_CONTEXT_URL;
+exports.BRAVE_WEB_SEARCH_TOOL_DEFINITION = BRAVE_WEB_SEARCH_TOOL_DEFINITION;
+exports.BRAVE_WEB_SEARCH_URL = BRAVE_WEB_SEARCH_URL;
+exports.BraveSearchClient = BraveSearchClient;
+exports.BraveSearchError = BraveSearchError;
+exports.ConfigError = ConfigError;
+exports.DEEPSEEK_BASE_URL = DEEPSEEK_BASE_URL;
+exports.DEEPSEEK_BETA_BASE_URL = DEEPSEEK_BETA_BASE_URL;
+exports.DEEPSEEK_MODELS = DEEPSEEK_MODELS;
+exports.DEFAULT_CONFIG = DEFAULT_CONFIG;
+exports.DEFAULT_MAX_TOOL_LOOP_ITERATIONS = DEFAULT_MAX_TOOL_LOOP_ITERATIONS;
+exports.DeepSeekClient = DeepSeekClient;
+exports.DeepSeekError = DeepSeekError;
+exports.ReasoningState = ReasoningState;
+exports.ToolError = ToolError;
+exports.ToolLoop = ToolLoop;
+exports.ToolLoopError = ToolLoopError;
+exports.ToolManager = ToolManager;
+exports.resolveConfig = resolveConfig;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map