@cognipeer/agent-sdk 0.8.9 → 0.8.10

package/dist/index.cjs

@@ -4299,7 +4299,7 @@ var LEVEL_DEFAULTS = {
 };
 var VALID_LEVELS = ["minimal", "low", "medium", "high"];
 var VALID_CADENCES = ["off", "every_turn", "after_tool", "on_branch", "initial_then_after_tool"];
-var VALID_EFFORTS = ["minimal", "low", "medium", "high"];
+var VALID_EFFORTS = ["none", "minimal", "low", "medium", "high"];
 function validateReasoningConfig(input) {
   if (!input) return;
   if (input.level !== void 0 && !VALID_LEVELS.includes(input.level)) {
@@ -8793,12 +8793,19 @@ function parseSSEBlock(block) {
 
 // src/providers/utils/reasoning.ts
 var ANTHROPIC_EFFORT_BUDGET = {
+  // 0 = off. `applyAnthropicReasoning` bails on a falsy budget and emits no
+  // thinking block, which on Anthropic IS off — thinking there is opt-in.
+  none: 0,
   minimal: 1024,
   low: 2048,
   medium: 8192,
   high: 16384
 };
 var GEMINI_EFFORT_BUDGET = {
+  // 0 is Gemini's own documented spelling for "do not think", and unlike
+  // Anthropic it has to be SENT — hence `applyGeminiReasoning` testing for null
+  // rather than falsiness.
+  none: 0,
   minimal: 512,
   low: 1024,
   medium: 4096,
@@ -8874,14 +8881,15 @@ function clampBudget(budget, maxTokens) {
 }
 function normalizeEffort(effort) {
   if (!effort) return void 0;
-  const allowed = ["minimal", "low", "medium", "high"];
+  const allowed = ["none", "minimal", "low", "medium", "high"];
   return allowed.includes(effort) ? effort : void 0;
 }
 function resolveBudget(reasoning, effortBudget) {
+  const effort = normalizeEffort(reasoning.effort);
+  if (effort === "none") return 0;
   if (typeof reasoning.budgetTokens === "number" && reasoning.budgetTokens > 0) {
     return Math.floor(reasoning.budgetTokens);
   }
-  const effort = normalizeEffort(reasoning.effort);
   if (effort && effortBudget[effort]) return effortBudget[effort];
   return void 0;
 }
@@ -8970,12 +8978,21 @@ var OpenAIProvider = class extends BaseProvider {
       ...config.defaultHeaders,
       ...config.organization ? { "OpenAI-Organization": config.organization } : {}
     };
+    this.responsesApi = config.responsesApi ?? "auto";
     if (config.retry) this.retryPolicy = { ...this.retryPolicy, ...config.retry };
   }
-  /** True when the request targets a reasoning model (o-series / gpt-5) so we
-   * should route through the Responses API, which exposes `reasoning.effort`
-   * and reasoning summaries. Chat Completions silently drops these. */
+  /** True when this request should go to the Responses API rather than Chat
+   * Completions — which exposes `reasoning.effort` and reasoning summaries that
+   * Chat Completions silently drops.
+   *
+   * `auto` (the default) keeps the historical rule: only when the request
+   * carries a reasoning config AND the model name looks like an o-series/gpt-5
+   * model. `never`/`always` let a caller state the answer instead, because the
+   * name check is a guess and the two APIs differ in far more than reasoning —
+   * see `responsesApi` in OpenAIProviderConfig. */
   useResponsesApi(request) {
+    if (this.responsesApi === "never") return false;
+    if (this.responsesApi === "always") return true;
     if (!request.reasoning) return false;
     return isReasoningModel(request.model || this.defaultModel);
   }
@@ -10838,7 +10855,7 @@ function fromNativeProvider(provider, options) {
     if (tools?.length) req.tools = tools;
     if (opts?.extra) req.extra = opts.extra;
     const reasoningOverride = invokeOptions?.reasoning;
-    const reasoningCfg = reasoningOverride ?? opts?.reasoning;
+    const reasoningCfg = mergeReasoning(opts?.reasoning, reasoningOverride);
     if (reasoningCfg) req.reasoning = reasoningCfg;
     const tc = invokeOptions?.tool_choice ?? invokeOptions?.toolChoice;
     if (tc && tools?.length) {
@@ -10867,6 +10884,15 @@ function fromNativeProvider(provider, options) {
     return req;
   }
 }
+function mergeReasoning(base, override) {
+  if (!base) return override;
+  if (!override) return base;
+  const merged = { ...base, ...override };
+  if (base.providerExtras || override.providerExtras) {
+    merged.providerExtras = { ...base.providerExtras, ...override.providerExtras };
+  }
+  return merged;
+}
 function toUnifiedMessage(msg) {
   const unified = {
     role: msg.role,