@theokit/sdk 2.11.3 → 2.13.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 2.13.0
+
+### Minor Changes
+
+- 958a81f: Add per-route opt-in for leaked-dialect safe-parse (`ProviderRoute.extractToolCallsFromContent`, default off). The 2.12.0 release exposed the recovery flag only on a static `ProviderProfile`; enabling it required redeclaring a provider profile. This adds the same flag at the routing layer, so a consumer can opt a single chat route into recovery without cloning the built-in provider: `providers: { routes: [{ capability: "chat", provider: "openrouter", extractToolCallsFromContent: true }] }`. The router clones the resolved profile with the flag for that run (built-in profiles still ship the flag off), so the OpenAI-compatible transport recovers the Hermes `<function=…></tool_call>` dialect leaked as text by models like qwen3-coder. Derived from `routes[0]` (mirrors how the primary provider is derived) and applied to the resolved chat chain; fail-open and default-off, so a non-leaking route is unaffected. This is the enablement path consumed by `@theokit/agents`' `recoverLeakedToolCalls` knob.
+
+## 2.12.0
+
+### Minor Changes
+
+- 95e9cba: Add opt-in leaked-dialect safe-parse for OpenAI-compatible providers (`ProviderProfile.extractToolCallsFromContent`, default off). Some models — notably qwen3-coder via OpenRouter — intermittently emit their Hermes tool-call dialect (`<function=NAME><parameter=KEY>VALUE</parameter></function></tool_call>`) as assistant TEXT instead of native `tool_calls`. When that happens the provider sends ZERO native `tool_calls`, so the agent loop sees a plain `end_turn` and the intended call is silently lost (theokit#58 follow-up). With the flag enabled, a `chat_completions` finish that has no native `tool_calls` has its assistant content scanned for the leaked dialect; any recovered calls are surfaced as real `tool_calls` and the stop reason flips to `tool_use` so the loop dispatches them. Fail-open like `stripThinkBlocks` — a partial/unclosed block is left as text and never fabricates a call. Default off, dedup-guarded (native `tool_calls` always win, no double-count), and scoped per-provider so a code assistant printing a literal `<function=` in a fenced block on a non-leaking route is unaffected.
+
 ## 2.11.3
 
 ### Patch Changes

package/dist/a2a/index.cjs

@@ -10097,6 +10097,40 @@ var init_ollama_native = __esm({
   }
 });
 
