cartethyia 2.7.0 → 2.7.2

package/src/providers/integrations/buddy/buddy-server-tools.ts

@@ -0,0 +1,240 @@
+/**
+ * Gateway-executed "server tools" for the Buddy family, ported from the
+ * reference gateway (`lib/server/proxy/server-tools/` in `codebuddy2api`).
+ *
+ * Some clients ask the *provider* to run a web tool by declaring a
+ * provider-executed type: Anthropic sends `web_search_20250305` /
+ * `web_fetch_20250910`, the Responses API sends `web_search_preview`.
+ * Upstream CodeBuddy has none of these, so the gateway executes the call
+ * against a backend and hands the findings back as if upstream had produced
+ * them.
+ *
+ * The distinction is declaration-driven, never name-driven: a client's own
+ * ordinary `function` named `WebSearch` (Claude Code) is resolved by the
+ * client, and the gateway must not pick it up. Only calls whose *declared
+ * type* carries the provider-executed prefix are server tools.
+ *
+ * This module is the pure engine: classification, invocation building,
+ * execution against injected backends, and the transcript messages a follow-up
+ * upstream call needs. The streaming loop that re-drives the upstream within
+ * one request is the adapter-side consumer.
+ */
+import type { ToolDefinition } from "../../../protocol/canonical-model";
+
+export type ServerToolKind = "web_search" | "web_fetch";
+
+export interface ServerToolDeclaration {
+  readonly kind: ServerToolKind;
+  readonly name: string;
+}
+
+export interface ServerToolInvocation {
+  readonly id: string;
+  readonly kind: ServerToolKind;
+  readonly rawArguments: string;
+}
+
+export interface ServerToolRunResult {
+  /** Text handed back upstream as the tool's result message. */
+  readonly content: string;
+  readonly toolCallId: string;
+}
+
+export interface ServerToolExecutor {
+  /** Runs one web fetch; `null` means the backend is unavailable. */
+  readonly fetch?: ((input: { url: string }) => Promise<string>) | undefined;
+  /** Runs one web search; `null` means the backend is unavailable. */
+  readonly search?: ((input: { query: string }) => Promise<string>) | undefined;
+}
+
+/** The declared-type prefixes the provider-executed tools carry. */
+const SEARCH_TYPE_PREFIX = "web_search_";
+const FETCH_TYPE_PREFIX = "web_fetch_";
+
+function normalizeTypeName(value: string): string {
+  return value.trim().toLowerCase().replace(/[_-]+/g, " ");
+}
+
+function classifyByType(type: string): ServerToolKind | null {
+  const normalized = normalizeTypeName(type);
+  if (normalized.startsWith(normalizeTypeName(SEARCH_TYPE_PREFIX))) return "web_search";
+  if (normalized.startsWith(normalizeTypeName(FETCH_TYPE_PREFIX))) return "web_fetch";
+  return null;
+}
+
+/**
+ * Classifies one canonical tool declaration, or returns `null` for a
+ * client-owned tool. Only the declared type counts; the name is never
+ * consulted, so a client function named `WebSearch` is never mistaken for the
+ * server tool. `native_type` retains the raw Anthropic/OpenAI type spelling
+ * (`web_search_20250305`, `web_fetch_20250910`) when the surface carries one;
+ * otherwise the normalized `tool_type` decides.
+ */
+export function classifyServerToolDeclaration(tool: ToolDefinition): ServerToolKind | null {
+  const raw = tool.native_type?.trim();
+  if (raw !== undefined && raw.length > 0) {
+    const byRaw = classifyByType(raw);
+    if (byRaw !== null) return byRaw;
+  }
+  if (tool.tool_type === "web_search") return "web_search";
+  if (tool.tool_type !== undefined && tool.tool_type !== "function") {
+    const byType = classifyByType(tool.tool_type);
+    if (byType !== null) return byType;
+  }
+  return null;
+}
+
+/** Indexes declared server tools by the name a call would carry. */
+export function findServerToolDeclarations(
+  tools: readonly ToolDefinition[] | undefined,
+): Map<string, ServerToolKind> {
+  const out = new Map<string, ServerToolKind>();
+  for (const tool of tools ?? []) {
+    const kind = classifyServerToolDeclaration(tool);
+    if (kind !== null) out.set(tool.name, kind);
+  }
+  return out;
+}
+
+/** True when a call's name matches a declared server tool. */
+export function isServerToolCall(
+  name: string,
+  declared: ReadonlyMap<string, ServerToolKind>,
+): boolean {
+  return declared.has(name);
+}
+
+function parseJsonArguments(raw: string): Record<string, unknown> {
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return parsed as Record<string, unknown>;
+    }
+  } catch {
+    // fall through
+  }
+  return {};
+}
+
+/** Builds one invocation from a tool call, kind already classified. */
+export function buildServerToolInvocation(
+  callId: string,
+  name: string,
+  kind: ServerToolKind,
+  rawArguments: string,
+): ServerToolInvocation {
+  return { id: callId || `server_tool_${name}`, kind, rawArguments };
+}
+
+function textOf(value: unknown): string {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function safeFetchUrl(url: string): string | null {
+  let parsed: URL;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return null;
+  }
+  if (parsed.protocol !== "https:" && parsed.protocol !== "http:") return null;
+  return parsed.toString();
+}
+
+/**
+ * Runs one invocation against the injected backend. Failures become text
+ * rather than exceptions: the arguments came from the model, so the useful
+ * outcome is for it to see what went wrong and retry or answer without the
+ * findings — not for the whole turn to fail.
+ */
+async function runOne(
+  executor: ServerToolExecutor,
+  invocation: ServerToolInvocation,
+): Promise<ServerToolRunResult> {
+  const args = parseJsonArguments(invocation.rawArguments);
+  if (invocation.kind === "web_fetch") {
+    const url = safeFetchUrl(textOf(args["url"] ?? args["target"]));
+    if (url === null) {
+      return {
+        toolCallId: invocation.id,
+        content: "web_fetch failed: the model supplied an invalid or unsupported URL and nothing was fetched.",
+      };
+    }
+    if (executor.fetch === undefined) {
+      return {
+        toolCallId: invocation.id,
+        content: "web_fetch unavailable: the gateway has no fetch backend configured.",
+      };
+    }
+    try {
+      const content = await executor.fetch({ url });
+      return { toolCallId: invocation.id, content };
+    } catch (error) {
+      return {
+        toolCallId: invocation.id,
+        content: `web_fetch failed: ${error instanceof Error ? error.message : String(error)}`,
+      };
+    }
+  }
+  const query = textOf(args["query"]);
+  if (query.length === 0) {
+    return {
+      toolCallId: invocation.id,
+      content: "web_search failed: the model supplied an empty query and nothing was searched.",
+    };
+  }
+  if (executor.search === undefined) {
+    return {
+      toolCallId: invocation.id,
+      content: "web_search unavailable: the gateway has no search backend configured.",
+    };
+  }
+  try {
+    const content = await executor.search({ query });
+    return { toolCallId: invocation.id, content };
+  } catch (error) {
+    return {
+      toolCallId: invocation.id,
+      content: `web_search failed: ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+}
+
+/** Runs every invocation and returns one tool message per call. */
+export async function executeServerToolInvocations(
+  executor: ServerToolExecutor,
+  invocations: readonly ServerToolInvocation[],
+): Promise<readonly ServerToolRunResult[]> {
+  return Promise.all(invocations.map((invocation) => runOne(executor, invocation)));
+}
+
+/**
+ * Builds the transcript messages a follow-up upstream call needs: the
+ * assistant turn carrying the calls, then one `tool` result per call. Matches
+ * the OpenAI-shaped transcript the buddy upstream expects.
+ */
+export function buildServerToolFollowUpMessages(
+  assistantToolCalls: Array<{ id: string; name: string; arguments: string }>,
+  results: readonly ServerToolRunResult[],
+): Array<Record<string, unknown>> {
+  const messages: Array<Record<string, unknown>> = [];
+  if (assistantToolCalls.length > 0) {
+    messages.push({
+      role: "assistant",
+      content: "",
+      tool_calls: assistantToolCalls.map((call) => ({
+        id: call.id,
+        type: "function",
+        function: { name: call.name, arguments: call.arguments },
+      })),
+    });
+  }
+  for (const result of results) {
+    messages.push({
+      role: "tool",
+      tool_call_id: result.toolCallId,
+      content: result.content,
+    });
+  }
+  return messages;
+}

package/src/providers/integrations/buddy/codebuddy/cn-catalog.ts

@@ -0,0 +1,36 @@
+/**
+ * CodeBuddy CN model roster, isolated in a leaf module.
+ *
+ * `buddy-chat-shared` needs the raw table to answer output-limit lookups for
+ * CN-only ids, and `cn-provider` builds its catalog from it. Keeping the table
+ * here — instead of inside `cn-provider` — removes the load-time import cycle
+ * between `buddy-chat-shared` ⇄ `cn-provider` (and its buddy-media/provider
+ * variants): both sides import this module, and this module imports nothing
+ * back.
+ */
+import type { BuddyRawEntry } from "../buddy-catalog-shared";
+
+export const CODEBUDDY_CN_RAW: readonly BuddyRawEntry[] = [
+  ["glm-5.1", "GLM 5.1", true, true, 200_000, 48_000],
+  ["glm-5.2", "GLM 5.2", true, true, 1_000_000, 64_000],
+  ["glm-5.3", "GLM 5.3", true, true, 1_000_000, 64_000],
+  ["glm-5.3-flash", "GLM 5.3 Flash", true, true, 1_000_000, 131_072],
+  ["glm-5v-turbo", "GLM 5v Turbo", true, true, 200_000, 64_000],
+  ["minimax-m3", "MiniMax M3", true, true, 512_000, 64_000],
+  // 1M context, reasoning always on (upstream states both); vision inherited
+  // from the M3 row, which is the same family.
+  ["minimax-m3.1-flash", "MiniMax M3.1 Flash", true, true, 1_000_000, 128_000],
+  ["mimo-v2.6-pro", "MiMo V2.6 Pro", true, true, 1_000_000, 128_000],
+  ["kimi-k2.8-preview", "Kimi K2.8 Preview", true, true, 1_000_000, 64_000],
+  ["kimi-k3.1-pro", "Kimi K3.1 Pro", true, true, 1_000_000, 32_000],
+  ["hy3", "Hy3", true, true, 192_000, 64_000],
+  ["hy4-preview", "Hy4 Preview", true, true, 960_000, 64_000],
+  ["space-bunny", "Space Bunny", true, true, 1_000_000, 128_000],
+  ["step-5-preview", "Step 5 Preview", true, true, 1_000_000, 64_000],
+  ["deepseek-v4-pro", "DeepSeek V4 Pro", true, true, 1_000_000, 128_000],
+  ["deepseek-v4.1-flash", "DeepSeek V4.1 Flash", true, true, 1_000_000, 128_000],
+  // Live on the CN roster but absent here, so a request for it resolved to
+  // nothing. Limits as published by /v3/config.
+  ["kimi-k3-1", "Kimi K3-1", true, true, 1_000_000, 32_000],
+  ["minimax-m2.7", "MiniMax M2.7", true, true, 200_000, 48_000],
+];

package/src/providers/integrations/buddy/codebuddy/cn-provider.ts

@@ -16,19 +16,18 @@ import { providerBaseUrl } from "../../../provider-metadata";
 import {
   codebuddyAdapterConfig,
 } from "./shared";
+import { CODEBUDDY_CN_RAW } from "./cn-catalog";
 import { CODEBUDDY_SYSTEM_PROMPT } from "./provider";
 import {
   BUDDY_CN_IMAGE_MODEL_ID_SET,
   makeBuddyCnImageModels,
   makeBuddyModel,
-  type BuddyRawEntry,
 } from "../buddy-catalog-shared";
 import { BUDDY_CN_MODELS_PATH, fetchBuddyDirectoryModels } from "../buddy-discovery-shared";
 import {
   buddyPrePayloadCommon,
-  coalesceConsecutiveUserMessages,
-  dropEmptyBuddyMessages,
-  ensureBuddyLeadingSystem,
+  finalizeBuddyMessages,
+  injectBuddyParallelToolCalls,
   normalizeBuddyToolNames,
 } from "../buddy-chat-shared";
 
@@ -93,42 +92,18 @@ export function codeBuddyCnPrePayload(
   if (Array.isArray(payload["messages"])) {
     const messages = payload["messages"] as Array<Record<string, unknown>>;
     neutralizeCnMessages(messages);
-    coalesceConsecutiveUserMessages(messages);
-    dropEmptyBuddyMessages(messages);
-    ensureBuddyLeadingSystem(messages, CODEBUDDY_CN_NEUTRAL_PROMPT);
+    finalizeBuddyMessages(messages, { leadPrompt: CODEBUDDY_CN_NEUTRAL_PROMPT });
   }
   ensurePayloadModel(payload, candidate, "CodeBuddy CN");
   normalizeBuddyToolNames(payload);
+  injectBuddyParallelToolCalls(payload, request);
   void request;
 }
 
 // Model catalog — CodeBuddy CN console and CLI catalog.
 // Exported because `buddyModelOutputLimit` searches every buddy raw table, and
 // a CN-only id would otherwise never get an output limit.
-export const CODEBUDDY_CN_RAW: readonly BuddyRawEntry[] = [
-  ["glm-5.1", "GLM 5.1", true, true, 200_000, 48_000],
-  ["glm-5.2", "GLM 5.2", true, true, 1_000_000, 64_000],
-  ["glm-5.3", "GLM 5.3", true, true, 1_000_000, 64_000],
-  ["glm-5.3-flash", "GLM 5.3 Flash", true, true, 1_000_000, 131_072],
-  ["glm-5v-turbo", "GLM 5v Turbo", true, true, 200_000, 64_000],
-  ["minimax-m3", "MiniMax M3", true, true, 512_000, 64_000],
-  // 1M context, reasoning always on (upstream states both); vision inherited
-  // from the M3 row, which is the same family.
-  ["minimax-m3.1-flash", "MiniMax M3.1 Flash", true, true, 1_000_000, 128_000],
-  ["mimo-v2.6-pro", "MiMo V2.6 Pro", true, true, 1_000_000, 128_000],
-  ["kimi-k2.8-preview", "Kimi K2.8 Preview", true, true, 1_000_000, 64_000],
-  ["kimi-k3.1-pro", "Kimi K3.1 Pro", true, true, 1_000_000, 32_000],
-  ["hy3", "Hy3", true, true, 192_000, 64_000],
-  ["hy4-preview", "Hy4 Preview", true, true, 960_000, 64_000],
-  ["space-bunny", "Space Bunny", true, true, 1_000_000, 128_000],
-  ["step-5-preview", "Step 5 Preview", true, true, 1_000_000, 64_000],
-  ["deepseek-v4-pro", "DeepSeek V4 Pro", true, true, 1_000_000, 128_000],
-  ["deepseek-v4.1-flash", "DeepSeek V4.1 Flash", true, true, 1_000_000, 128_000],
-  // Live on the CN roster but absent here, so a request for it resolved to
-  // nothing. Limits as published by /v3/config.
-  ["kimi-k3-1", "Kimi K3-1", true, true, 1_000_000, 32_000],
-  ["minimax-m2.7", "MiniMax M2.7", true, true, 200_000, 48_000],
-];
+export { CODEBUDDY_CN_RAW };
 /**
  * CN's image-generation rows (`hunyuan-image-alpha`).
  *

package/src/providers/integrations/buddy/codebuddy/provider.ts

@@ -30,6 +30,7 @@ import { BUDDY_INTL_MODELS_PATH, fetchBuddyDirectoryModels } from "../buddy-disc
 import {
   applyBuddySystemPrompt,
   buddyPrePayloadCommon,
+  injectBuddyParallelToolCalls,
   normalizeBuddyToolNames,
 } from "../buddy-chat-shared";
 
@@ -86,6 +87,7 @@ function codeBuddyIntlPrePayload(
     applyBuddySystemPrompt(messages as Array<Record<string, unknown>>, CODEBUDDY_SYSTEM_PROMPT);
   }
   normalizeBuddyToolNames(payload);
+  injectBuddyParallelToolCalls(payload, request);
   void request;
 }
 

package/src/providers/integrations/buddy/codebuddy/shared.ts

@@ -3,9 +3,10 @@ import type { CanonicalRequest } from "../../../../protocol/canonical-model";
 import type { ProviderDispatchContext, ProviderDispatchTarget, ProviderId } from "../../../provider-contracts";
 import { resolveInboundSessionId } from "../../../operations/session-resolution";
 import { buddyConversationHeaders } from "../buddy-conversation-headers";
-import { buddyEnterprise, buddyUserId, resolveBuddyIdentity } from "../buddy-identity";
+import { buddyEnterprise, buddyUserId, resolveBuddyDeviceBinding, resolveBuddyIdentity } from "../buddy-identity";
 import { buildCodeBuddyUserAgent, getCodeBuddyCnVersion, getCodeBuddyVersion } from "../../../operations/client-versions";
-import { readBuddyDeviceToken } from "../workbuddy/shared";
+import { buddyDeviceTokenHeaders } from "../workbuddy/shared";
+import { CODEBUDDY_TURING_CONFIG } from "../turing-device-token";
 import { buddyCliHeaders, buddyCliTraceHeaders } from "../buddy-cli-headers";
 
 /** Client identity variant behind the per-request CodeBuddy headers. */
@@ -34,7 +35,6 @@ export async function codebuddyHeaders(
 ): Promise<Record<string, string>> {
   const identity = variant === "IDE" ? "IDE" : "CLI";
   const ua = buildCodeBuddyUserAgent(identity);
-  const deviceToken = readBuddyDeviceToken(context);
   const conversationId = resolveInboundSessionId(context, request);
   const conversation = buddyConversationHeaders({
     ...(conversationId === undefined ? {} : { conversationId }),
@@ -88,7 +88,22 @@ export async function codebuddyHeaders(
     // turn-level aggregation key, and a chat request without it is refused for a
     // missing conversation id.
     ...conversation,
-    ...(deviceToken === undefined ? {} : { "X-Device-Token": deviceToken }),
+    // Per-account device binding (qimei36) — distinct device per account.
+    ...(() => {
+      const binding = resolveBuddyDeviceBinding(context);
+      return binding === undefined ? {} : { "X-Device-Id-List": JSON.stringify({ qimei36: binding }) };
+    })(),
+    // The desktop client sends the device-token pair on both realms. SDK
+    // token when configured, captured token otherwise, or the official failure
+    // placeholder. CodeBuddy uses its own SDK payload profile (same SDK,
+    // distinct product identity). (CLI branch above already returned without
+    // device headers.)
+    ...(await buddyDeviceTokenHeaders({
+      realm: identity === "IDE" ? "intl" : "cn",
+      context,
+      cliIdentity,
+      turingConfig: CODEBUDDY_TURING_CONFIG,
+    })),
   };
 }
 

package/src/providers/integrations/buddy/turing-device-token.ts

@@ -0,0 +1,262 @@
+/**
+ * TuringShield device-token integration for the buddy providers.
+ *
+ * WorkBuddy/CodeBuddy desktop clients derive `X-Device-Token` from Tencent's
+ * TuringShield SDK (native addon + DLL, channel 400111). The upstream risk
+ * control expects that header on chat traffic, and the official desktop app
+ * always presents either a real token or an `X-Device-Token-Error` — never
+ * neither.
+ *
+ * The SDK is a proprietary native binary shipped inside this repository under
+ * `vendor/turing-sdk/` (extracted from the WorkBuddy desktop app, channel
+ * 400111). `CARTETHYIA_TURING_SDK_PATH` remains as an optional override for
+ * deployments that bring their own copy. When neither is present the service
+ * falls back to the same "sdk_not_initialized" failure state the desktop app
+ * emits when the SDK cannot run.
+ *
+ * Loading and calling the SDK is safe: `configure()` is local-only, and
+ * `fetchDeviceToken()` performs the SDK's normal network exchange with the
+ * Turing endpoint (the same call the desktop client makes). On platforms
+ * without native support (non-win32/darwin) the service degrades to the
+ * fallback.
+ */
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { log } from "../../../observability/logger";
+import { resolvePackagePath } from "../../../config/package-paths";
+
+/** Channel assigned to the WorkBuddy desktop product (see cli/product.json). */
+export const TURING_CHANNEL_ID = 400111;
+
+/** Per-provider SDK configuration (payload identity sent to Turing). */
+export interface TuringSdkConfig {
+  readonly channelId: number;
+  readonly productName: string;
+  readonly productVersion: string;
+}
+
+/** Canonical config for the WorkBuddy profile. */
+export const WORKBUDDY_TURING_CONFIG: TuringSdkConfig = {
+  channelId: TURING_CHANNEL_ID,
+  productName: "WorkBuddy AI",
+  productVersion: "5.8.4",
+};
+
+/** Canonical config for the CodeBuddy profile (same SDK, distinct payload). */
+export const CODEBUDDY_TURING_CONFIG: TuringSdkConfig = {
+  channelId: TURING_CHANNEL_ID,
+  productName: "CodeBuddy",
+  productVersion: "4.12.1",
+};
+
+/** Mirror the desktop client's service defaults (main-bootstrap.js). */
+const DEFAULT_REQUEST_TIMEOUT_MS = 15_000;
+const DEFAULT_REFRESH_INTERVAL_MS = 5 * 60_000;
+const DEFAULT_RETRY_BASE_DELAY_MS = 30_000;
+const DEFAULT_RETRY_MAX_DELAY_MS = 5 * 60_000;
+const MAX_BACKOFF_LEVEL = 20;
+
+/**
+ * Resolve the directory holding the Turing SDK native files, or null.
+ *
+ * Priority: `CARTETHYIA_TURING_SDK_PATH` override → bundled copy in
+ * `vendor/turing-sdk/build/Release/` under the package root (works both in
+ * source and in the compiled binary, where `CARTETHYIA_PACKAGE_ROOT` points at
+ * `/app`).
+ */
+export function resolveTuringSdkRoot(): string | null {
+  const env = process.env["CARTETHYIA_TURING_SDK_PATH"];
+  if (env !== undefined && env.trim().length > 0) return env.trim();
+  // Bundled SDK (committed in vendor/).
+  const bundled = resolvePackagePath("vendor", "turing-sdk", "build", "Release");
+  if (existsSync(path.join(bundled, "turing_sdk.node"))) return bundled;
+  return null;
+}
+
+/** Pure header decision, matching the desktop app's `token || error` contract. */
+export function turingHeadersForRequest(args: {
+  token?: string;
+  error?: string;
+  cliIdentity?: boolean;
+}): Record<string, string> {
+  if (args.cliIdentity) return {};
+  const token = args.token?.trim();
+  if (token !== undefined && token.length > 0) return { "x-device-token": token };
+  const error = args.error?.trim();
+  if (error !== undefined && error.length > 0) return { "x-device-token-error": error };
+  return { "x-device-token-error": "sdk_not_initialized" };
+}
+
+/** Stable identifier for logs (never the token itself). */
+function logDeviceFingerprint(): string {
+  const parts = [process.platform, process.arch, process.env["COMPUTERNAME"] ?? process.env["HOSTNAME"] ?? ""];
+  return createHash("sha256").update(parts.join("|")).digest("hex").slice(0, 12);
+}
+
+export class TuringDeviceTokenService {
+  private binding: { configure(...a: unknown[]): unknown; fetchDeviceToken(o: unknown): unknown } | null = null;
+  private loadAttempted = false;
+  private configured = false;
+
+  private cachedToken: string | undefined;
+  private cachedError: string | undefined;
+  private cachedAt = 0;
+  private consecutiveFailures = 0;
+  private nextRetryAt = 0;
+  private inflight: Promise<string> | undefined;
+
+  constructor(private readonly config: TuringSdkConfig = WORKBUDDY_TURING_CONFIG) {}
+
+  private ensureLoaded(): boolean {
+    if (this.loadAttempted) return this.configured;
+    this.loadAttempted = true;
+    const root = resolveTuringSdkRoot();
+    if (root === null) {
+      log.warn("[turing-sdk] no SDK root (env unset & vendor missing); device token fallback active");
+      return false;
+    }
+    const nodePath = path.join(root, "turing_sdk.node");
+    if (!existsSync(nodePath)) {
+      log.warn("[turing-sdk] turing_sdk.node not found at " + nodePath);
+      return false;
+    }
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const loaded: unknown = require(nodePath);
+      if (loaded === null || typeof loaded !== "object" || typeof (loaded as Record<string, unknown>)["configure"] !== "function") {
+        log.warn("[turing-sdk] native addon loaded but exposes no configure()");
+        return false;
+      }
+      const binding = loaded as NonNullable<TuringDeviceTokenService["binding"]>;
+      binding.configure(this.config.channelId, this.config.productName, this.config.productVersion);
+      this.binding = binding;
+      this.configured = true;
+      log.info(
+        "[turing-sdk] native SDK configured (channel " + this.config.channelId +
+        ", product " + this.config.productName + " " + this.config.productVersion +
+        ", " + logDeviceFingerprint() + ")",
+      );
+    } catch (error) {
+      log.warn("[turing-sdk] failed to load/configure native SDK: " + (error instanceof Error ? error.message : String(error)));
+      this.binding = null;
+    }
+    return this.configured;
+  }
+
+  /** Returns a real token when the SDK can produce one; undefined otherwise. */
+  async fetchDeviceToken(): Promise<string | undefined> {
+    if (!this.ensureLoaded()) return undefined;
+    const now = Date.now();
+    if (this.inflight) return this.inflight;
+    const task = this.performFetch().finally(() => {
+      this.inflight = undefined;
+    });
+    this.inflight = task;
+    try {
+      const token = await task;
+      this.cachedToken = token;
+      this.cachedError = undefined;
+      this.cachedAt = now;
+      this.consecutiveFailures = 0;
+      this.nextRetryAt = 0;
+      return token;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.cachedError = message.replace(/[^\x20-\x7E]/g, "").slice(0, 64);
+      this.consecutiveFailures += 1;
+      const level = Math.min(Math.max(0, this.consecutiveFailures - 1), MAX_BACKOFF_LEVEL);
+      const delay = Math.min(DEFAULT_RETRY_BASE_DELAY_MS * 2 ** level, DEFAULT_RETRY_MAX_DELAY_MS);
+      this.nextRetryAt = Date.now() + delay;
+      return undefined;
+    }
+  }
+
+  private async performFetch(): Promise<string> {
+    const binding = this.binding;
+    if (!binding) throw new Error("sdk_not_initialized");
+    const timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS;
+    const promise = binding.fetchDeviceToken({
+      usingCachedMessage: true,
+      includesOutdatedMessage: false,
+      includesDeviceInfo: true,
+      timeoutMs,
+    });
+    const token = await this.withTimeout(Promise.resolve(promise) as Promise<string>, timeoutMs);
+    const text = typeof token === "string" ? token : String(token ?? "");
+    if (text.trim().length === 0) throw new Error("Turing SDK returned an empty device token");
+    return text.trim();
+  }
+
+  private async withTimeout(promise: Promise<string>, ms: number): Promise<string> {
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    try {
+      return await Promise.race([
+        promise,
+        new Promise<string>((_, reject) => {
+          timer = setTimeout(() => reject(new Error("Turing SDK device token request timed out after " + ms + "ms")), ms);
+          timer.unref?.();
+        }),
+      ]);
+    } finally {
+      if (timer !== undefined) clearTimeout(timer);
+    }
+  }
+
+  /**
+   * Headers for one buddy request. Ensures a cached token exists (refreshing
+   * in the background when stale), then returns the desktop `token || error`
+   * contract.
+   */
+  async headersForRequest(cliIdentity?: boolean, requested?: TuringSdkConfig): Promise<Record<string, string>> {
+    // The Turing SDK rejects a channelId change after initialization. Keep the
+    // first config that actually configures the binding; later conflicting
+    // requests are warned once and keep serving the active token.
+    if (requested !== undefined) {
+      const activeOrMine = this.configured ? this.config : requested;
+      if (this.configured && (requested.channelId !== this.config.channelId || requested.productName !== this.config.productName)) {
+        log.warn("[turing-sdk] ignoring conflicting SDK config (channel " + requested.channelId + ", " + requested.productName + "); active is channel " + this.config.channelId + ", " + this.config.productName);
+      } else {
+        void activeOrMine;
+      }
+    }
+    let token: string | undefined = this.cachedToken;
+    let error: string | undefined = this.cachedError;
+    const now = Date.now();
+    if (token === undefined) {
+      if (now < this.nextRetryAt) {
+        // Keep whatever we had; still within backoff.
+      } else {
+        token = await this.fetchDeviceToken();
+        if (token === undefined) error = this.cachedError;
+      }
+    } else if (now - this.cachedAt >= DEFAULT_REFRESH_INTERVAL_MS) {
+      // Stale: refresh opportunistically but keep serving the cached token.
+      void this.fetchDeviceToken();
+    }
+    return turingHeadersForRequest({
+      ...(token === undefined ? {} : { token }),
+      ...(error === undefined ? {} : { error }),
+      ...(cliIdentity === undefined ? {} : { cliIdentity }),
+    });
+  }
+}
+
+/**
+ * Process-wide services keyed by their SDK config (channel/product). Each
+ * provider identity gets its own service so its payload (productName,
+ * productVersion) is used when the SDK is first configured. The underlying
+ * native addon is shared, but configure() runs per instance.
+ */
+const servicesByConfig = new Map<string, TuringDeviceTokenService>();
+export function getTuringDeviceTokenService(
+  config: TuringSdkConfig = WORKBUDDY_TURING_CONFIG,
+): TuringDeviceTokenService {
+  const key = `${config.channelId}:${config.productName}`;
+  let service = servicesByConfig.get(key);
+  if (service === undefined) {
+    service = new TuringDeviceTokenService(config);
+    servicesByConfig.set(key, service);
+  }
+  return service;
+}

package/src/providers/integrations/buddy/workbuddy/provider.ts

@@ -34,6 +34,7 @@ import { BUDDY_INTL_MODELS_PATH, fetchBuddyDirectoryModels } from "../buddy-disc
 import {
   applyBuddySystemPrompt,
   buddyPrePayloadCommon,
+  injectBuddyParallelToolCalls,
   normalizeBuddyToolNames,
 } from "../buddy-chat-shared";
 
@@ -141,6 +142,7 @@ export function workbuddyPrePayload(
     restoreHistoricalToolDefinitions(payload, normalizedMessages);
   }
   normalizeBuddyToolNames(payload);
+  injectBuddyParallelToolCalls(payload, request);
   void request;
 }