deepcode-ai 1.1.37 → 1.1.39

package/dist/index.js

@@ -6049,6 +6049,8 @@ var OpenAICompatibleProvider = class {
   extraHeaders;
   normalizeModelId;
   buildRequestBody;
+  contentToolCallParser;
+  contentToolCallMarker;
   apiKeyOptional;
   constructor(options) {
     this.id = options.id;
@@ -6059,6 +6061,8 @@ var OpenAICompatibleProvider = class {
     this.extraHeaders = options.extraHeaders ?? {};
     this.normalizeModelId = options.normalizeModelId;
     this.buildRequestBody = options.buildRequestBody;
+    this.contentToolCallParser = options.contentToolCallParser;
+    this.contentToolCallMarker = options.contentToolCallMarker;
     this.apiKeyOptional = options.apiKeyOptional ?? false;
   }
   async *chat(messages, options) {
@@ -6092,6 +6096,8 @@ var OpenAICompatibleProvider = class {
     await this.assertOk(response);
     const pendingTools = /* @__PURE__ */ new Map();
     let lastUsage = null;
+    const bufferAllContent = Boolean(this.contentToolCallParser);
+    let bufferedContent = "";
     for await (const event of parseSse(response)) {
       const streamError = getOpenAICompatibleStreamError(event);
       if (streamError) {
@@ -6103,7 +6109,11 @@ var OpenAICompatibleProvider = class {
       const choice = event.choices?.[0];
       const delta = choice?.delta;
       if (delta?.content) {
-        yield { type: "delta", content: delta.content };
+        if (bufferAllContent) {
+          bufferedContent += delta.content;
+        } else {
+          yield { type: "delta", content: delta.content };
+        }
       }
       if (typeof delta?.reasoning_content === "string" && delta.reasoning_content.length > 0) {
         yield { type: "reasoning", content: delta.reasoning_content };
@@ -6142,6 +6152,23 @@ var OpenAICompatibleProvider = class {
         };
       }
     }
+    if (bufferAllContent && this.contentToolCallParser) {
+      const marker = this.contentToolCallMarker;
+      const likelyHasDsml = !marker || bufferedContent.includes(marker);
+      const parsed = likelyHasDsml ? this.contentToolCallParser(bufferedContent) : null;
+      if (parsed) {
+        if (parsed.remainder) yield { type: "delta", content: parsed.remainder };
+        for (let i = 0; i < parsed.toolCalls.length; i++) {
+          const call = parsed.toolCalls[i];
+          yield {
+            type: "tool_call",
+            call: { id: `dsml_${i}`, name: call.name, arguments: call.arguments }
+          };
+        }
+      } else if (bufferedContent) {
+        yield { type: "delta", content: bufferedContent };
+      }
+    }
     for (const [index, call] of pendingTools) {
       if (!call.name) continue;
       yield {
@@ -6308,6 +6335,57 @@ function toOpenAICompatibleToolChoice(toolChoice) {
   }
   return toolChoice;
 }
+var PIPE_PAT = "[\uFF5C|]{1,2}";
+var DSML_HINT = "DSML";
+var TOOL_CALLS_OPEN_RE = new RegExp(`<${PIPE_PAT}DSML${PIPE_PAT}tool_calls>`, "i");
+var TOOL_CALLS_CLOSE_RE = new RegExp(`<\\/${PIPE_PAT}DSML${PIPE_PAT}tool_calls>`, "i");
+var INVOKE_RE_SRC = `<${PIPE_PAT}DSML${PIPE_PAT}invoke name="([^"]+)">(.*?)<\\/${PIPE_PAT}DSML${PIPE_PAT}invoke>`;
+var PARAM_RE_SRC = `<${PIPE_PAT}DSML${PIPE_PAT}parameter name="([^"]+)"([^>]*)>(.*?)<\\/${PIPE_PAT}DSML${PIPE_PAT}parameter>`;
+function parseDSMLToolCalls(content) {
+  const openMatch = TOOL_CALLS_OPEN_RE.exec(content);
+  if (!openMatch) return null;
+  const startIdx = openMatch.index;
+  const blockStart = startIdx + openMatch[0].length;
+  const closeMatch = TOOL_CALLS_CLOSE_RE.exec(content.slice(blockStart));
+  if (!closeMatch) return null;
+  const blockEnd = blockStart + closeMatch.index;
+  const closeEnd = blockEnd + closeMatch[0].length;
+  const remainder = (content.slice(0, startIdx) + content.slice(closeEnd)).trim();
+  const block = content.slice(blockStart, blockEnd);
+  const toolCalls = [];
+  const invokeRe = new RegExp(INVOKE_RE_SRC, "gis");
+  let invokeMatch;
+  while ((invokeMatch = invokeRe.exec(block)) !== null) {
+    const toolName = invokeMatch[1];
+    const paramBlock = invokeMatch[2];
+    const args = {};
+    const paramRe = new RegExp(PARAM_RE_SRC, "gis");
+    let paramMatch;
+    while ((paramMatch = paramRe.exec(paramBlock)) !== null) {
+      const paramName = paramMatch[1];
+      const paramAttrs = paramMatch[2];
+      const rawValue = paramMatch[3].trim();
+      args[paramName] = coerceDSMLParam(rawValue, paramAttrs);
+    }
+    toolCalls.push({ name: toolName, arguments: args });
+  }
+  return { toolCalls, remainder };
+}
+function coerceDSMLParam(value, attrs) {
+  if (/\bstring="true"/i.test(attrs)) return value;
+  if (/\bnumber="true"/i.test(attrs)) {
+    const n = Number(value);
+    return Number.isNaN(n) ? value : n;
+  }
+  if (/\bboolean="true"/i.test(attrs)) {
+    return value.toLowerCase() === "true";
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
 var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([408, 429, 502, 503, 504]);
 var MODEL_CATALOG_GRACE_MS = 250;
 function isRetryableError(error) {
@@ -6368,7 +6446,9 @@ var ProviderManager = class {
         buildRequestBody: (body, context) => ({
           ...body,
           thinking: buildDeepSeekThinkingOverride(context.model)
-        })
+        }),
+        contentToolCallParser: parseDSMLToolCalls,
+        contentToolCallMarker: DSML_HINT
       })
     );
     this.register(
@@ -28344,7 +28424,7 @@ function parseVersion2(version) {
   if (!match) return null;
   return [Number(match[1]), Number(match[2]), Number(match[3])];
 }
-var VERSION = "1.1.37".length > 0 ? "1.1.37" : "0.0.0-dev";
+var VERSION = "1.1.39".length > 0 ? "1.1.39" : "0.0.0-dev";
 var updateCommand = {
   name: "update",
   description: "Check published DeepCode versions",