+// src/internal/llm/hermes-tool-extract.ts
+function extractHermesToolCalls(content, makeId) {
+  const toolCalls = [];
+  for (const block of content.matchAll(HERMES_BLOCK)) {
+    const name = (block[1] ?? "").trim();
+    if (name.length === 0) continue;
+    toolCalls.push({
+      type: "tool_use",
+      id: makeId(),
+      name,
+      input: parseHermesParams(block[2] ?? "")
+    });
+  }
+  const residualText = toolCalls.length === 0 ? content : content.replace(HERMES_BLOCK, "").trim();
+  return { toolCalls, residualText };
+}
+function parseHermesParams(inner) {
+  const input = {};
+  for (const param of inner.matchAll(HERMES_PARAM)) {
+    const key = param[1];
+    const value = param[2];
+    if (key === void 0 || value === void 0) continue;
+    input[key.trim()] = value;
+  }
+  return input;
+}
+var HERMES_BLOCK, HERMES_PARAM;
+var init_hermes_tool_extract = __esm({
+  "src/internal/llm/hermes-tool-extract.ts"() {
+    HERMES_BLOCK = /<function=\s*([^>\s]+)\s*>([\s\S]*?)<\/tool_call>/g;
+    HERMES_PARAM = /<parameter=\s*([^>\s]+)\s*>([\s\S]*?)<\/parameter>/g;
+  }
+});
+
 // src/internal/llm/openai.ts
 function mapOpenAIFinish(reason) {
   switch (reason) {
@@ -10209,6 +10243,7 @@ var init_openai2 = __esm({
     init_ollama2();
     init_openai_compatible();
     init_finish();
+    init_hermes_tool_extract();
     init_sse();
     OpenAIClient = class {
       constructor(options) {
@@ -10220,6 +10255,14 @@ var init_openai2 = __esm({
       name = "openai";
       baseUrl;
       fetchImpl;
+      /**
+       * Whether this client recovers leaked Hermes tool-call dialect from assistant
+       * text (theokit#58 follow-up). Observability for the route→client wiring of
+       * `extractToolCallsFromContent`. @internal
+       */
+      get recoversLeakedToolCalls() {
+        return this.options.extractToolCallsFromContent ?? false;
+      }
       // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: HTTP+SSE handshake + accumulator is intentionally one block
       async *stream(request, signal) {
         const headers = {
@@ -10270,7 +10313,10 @@ var init_openai2 = __esm({
             endpoint: "/v1/chat/completions"
           });
         }
-        const accumulator = new OpenAIStreamAccumulator();
+        const accumulator = new OpenAIStreamAccumulator(
+          this.options.extractToolCallsFromContent ?? false,
+          providerId
+        );
         for await (const record of parseSseStream(response.body, signal)) {
           if (record.data === "[DONE]") break;
           let chunk;
@@ -10296,6 +10342,16 @@ var init_openai2 = __esm({
       }
     };
     OpenAIStreamAccumulator = class {
+      /**
+       * @param extractFromContent opt-in leaked-dialect safe-parse (theokit#58). Default false.
+       * @param providerName provider id, used only to label the recovery log line.
+       */
+      constructor(extractFromContent = false, providerName = "openai") {
+        this.extractFromContent = extractFromContent;
+        this.providerName = providerName;
+      }
+      extractFromContent;
+      providerName;
       text = "";
       stopReason = "end_turn";
       inputTokens;
@@ -10361,9 +10417,26 @@ var init_openai2 = __esm({
           const input = parseToolArguments(call.args);
           toolCalls.push({ type: "tool_use", id: call.id, name: call.name, input });
         }
+        let text = this.text;
+        let stopReason = this.stopReason;
+        if (this.extractFromContent && toolCalls.length === 0) {
+          const recovered = extractHermesToolCalls(
+            this.text,
+            () => `hermes-${globalThis.crypto.randomUUID()}`
+          );
+          if (recovered.toolCalls.length > 0) {
+            toolCalls.push(...recovered.toolCalls);
+            text = recovered.residualText;
+            stopReason = "tool_use";
+            process.stderr.write(
+              `[theokit-sdk] recovered ${recovered.toolCalls.length} leaked tool call(s) from assistant content (provider="${this.providerName}", names=${recovered.toolCalls.map((c) => c.name).join(",")})
+`
+            );
+          }
+        }
         return makeLlmFinish({
-          stopReason: this.stopReason,
-          text: this.text,
+          stopReason,
+          text,
           toolCalls,
           inputTokens: this.inputTokens,
           outputTokens: this.outputTokens,
@@ -10775,8 +10848,9 @@ function buildChain(options) {
   return clients;
 }
 function buildClient(name, routerOptions) {
-  const profile = getProviderProfile(name);
-  if (profile === void 0) return void 0;
+  const baseProfile = getProviderProfile(name);
+  if (baseProfile === void 0) return void 0;
+  const profile = routerOptions.extractToolCallsFromContent === true && baseProfile.extractToolCallsFromContent !== true ? { ...baseProfile, extractToolCallsFromContent: true } : baseProfile;
   const ambient = currentCredentialPool(name);
   if (ambient !== void 0) {
     return new PoolAwareLlmClient(ambient, (apiKey) => selectTransport(profile, apiKey));
@@ -10876,6 +10950,9 @@ function selectTransport(profile, apiKey) {
     const opts = { apiKey };
     opts.baseUrl = profile.baseUrl;
     opts.providerName = profile.name;
+    if (profile.extractToolCallsFromContent === true) {
+      opts.extractToolCallsFromContent = true;
+    }
     if (profile.name === "openai" && process.env.OPENAI_ORGANIZATION !== void 0) {
       opts.organization = process.env.OPENAI_ORGANIZATION;
     }
@@ -11202,11 +11279,13 @@ function buildLoopInputs(options, runId, userText) {
   const fallback = options.agentOptions.providers?.fallback;
   const apiKeys = options.agentOptions.providers?.apiKeys;
   const credentialPoolStrategy = options.agentOptions.providers?.credentialPoolStrategy;
+  const extractToolCallsFromContent = options.agentOptions.providers?.routes?.[0]?.extractToolCallsFromContent;
   const chain = resolveProviderChain({
     primary,
     ...fallback !== void 0 ? { fallback } : {},
     ...apiKeys !== void 0 ? { apiKeys } : {},
-    ...credentialPoolStrategy !== void 0 ? { credentialPoolStrategy } : {}
+    ...credentialPoolStrategy !== void 0 ? { credentialPoolStrategy } : {},
+    ...extractToolCallsFromContent === true ? { extractToolCallsFromContent: true } : {}
   });
   const llm = chain.length === 1 ? chain[0] : new FallbackLlmClient(chain);
   return {