@quilltap/plugin-utils 2.2.20 → 2.4.0

package/dist/providers/index.d.mts

@@ -122,6 +122,27 @@ declare class OpenAICompatibleProvider implements TextProvider {
     protected readonly maxRetries: number;
     /** Logger instance */
     protected readonly logger: PluginLogger;
+    /**
+     * Whether the endpoint tolerates more than one leading `system` message.
+     *
+     * True for every hosted service — and so the default, which keeps the
+     * outbound bytes of OpenRouter, Z.AI and every other subclass exactly as they
+     * were. A subclass that points at a local runtime applying the *model's* chat
+     * template sets this false: several template families reject a system message
+     * anywhere but index 0, and Quilltap's context builder deliberately emits up
+     * to three of them so its cache breakpoints survive. See Bug 82 and
+     * {@link collapseLeadingSystemMessages}.
+     */
+    protected readonly acceptsRepeatedSystemMessages: boolean;
+    /**
+     * Apply {@link acceptsRepeatedSystemMessages} to a mapped wire-message array.
+     * Called by both body builds so the streaming and non-streaming shapes cannot
+     * drift apart.
+     */
+    protected applySystemMessagePolicy<T extends {
+        role: string;
+        content?: string | null;
+    }>(messages: T[]): T[];
     /**
      * Creates a new OpenAI-compatible provider instance.
      *
@@ -178,6 +199,44 @@ declare class OpenAICompatibleProvider implements TextProvider {
         timeout: number;
         maxRetries: number;
     } | undefined;
+    /**
+     * Profile-parameter keys this provider forwards from
+     * `LLMParams.profileParameters` onto the request body.
+     *
+     * **Empty by default**, so a subclass that declares nothing sends exactly the
+     * bytes it sent before this mechanism existed. Subclasses opt in by
+     * overriding with their own allow-list; `model`, `messages`, `stream`,
+     * `stream_options` and `tools` must never appear in one.
+     */
+    protected readonly profileParamAllowlist: readonly string[];
+    /**
+     * Per-key hook for allow-listed profile parameters. The default forwards the
+     * stored value verbatim.
+     *
+     * Override to reshape a value (the editor stores flat strings where some APIs
+     * want objects), to gate a key on the model, or — by writing into `body` and
+     * returning `undefined` — to send it under a different key entirely.
+     */
+    protected normalizeProfileParam(_key: string, value: unknown, _params: LLMParams, _body: Record<string, unknown>): unknown | undefined;
+    /**
+     * Apply {@link profileParamAllowlist} to a request body under construction.
+     * Called by both body builds so the streaming and non-streaming shapes cannot
+     * drift apart.
+     */
+    protected applyProfileParams(body: Record<string, unknown>, params: LLMParams): void;
+    /**
+     * Normalize an OpenAI-shaped `tool_calls` array into Quilltap's `ToolCall`
+     * shape, tolerating servers that hand back already-parsed argument objects
+     * where the OpenAI wire format specifies a JSON string.
+     */
+    protected normalizeToolCalls(toolCalls: readonly unknown[] | undefined | null): {
+        id: string;
+        type: 'function';
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }[];
     /**
      * Sends a message and returns the complete response.
      *
@@ -210,6 +269,106 @@ declare class OpenAICompatibleProvider implements TextProvider {
     getAvailableModels(apiKey: string): Promise<string[]>;
 }
 
+/**
+ * Profile-parameter passthrough
+ *
+ * A connection profile's `parameters` blob is free-form JSON: the host stores
+ * whatever the profile editor (or a hand-edited profile) puts there and hands
+ * it back to the provider as `LLMParams.profileParameters` at call time. What
+ * reaches the wire is entirely the provider's business — and a provider that
+ * never reads the bag drops every setting in silence, which is exactly the
+ * defect Bug 71 records.
+ *
+ * This is the one mechanism every provider uses to forward those keys.
+ *
+ * **An exported function rather than a base-class method.** Only one plugin in
+ * the repository extends `OpenAICompatibleProvider` (DeepSeek); Z.AI and
+ * OpenRouter implement `TextProvider` directly, and Ollama speaks its own
+ * REST shape. A `protected` method would have reached one of them, so the
+ * mechanism is a free function usable by inheritance *and* composition, and
+ * the base class simply calls it.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Per-key hook applied to an allow-listed profile parameter on its way into
+ * the request body.
+ *
+ * Return the value to send, or `undefined` to omit the key entirely.
+ *
+ * The `body` is passed so a normalizer can place a value somewhere other than
+ * its own top-level key — the OpenAI-compatible plugin folds `reasoning_effort`
+ * into `chat_template_kwargs` this way, then returns `undefined` so no flat
+ * `reasoning_effort` key is sent. Normalizers that only reshape a value can
+ * ignore the argument.
+ */
+type ProfileParamNormalizer = (key: string, value: unknown, params: LLMParams, body: Record<string, unknown>) => unknown | undefined;
+/**
+ * Copy allow-listed keys from `params.profileParameters` onto a request body.
+ *
+ * Rules, all of which predate this helper (they were hand-rolled identically in
+ * the DeepSeek and Z.AI providers before it existed):
+ *
+ * - **Allow-list, never spread.** `model`, `messages`, `stream`,
+ *   `stream_options` and `tools` must be unreachable from a profile — a
+ *   misconfigured bag cannot be allowed to retarget the request.
+ * - **`undefined` and `null` skip.** So does the empty string, which is what
+ *   the schema-driven profile editor stores for "omit this and use the model
+ *   default".
+ * - **The allow-list is ordered.** Keys are applied in the order given, so a
+ *   normalizer that merges into an earlier key (`chat_template_kwargs`) sees
+ *   whatever the profile set for it.
+ *
+ * @param body - Request body under construction; mutated in place
+ * @param params - The call's LLM parameters, carrying `profileParameters`
+ * @param allowlist - Keys this provider is willing to forward
+ * @param normalize - Optional per-key hook (see {@link ProfileParamNormalizer})
+ */
+declare function applyProfileParameters(body: Record<string, unknown>, params: LLMParams, allowlist: readonly string[], normalize?: ProfileParamNormalizer): void;
+
+/**
+ * Leading-system-message collapse.
+ *
+ * Quilltap's context builder deliberately emits the head of a turn as up to
+ * three consecutive `system` messages — the cacheable persona prefix, the
+ * static identity reinforcement, and the compressed-history summary — so that a
+ * cache breakpoint on the first is not invalidated by churn in the others.
+ * Hosted providers accept that happily.
+ *
+ * A local runtime does not answer for itself: it applies the *model's own* chat
+ * template, and several families (Qwen most notably, plus Llama- and
+ * Gemma-derived templates) `raise_exception` on any system message after index
+ * 0. The whole request is then rejected before a token is generated, so the
+ * opening greeting — one system message — works and every turn after it dies.
+ *
+ * The repair belongs here, at request-build time, rather than in the context
+ * assembly: the blocks stay separate for every provider that wants them
+ * separate, and the providers that cannot take them fold the run on the way
+ * out. See Bug 82.
+ *
+ * @packageDocumentation
+ */
+/** The shape this helper needs; wire messages carry more, and keep it. */
+interface RoleAndContent {
+    role: string;
+    content?: string | null;
+}
+/**
+ * Fold a run of consecutive leading `system` messages into a single one,
+ * joining their contents with a blank line.
+ *
+ * Only the *leading* run is touched — a system message that appears later is
+ * left where it is, because moving or merging it would change what the model is
+ * told and when. Arrays with fewer than two leading system messages are
+ * returned unchanged (the same array reference), so a provider that opts in
+ * still sends byte-identical requests everywhere the problem does not arise.
+ *
+ * @param messages - Wire-format messages, already mapped for the endpoint
+ * @returns The messages with their leading system run collapsed
+ */
+declare function collapseLeadingSystemMessages<T extends RoleAndContent>(messages: T[]): T[];
+
 /**
  * Per-request wall-clock budgets.
  *
@@ -291,4 +450,4 @@ declare function buildSdkClientOptions(params: Pick<LLMParams, 'requestTimeoutMs
  */
 declare function buildRequestAbortSignal(params: Pick<LLMParams, 'requestTimeoutMs'>, defaultMs?: number): AbortSignal;
 
-export { DEFAULT_REQUEST_TIMEOUT_MS, OpenAICompatibleProvider, type OpenAICompatibleProviderConfig, buildRequestAbortSignal, buildSdkClientOptions, buildSdkRequestOptions, resolveRequestTimeoutMs };
+export { DEFAULT_REQUEST_TIMEOUT_MS, OpenAICompatibleProvider, type OpenAICompatibleProviderConfig, type ProfileParamNormalizer, applyProfileParameters, buildRequestAbortSignal, buildSdkClientOptions, buildSdkRequestOptions, collapseLeadingSystemMessages, resolveRequestTimeoutMs };

package/dist/providers/index.d.ts

@@ -122,6 +122,27 @@ declare class OpenAICompatibleProvider implements TextProvider {
     protected readonly maxRetries: number;
     /** Logger instance */
     protected readonly logger: PluginLogger;
+    /**
+     * Whether the endpoint tolerates more than one leading `system` message.
+     *
+     * True for every hosted service — and so the default, which keeps the
+     * outbound bytes of OpenRouter, Z.AI and every other subclass exactly as they
+     * were. A subclass that points at a local runtime applying the *model's* chat
+     * template sets this false: several template families reject a system message
+     * anywhere but index 0, and Quilltap's context builder deliberately emits up
+     * to three of them so its cache breakpoints survive. See Bug 82 and
+     * {@link collapseLeadingSystemMessages}.
+     */
+    protected readonly acceptsRepeatedSystemMessages: boolean;
+    /**
+     * Apply {@link acceptsRepeatedSystemMessages} to a mapped wire-message array.
+     * Called by both body builds so the streaming and non-streaming shapes cannot
+     * drift apart.
+     */
+    protected applySystemMessagePolicy<T extends {
+        role: string;
+        content?: string | null;
+    }>(messages: T[]): T[];
     /**
      * Creates a new OpenAI-compatible provider instance.
      *
@@ -178,6 +199,44 @@ declare class OpenAICompatibleProvider implements TextProvider {
         timeout: number;
         maxRetries: number;
     } | undefined;
+    /**
+     * Profile-parameter keys this provider forwards from
+     * `LLMParams.profileParameters` onto the request body.
+     *
+     * **Empty by default**, so a subclass that declares nothing sends exactly the
+     * bytes it sent before this mechanism existed. Subclasses opt in by
+     * overriding with their own allow-list; `model`, `messages`, `stream`,
+     * `stream_options` and `tools` must never appear in one.
+     */
+    protected readonly profileParamAllowlist: readonly string[];
+    /**
+     * Per-key hook for allow-listed profile parameters. The default forwards the
+     * stored value verbatim.
+     *
+     * Override to reshape a value (the editor stores flat strings where some APIs
+     * want objects), to gate a key on the model, or — by writing into `body` and
+     * returning `undefined` — to send it under a different key entirely.
+     */
+    protected normalizeProfileParam(_key: string, value: unknown, _params: LLMParams, _body: Record<string, unknown>): unknown | undefined;
+    /**
+     * Apply {@link profileParamAllowlist} to a request body under construction.
+     * Called by both body builds so the streaming and non-streaming shapes cannot
+     * drift apart.
+     */
+    protected applyProfileParams(body: Record<string, unknown>, params: LLMParams): void;
+    /**
+     * Normalize an OpenAI-shaped `tool_calls` array into Quilltap's `ToolCall`
+     * shape, tolerating servers that hand back already-parsed argument objects
+     * where the OpenAI wire format specifies a JSON string.
+     */
+    protected normalizeToolCalls(toolCalls: readonly unknown[] | undefined | null): {
+        id: string;
+        type: 'function';
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }[];
     /**
      * Sends a message and returns the complete response.
      *
@@ -210,6 +269,106 @@ declare class OpenAICompatibleProvider implements TextProvider {
     getAvailableModels(apiKey: string): Promise<string[]>;
 }
 
+/**
+ * Profile-parameter passthrough
+ *
+ * A connection profile's `parameters` blob is free-form JSON: the host stores
+ * whatever the profile editor (or a hand-edited profile) puts there and hands
+ * it back to the provider as `LLMParams.profileParameters` at call time. What
+ * reaches the wire is entirely the provider's business — and a provider that
+ * never reads the bag drops every setting in silence, which is exactly the
+ * defect Bug 71 records.
+ *
+ * This is the one mechanism every provider uses to forward those keys.
+ *
+ * **An exported function rather than a base-class method.** Only one plugin in
+ * the repository extends `OpenAICompatibleProvider` (DeepSeek); Z.AI and
+ * OpenRouter implement `TextProvider` directly, and Ollama speaks its own
+ * REST shape. A `protected` method would have reached one of them, so the
+ * mechanism is a free function usable by inheritance *and* composition, and
+ * the base class simply calls it.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Per-key hook applied to an allow-listed profile parameter on its way into
+ * the request body.
+ *
+ * Return the value to send, or `undefined` to omit the key entirely.
+ *
+ * The `body` is passed so a normalizer can place a value somewhere other than
+ * its own top-level key — the OpenAI-compatible plugin folds `reasoning_effort`
+ * into `chat_template_kwargs` this way, then returns `undefined` so no flat
+ * `reasoning_effort` key is sent. Normalizers that only reshape a value can
+ * ignore the argument.
+ */
+type ProfileParamNormalizer = (key: string, value: unknown, params: LLMParams, body: Record<string, unknown>) => unknown | undefined;
+/**
+ * Copy allow-listed keys from `params.profileParameters` onto a request body.
+ *
+ * Rules, all of which predate this helper (they were hand-rolled identically in
+ * the DeepSeek and Z.AI providers before it existed):
+ *
+ * - **Allow-list, never spread.** `model`, `messages`, `stream`,
+ *   `stream_options` and `tools` must be unreachable from a profile — a
+ *   misconfigured bag cannot be allowed to retarget the request.
+ * - **`undefined` and `null` skip.** So does the empty string, which is what
+ *   the schema-driven profile editor stores for "omit this and use the model
+ *   default".
+ * - **The allow-list is ordered.** Keys are applied in the order given, so a
+ *   normalizer that merges into an earlier key (`chat_template_kwargs`) sees
+ *   whatever the profile set for it.
+ *
+ * @param body - Request body under construction; mutated in place
+ * @param params - The call's LLM parameters, carrying `profileParameters`
+ * @param allowlist - Keys this provider is willing to forward
+ * @param normalize - Optional per-key hook (see {@link ProfileParamNormalizer})
+ */
+declare function applyProfileParameters(body: Record<string, unknown>, params: LLMParams, allowlist: readonly string[], normalize?: ProfileParamNormalizer): void;
+
+/**
+ * Leading-system-message collapse.
+ *
+ * Quilltap's context builder deliberately emits the head of a turn as up to
+ * three consecutive `system` messages — the cacheable persona prefix, the
+ * static identity reinforcement, and the compressed-history summary — so that a
+ * cache breakpoint on the first is not invalidated by churn in the others.
+ * Hosted providers accept that happily.
+ *
+ * A local runtime does not answer for itself: it applies the *model's own* chat
+ * template, and several families (Qwen most notably, plus Llama- and
+ * Gemma-derived templates) `raise_exception` on any system message after index
+ * 0. The whole request is then rejected before a token is generated, so the
+ * opening greeting — one system message — works and every turn after it dies.
+ *
+ * The repair belongs here, at request-build time, rather than in the context
+ * assembly: the blocks stay separate for every provider that wants them
+ * separate, and the providers that cannot take them fold the run on the way
+ * out. See Bug 82.
+ *
+ * @packageDocumentation
+ */
+/** The shape this helper needs; wire messages carry more, and keep it. */
+interface RoleAndContent {
+    role: string;
+    content?: string | null;
+}
+/**
+ * Fold a run of consecutive leading `system` messages into a single one,
+ * joining their contents with a blank line.
+ *
+ * Only the *leading* run is touched — a system message that appears later is
+ * left where it is, because moving or merging it would change what the model is
+ * told and when. Arrays with fewer than two leading system messages are
+ * returned unchanged (the same array reference), so a provider that opts in
+ * still sends byte-identical requests everywhere the problem does not arise.
+ *
+ * @param messages - Wire-format messages, already mapped for the endpoint
+ * @returns The messages with their leading system run collapsed
+ */
+declare function collapseLeadingSystemMessages<T extends RoleAndContent>(messages: T[]): T[];
+
 /**
  * Per-request wall-clock budgets.
  *
@@ -291,4 +450,4 @@ declare function buildSdkClientOptions(params: Pick<LLMParams, 'requestTimeoutMs
  */
 declare function buildRequestAbortSignal(params: Pick<LLMParams, 'requestTimeoutMs'>, defaultMs?: number): AbortSignal;
 
-export { DEFAULT_REQUEST_TIMEOUT_MS, OpenAICompatibleProvider, type OpenAICompatibleProviderConfig, buildRequestAbortSignal, buildSdkClientOptions, buildSdkRequestOptions, resolveRequestTimeoutMs };
+export { DEFAULT_REQUEST_TIMEOUT_MS, OpenAICompatibleProvider, type OpenAICompatibleProviderConfig, type ProfileParamNormalizer, applyProfileParameters, buildRequestAbortSignal, buildSdkClientOptions, buildSdkRequestOptions, collapseLeadingSystemMessages, resolveRequestTimeoutMs };

package/dist/providers/index.js

@@ -32,9 +32,11 @@ var providers_exports = {};
 __export(providers_exports, {
   DEFAULT_REQUEST_TIMEOUT_MS: () => DEFAULT_REQUEST_TIMEOUT_MS,
   OpenAICompatibleProvider: () => OpenAICompatibleProvider,
+  applyProfileParameters: () => applyProfileParameters,
   buildRequestAbortSignal: () => buildRequestAbortSignal,
   buildSdkClientOptions: () => buildSdkClientOptions,
   buildSdkRequestOptions: () => buildSdkRequestOptions,
+  collapseLeadingSystemMessages: () => collapseLeadingSystemMessages,
   resolveRequestTimeoutMs: () => resolveRequestTimeoutMs
 });
 module.exports = __toCommonJS(providers_exports);
@@ -131,6 +133,36 @@ function buildRequestAbortSignal(params, defaultMs = DEFAULT_REQUEST_TIMEOUT_MS)
   return AbortSignal.timeout(resolveRequestTimeoutMs(params, defaultMs));
 }
 
+// src/providers/profile-parameters.ts
+function applyProfileParameters(body, params, allowlist, normalize) {
+  const profile = params.profileParameters;
+  if (!profile || typeof profile !== "object") return;
+  const bag = profile;
+  for (const key of allowlist) {
+    const raw = bag[key];
+    if (raw === void 0 || raw === null) continue;
+    if (typeof raw === "string" && raw === "") continue;
+    const value = normalize ? normalize(key, raw, params, body) : raw;
+    if (value === void 0) continue;
+    body[key] = value;
+  }
+}
+
+// src/providers/system-messages.ts
+function collapseLeadingSystemMessages(messages) {
+  let runLength = 0;
+  while (runLength < messages.length && messages[runLength].role === "system") {
+    runLength++;
+  }
+  if (runLength < 2) return messages;
+  const run = messages.slice(0, runLength);
+  const merged = {
+    ...run[0],
+    content: run.map((m) => m.content ?? "").filter((c) => c.length > 0).join("\n\n")
+  };
+  return [merged, ...messages.slice(runLength)];
+}
+
 // src/providers/openai-compatible.ts
 var DEFAULT_MAX_RETRIES = 2;
 var OpenAICompatibleProvider = class {
@@ -146,6 +178,28 @@ var OpenAICompatibleProvider = class {
     this.supportedMimeTypes = [];
     /** Web search is not supported */
     this.supportsWebSearch = false;
+    /**
+     * Whether the endpoint tolerates more than one leading `system` message.
+     *
+     * True for every hosted service — and so the default, which keeps the
+     * outbound bytes of OpenRouter, Z.AI and every other subclass exactly as they
+     * were. A subclass that points at a local runtime applying the *model's* chat
+     * template sets this false: several template families reject a system message
+     * anywhere but index 0, and Quilltap's context builder deliberately emits up
+     * to three of them so its cache breakpoints survive. See Bug 82 and
+     * {@link collapseLeadingSystemMessages}.
+     */
+    this.acceptsRepeatedSystemMessages = true;
+    /**
+     * Profile-parameter keys this provider forwards from
+     * `LLMParams.profileParameters` onto the request body.
+     *
+     * **Empty by default**, so a subclass that declares nothing sends exactly the
+     * bytes it sent before this mechanism existed. Subclasses opt in by
+     * overriding with their own allow-list; `model`, `messages`, `stream`,
+     * `stream_options` and `tools` must never appear in one.
+     */
+    this.profileParamAllowlist = [];
     if (typeof config === "string") {
       this.baseUrl = config;
       this.providerName = "OpenAICompatible";
@@ -163,6 +217,14 @@ var OpenAICompatibleProvider = class {
     }
     this.logger = createPluginLogger(`${this.providerName}Provider`);
   }
+  /**
+   * Apply {@link acceptsRepeatedSystemMessages} to a mapped wire-message array.
+   * Called by both body builds so the streaming and non-streaming shapes cannot
+   * drift apart.
+   */
+  applySystemMessagePolicy(messages) {
+    return this.acceptsRepeatedSystemMessages ? messages : collapseLeadingSystemMessages(messages);
+  }
   /**
    * Collects attachment failures for messages with attachments.
    * Since attachments are not supported, all attachments are marked as failed.
@@ -233,6 +295,53 @@ var OpenAICompatibleProvider = class {
   buildRequestOptions(params) {
     return buildSdkRequestOptions(params);
   }
+  /**
+   * Per-key hook for allow-listed profile parameters. The default forwards the
+   * stored value verbatim.
+   *
+   * Override to reshape a value (the editor stores flat strings where some APIs
+   * want objects), to gate a key on the model, or — by writing into `body` and
+   * returning `undefined` — to send it under a different key entirely.
+   */
+  normalizeProfileParam(_key, value, _params, _body) {
+    return value;
+  }
+  /**
+   * Apply {@link profileParamAllowlist} to a request body under construction.
+   * Called by both body builds so the streaming and non-streaming shapes cannot
+   * drift apart.
+   */
+  applyProfileParams(body, params) {
+    applyProfileParameters(
+      body,
+      params,
+      this.profileParamAllowlist,
+      (key, value, callParams, target) => this.normalizeProfileParam(key, value, callParams, target)
+    );
+  }
+  /**
+   * Normalize an OpenAI-shaped `tool_calls` array into Quilltap's `ToolCall`
+   * shape, tolerating servers that hand back already-parsed argument objects
+   * where the OpenAI wire format specifies a JSON string.
+   */
+  normalizeToolCalls(toolCalls) {
+    if (!toolCalls || toolCalls.length === 0) return [];
+    const out = [];
+    for (const raw of toolCalls) {
+      const tc = raw;
+      if (!tc?.function?.name) continue;
+      const args = tc.function.arguments;
+      out.push({
+        id: tc.id ?? "",
+        type: "function",
+        function: {
+          name: tc.function.name,
+          arguments: typeof args === "string" ? args : JSON.stringify(args ?? {})
+        }
+      });
+    }
+    return out;
+  }
   /**
    * Sends a message and returns the complete response.
    *
@@ -244,7 +353,7 @@ var OpenAICompatibleProvider = class {
     this.validateApiKeyRequirement(apiKey);
     const attachmentResults = this.collectAttachmentFailures(params);
     const client = this.createClient(apiKey);
-    const messages = params.messages.filter((m) => {
+    const mappedMessages = params.messages.filter((m) => {
       if (m.role === "tool" && !m.toolCallId) return false;
       return true;
     }).map((m) => {
@@ -271,17 +380,27 @@ var OpenAICompatibleProvider = class {
         content: m.content
       };
     });
+    const messages = this.applySystemMessagePolicy(mappedMessages);
+    const body = {
+      model: params.model,
+      messages,
+      temperature: params.temperature ?? 0.7,
+      max_tokens: params.maxTokens ?? 4096,
+      top_p: params.topP ?? 1,
+      stop: params.stop,
+      ...params.cacheKey ? { user: params.cacheKey } : {},
+      // Tools arrive only once the runtime gate (the profile's "Allow tool
+      // use") has passed, so no separate guard is needed here.
+      ...params.tools && params.tools.length > 0 ? { tools: params.tools, tool_choice: params.toolChoice ?? "auto" } : {}
+    };
+    this.applyProfileParams(body, params);
     try {
-      const response = await client.chat.completions.create({
-        model: params.model,
-        messages,
-        temperature: params.temperature ?? 0.7,
-        max_tokens: params.maxTokens ?? 4096,
-        top_p: params.topP ?? 1,
-        stop: params.stop,
-        ...params.cacheKey ? { user: params.cacheKey } : {}
-      }, this.buildRequestOptions(params));
+      const response = await client.chat.completions.create(
+        body,
+        this.buildRequestOptions(params)
+      );
       const choice = response.choices[0];
+      const toolCalls = this.normalizeToolCalls(choice.message.tool_calls);
       return {
         content: choice.message.content ?? "",
         finishReason: choice.finish_reason,
@@ -291,7 +410,8 @@ var OpenAICompatibleProvider = class {
           totalTokens: response.usage?.total_tokens ?? 0
         },
         raw: response,
-        attachmentResults
+        attachmentResults,
+        ...toolCalls.length > 0 ? { toolCalls } : {}
       };
     } catch (error) {
       this.logger.error(
@@ -313,7 +433,7 @@ var OpenAICompatibleProvider = class {
     this.validateApiKeyRequirement(apiKey);
     const attachmentResults = this.collectAttachmentFailures(params);
     const client = this.createClient(apiKey);
-    const messages = params.messages.filter((m) => {
+    const mappedMessages = params.messages.filter((m) => {
       if (m.role === "tool" && !m.toolCallId) return false;
       return true;
     }).map((m) => {
@@ -340,23 +460,33 @@ var OpenAICompatibleProvider = class {
         content: m.content
       };
     });
+    const messages = this.applySystemMessagePolicy(mappedMessages);
+    const body = {
+      model: params.model,
+      messages,
+      temperature: params.temperature ?? 0.7,
+      max_tokens: params.maxTokens ?? 4096,
+      top_p: params.topP ?? 1,
+      stop: params.stop,
+      stream: true,
+      stream_options: { include_usage: true },
+      ...params.cacheKey ? { user: params.cacheKey } : {},
+      ...params.tools && params.tools.length > 0 ? { tools: params.tools, tool_choice: params.toolChoice ?? "auto" } : {}
+    };
+    this.applyProfileParams(body, params);
     try {
-      const stream = await client.chat.completions.create({
-        model: params.model,
-        messages,
-        temperature: params.temperature ?? 0.7,
-        max_tokens: params.maxTokens ?? 4096,
-        top_p: params.topP ?? 1,
-        stop: params.stop,
-        stream: true,
-        stream_options: { include_usage: true },
-        ...params.cacheKey ? { user: params.cacheKey } : {}
-      }, this.buildRequestOptions(params));
+      const stream = await client.chat.completions.create(
+        body,
+        this.buildRequestOptions(params)
+      );
       let chunkCount = 0;
       let accumulatedUsage = null;
+      const toolCallAccumulator = /* @__PURE__ */ new Map();
+      let finishReason = null;
       for await (const chunk of stream) {
         chunkCount++;
-        const content = chunk.choices[0]?.delta?.content;
+        const choice = chunk.choices[0];
+        const content = choice?.delta?.content;
         const hasUsage = chunk.usage;
         if (hasUsage) {
           accumulatedUsage = {
@@ -365,6 +495,17 @@ var OpenAICompatibleProvider = class {
             total_tokens: chunk.usage?.total_tokens
           };
         }
+        if (choice?.delta?.tool_calls) {
+          for (const tcDelta of choice.delta.tool_calls) {
+            const idx = tcDelta.index ?? 0;
+            const existing = toolCallAccumulator.get(idx) ?? { id: "", name: "", arguments: "" };
+            if (tcDelta.id) existing.id = tcDelta.id;
+            if (tcDelta.function?.name) existing.name = tcDelta.function.name;
+            if (tcDelta.function?.arguments) existing.arguments += tcDelta.function.arguments;
+            toolCallAccumulator.set(idx, existing);
+          }
+        }
+        if (choice?.finish_reason) finishReason = choice.finish_reason;
         if (content) {
           yield {
             content,
@@ -372,6 +513,11 @@ var OpenAICompatibleProvider = class {
           };
         }
       }
+      const toolCalls = Array.from(toolCallAccumulator.values()).filter((tc) => tc.name).map((tc) => ({
+        id: tc.id,
+        type: "function",
+        function: { name: tc.name, arguments: tc.arguments }
+      }));
       yield {
         content: "",
         done: true,
@@ -380,7 +526,22 @@ var OpenAICompatibleProvider = class {
           completionTokens: accumulatedUsage.completion_tokens ?? 0,
           totalTokens: accumulatedUsage.total_tokens ?? 0
         } : void 0,
-        attachmentResults
+        attachmentResults,
+        // Only synthesized when the stream actually carried tool calls: the
+        // host's tool detection reads `rawResponse`, and an empty one on every
+        // ordinary turn would be noise in the logs for no gain.
+        ...toolCalls.length > 0 ? {
+          toolCalls,
+          rawResponse: {
+            choices: [
+              {
+                index: 0,
+                message: { role: "assistant", content: "", tool_calls: toolCalls },
+                finish_reason: finishReason
+              }
+            ]
+          }
+        } : {}
       };
     } catch (error) {
       this.logger.error(
@@ -446,9 +607,11 @@ var OpenAICompatibleProvider = class {
 0 && (module.exports = {
   DEFAULT_REQUEST_TIMEOUT_MS,
   OpenAICompatibleProvider,
+  applyProfileParameters,
   buildRequestAbortSignal,
   buildSdkClientOptions,
   buildSdkRequestOptions,
+  collapseLeadingSystemMessages,
   resolveRequestTimeoutMs
 });
 //# sourceMappingURL=index.js.map