@cognipeer/agent-sdk 0.7.0 → 0.7.1

package/dist/index.cjs

@@ -3345,15 +3345,40 @@ function countToolCallsInLastTurn(state) {
 function stripReflectionAskMessages(messages) {
   return messages.filter((m) => !(m?.role === "user" && m?.name === REFLECTION_ASK_NAME));
 }
+function lastTwoToolTurns(state) {
+  const groups = [];
+  let cur = [];
+  let sawTool = false;
+  for (let i = state.messages.length - 1; i >= 0; i--) {
+    const m = state.messages[i];
+    if (m?.role === "tool") {
+      if (m.name) cur.push(m.name);
+      sawTool = true;
+    } else if (m?.role === "assistant") {
+      if (sawTool) {
+        groups.push(cur);
+        cur = [];
+        sawTool = false;
+        if (groups.length >= 2) break;
+      }
+    }
+  }
+  if (sawTool && cur.length) groups.push(cur);
+  return { current: groups[0] ?? [], previous: groups[1] ?? [] };
+}
 function shouldRunReflection(cadence, state, ranToolsThisTurn) {
   if (cadence === "off") return false;
   if (cadence === "every_turn") return true;
   if (cadence === "after_tool") return ranToolsThisTurn;
+  if (cadence === "initial_then_after_tool") return ranToolsThisTurn;
   if (cadence === "on_branch") {
-    const reflections = state.reflections || [];
-    const lastReflectionTurn = reflections[reflections.length - 1]?.turn ?? -1;
-    const currentTurnId = state.toolCallCount ?? 0;
-    return currentTurnId - lastReflectionTurn >= 2;
+    const { current, previous } = lastTwoToolTurns(state);
+    if (previous.length === 0) return true;
+    const a = new Set(current);
+    const b = new Set(previous);
+    for (const n of a) if (!b.has(n)) return true;
+    for (const n of b) if (!a.has(n)) return true;
+    return false;
   }
   return false;
 }
@@ -3370,7 +3395,10 @@ function createReflectionNode(opts, resolved) {
     const onEvent = state.ctx?.__onEvent;
     const traceSession = state.ctx?.__traceSession;
     const maxChars = resolved.maxChars;
-    const promptBody = (resolved.promptTemplate || DEFAULT_REFLECT_PROMPT).replace(/\$\{maxChars\}/g, String(maxChars));
+    const turnNow = state.toolCallCount ?? 0;
+    const hookCtx = { state, turn: turnNow, trigger, ranToolsThisTurn: true };
+    const defaultPrompt = (resolved.promptTemplate || DEFAULT_REFLECT_PROMPT).replace(/\$\{maxChars\}/g, String(maxChars));
+    const promptBody = resolved.buildPrompt ? String(resolved.buildPrompt({ ...hookCtx, defaultPrompt, maxChars }) ?? defaultPrompt) : defaultPrompt;
     const baseMessages = stripReflectionAskMessages([...state.messages]);
     const askMessage = {
       role: "user",
@@ -3404,6 +3432,8 @@ function createReflectionNode(opts, resolved) {
     const rawText = extractText(response);
     const text = trimToChars(String(rawText ?? "").trim(), maxChars);
     if (!text) return {};
+    const prevText = (state.reflections?.[state.reflections.length - 1]?.text || "").trim();
+    if (prevText && isNearDuplicate(prevText, text)) return {};
     const rawUsage = response?.usage_metadata || response?.response_metadata?.usage || response?.usage || response?.additional_kwargs?.usage;
     const usage = normalizeUsage(rawUsage);
     const { ids, names } = countToolCallsInLastTurn(state);
@@ -3452,6 +3482,12 @@ function createReflectionNode(opts, resolved) {
       } catch (e) {
       }
     }
+    if (resolved.onReflection) {
+      try {
+        resolved.onReflection(record, hookCtx);
+      } catch {
+      }
+    }
     const nextMessages = stripReflectionAskMessages([...state.messages]);
     const reflections = [...state.reflections || [], record];
     const kept = reflections.slice(-Math.max(1, resolved.keepLast));
@@ -3468,7 +3504,20 @@ ${r.text}
         metadata: { reflectionId: r.id, reflectionTurn: r.turn, reflectionTrigger: r.trigger }
       });
     }
-    return { messages: prunedMessages, reflections };
+    const patch = { messages: prunedMessages, reflections };
+    if (resolved.feedTo === "memory") {
+      const fact = {
+        key: `reflection_turn_${turn}`,
+        value: text,
+        sourceTurn: turn,
+        confidence: 0.3,
+        tags: ["reflection"]
+      };
+      patch.memoryFacts = [...state.memoryFacts || [], fact];
+    } else if (resolved.feedTo === "plan" && state.plan) {
+      patch.plan = { ...state.plan, lastReflection: text };
+    }
+    return patch;
   };
 }
 function extractText(chunk) {
@@ -3497,24 +3546,75 @@ function safeRandomId() {
     return `r_${Math.random().toString(36).slice(2, 10)}_${Date.now().toString(36)}`;
   }
 }
+function isNearDuplicate(a, b) {
+  const norm = (s) => s.toLowerCase().replace(/\s+/g, " ").trim();
+  const na = norm(a);
+  const nb = norm(b);
+  if (na === nb) return true;
+  const tokensA = new Set(na.split(" ").filter(Boolean));
+  const tokensB = new Set(nb.split(" ").filter(Boolean));
+  if (tokensA.size === 0 || tokensB.size === 0) return false;
+  let inter = 0;
+  for (const t of tokensA) if (tokensB.has(t)) inter++;
+  const union = tokensA.size + tokensB.size - inter;
+  return union > 0 && inter / union >= 0.9;
+}
 
 // src/smart/reasoning.ts
 var LEVEL_DEFAULTS = {
+  minimal: {
+    native: { effort: "minimal" },
+    reflection: { maxTokens: 150, maxChars: 400, cadence: "off" }
+  },
   low: {
     native: { effort: "low" },
     reflection: { maxTokens: 200, maxChars: 600, cadence: "on_branch" }
   },
   medium: {
     native: { effort: "medium" },
-    reflection: { maxTokens: 350, maxChars: 1200, cadence: "after_tool" }
+    reflection: { maxTokens: 350, maxChars: 1200, cadence: "initial_then_after_tool" }
   },
   high: {
     native: { effort: "high" },
-    reflection: { maxTokens: 600, maxChars: 2e3, cadence: "after_tool" }
+    reflection: { maxTokens: 600, maxChars: 2e3, cadence: "initial_then_after_tool" }
   }
 };
+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"];
+function validateReasoningConfig(input) {
+  if (!input) return;
+  if (input.level !== void 0 && !VALID_LEVELS.includes(input.level)) {
+    throw new Error(`reasoning.level must be one of ${VALID_LEVELS.join(", ")} (got "${input.level}")`);
+  }
+  if (input.native) {
+    const n = input.native;
+    if (n.effort !== void 0 && !VALID_EFFORTS.includes(n.effort)) {
+      throw new Error(`reasoning.native.effort must be one of ${VALID_EFFORTS.join(", ")} (got "${n.effort}")`);
+    }
+    if (n.budgetTokens !== void 0 && (!Number.isFinite(n.budgetTokens) || n.budgetTokens < 0)) {
+      throw new Error(`reasoning.native.budgetTokens must be a non-negative number (got ${n.budgetTokens})`);
+    }
+  }
+  if (input.reflection) {
+    const r = input.reflection;
+    if (r.cadence !== void 0 && !VALID_CADENCES.includes(r.cadence)) {
+      throw new Error(`reasoning.reflection.cadence must be one of ${VALID_CADENCES.join(", ")} (got "${r.cadence}")`);
+    }
+    if (r.maxPerRun !== void 0 && (!Number.isFinite(r.maxPerRun) || r.maxPerRun < 0)) {
+      throw new Error(`reasoning.reflection.maxPerRun must be a non-negative number (got ${r.maxPerRun})`);
+    }
+    if (r.everyNTurns !== void 0 && (!Number.isFinite(r.everyNTurns) || r.everyNTurns < 1)) {
+      throw new Error(`reasoning.reflection.everyNTurns must be >= 1 (got ${r.everyNTurns})`);
+    }
+    if (r.feedTo !== void 0 && !["memory", "plan", "none"].includes(r.feedTo)) {
+      throw new Error(`reasoning.reflection.feedTo must be "memory", "plan", or "none" (got "${r.feedTo}")`);
+    }
+  }
+}
 function resolveReasoning(input) {
   if (!input || input.enabled === false) return void 0;
+  validateReasoningConfig(input);
   const enabled = input.enabled ?? (input.native !== void 0 || input.reflection !== void 0 || input.level !== void 0);
   if (!enabled) return void 0;
   const level = input.level ?? "medium";
@@ -3539,7 +3639,8 @@ function resolveReflection(input, preset) {
       keepLast: 3,
       summarize: false,
       emitEvents: true,
-      everyNTurns: 1
+      everyNTurns: 1,
+      feedTo: "none"
     };
   }
   const cfg = input ?? {};
@@ -3556,7 +3657,11 @@ function resolveReflection(input, preset) {
     promptTemplate: cfg.promptTemplate,
     emitEvents: cfg.emitEvents ?? true,
     maxPerRun: typeof cfg.maxPerRun === "number" && cfg.maxPerRun >= 0 ? cfg.maxPerRun : void 0,
-    everyNTurns: Math.max(1, Math.trunc(cfg.everyNTurns ?? 1))
+    everyNTurns: Math.max(1, Math.trunc(cfg.everyNTurns ?? 1)),
+    feedTo: cfg.feedTo ?? "none",
+    shouldReflect: cfg.shouldReflect,
+    buildPrompt: cfg.buildPrompt,
+    onReflection: cfg.onReflection
   };
 }
 function ensureArray(value) {
@@ -4282,12 +4387,14 @@ function createAgent(opts) {
     if (summarizationThreshold === void 0) {
       state = clearNeedsSummarization(state);
     }
-    if (resolvedReasoning?.native) {
+    if (resolvedReasoning) {
       const ctx = { ...state.ctx || {} };
-      if (!ctx.__reasoning) {
+      if (resolvedReasoning.native) {
         ctx.__reasoning = resolvedReasoning.native;
-        state = { ...state, ctx };
+      } else {
+        delete ctx.__reasoning;
       }
+      state = { ...state, ctx: Object.keys(ctx).length > 0 ? ctx : void 0 };
     }
     const mergedLimits = {
       ...opts.limits || {},
@@ -4335,6 +4442,7 @@ function createAgent(opts) {
       return { breached: false };
     };
     let iterations = 0;
+    let reflectionsThisRun = 0;
     const onStateChange = config?.onStateChange;
     const checkpointReason = config?.checkpointReason;
     let pausedStage = null;
@@ -4380,6 +4488,16 @@ function createAgent(opts) {
       pausedStage = stage;
       return true;
     };
+    if (reflectNode && resolvedReasoning?.reflection.enabled && resolvedReasoning.reflection.cadence === "initial_then_after_tool" && resumeStage === null && !state.ctx?.__awaitingApproval && !state.ctx?.__awaitingUserQuestion && !state.messages.some((m) => m?.role === "assistant")) {
+      try {
+        const patch = await reflectNode(state, "initial_then_after_tool");
+        if (patch && Object.keys(patch).length > 0) {
+          state = { ...state, ...patch };
+          reflectionsThisRun++;
+        }
+      } catch {
+      }
+    }
     while (iterations < iterationLimit) {
       iterations++;
       const budget = checkBudgetBreached();
@@ -4556,16 +4674,18 @@ function createAgent(opts) {
       if (reflectNode && resolvedReasoning?.reflection.enabled) {
         const cadence = resolvedReasoning.reflection.cadence;
         const refl = resolvedReasoning.reflection;
-        const reflectionsSoFar = state.reflections?.length ?? 0;
         const lastTurn = state.reflections?.at(-1)?.turn ?? -Infinity;
         const currentTurn = state.toolCallCount || 0;
-        const budgetExceeded = typeof refl.maxPerRun === "number" && reflectionsSoFar >= refl.maxPerRun;
-        const cadenceGap = currentTurn - (Number.isFinite(lastTurn) ? lastTurn : -refl.everyNTurns) < refl.everyNTurns;
-        if (!budgetExceeded && !cadenceGap && shouldRunReflection(cadence, state, true)) {
+        const budgetExceeded = typeof refl.maxPerRun === "number" && reflectionsThisRun >= refl.maxPerRun;
+        const sinceLast = currentTurn - (Number.isFinite(lastTurn) ? lastTurn : -refl.everyNTurns);
+        const cadenceGap = sinceLast < refl.everyNTurns;
+        const cadenceWantsIt = refl.shouldReflect ? !!refl.shouldReflect({ state, turn: currentTurn, trigger: cadence, ranToolsThisTurn: true }) : shouldRunReflection(cadence, state, true);
+        if (!budgetExceeded && !cadenceGap && cadenceWantsIt) {
           try {
             const patch = await reflectNode(state, cadence);
             if (patch && Object.keys(patch).length > 0) {
               state = { ...state, ...patch };
+              reflectionsThisRun++;
             }
           } catch {
           }
@@ -6828,6 +6948,20 @@ function parseSSEBlock(block) {
 }
 
 // src/providers/utils/reasoning.ts
+var ANTHROPIC_EFFORT_BUDGET = {
+  minimal: 1024,
+  low: 2048,
+  medium: 8192,
+  high: 16384
+};
+var GEMINI_EFFORT_BUDGET = {
+  minimal: 512,
+  low: 1024,
+  medium: 4096,
+  high: 12e3
+};
+var THINKING_OUTPUT_RESERVE = 1024;
+var THINKING_MIN_MAX_TOKENS = 4096;
 function applyOpenAIReasoning(body, reasoning, mode = "legacy_effort") {
   if (!reasoning) return;
   const effort = normalizeEffort(reasoning.effort);
@@ -6844,21 +6978,56 @@ function applyOpenAIReasoning(body, reasoning, mode = "legacy_effort") {
 }
 function applyAnthropicReasoning(body, reasoning) {
   if (!reasoning) return;
-  const budget = resolveBudget(reasoning, { low: 2048, medium: 8192, high: 16384, minimal: 1024 });
+  let budget = resolveBudget(reasoning, ANTHROPIC_EFFORT_BUDGET);
   if (!budget) return;
+  const currentMax = typeof body.max_tokens === "number" ? body.max_tokens : 0;
+  const requiredMax = Math.max(THINKING_MIN_MAX_TOKENS, budget + THINKING_OUTPUT_RESERVE);
+  if (currentMax < requiredMax) {
+    body.max_tokens = requiredMax;
+  }
+  budget = clampBudget(budget, body.max_tokens);
   const thinking = { type: "enabled", budget_tokens: budget };
   if (reasoning.providerExtras) Object.assign(thinking, reasoning.providerExtras);
   body.thinking = thinking;
+  stripSamplingParams(body, ["temperature", "top_p", "top_k"]);
+}
+function applyBedrockReasoning(body, reasoning) {
+  if (!reasoning) return;
+  let budget = resolveBudget(reasoning, ANTHROPIC_EFFORT_BUDGET);
+  if (!budget) return;
+  const inference = body.inferenceConfig ?? (body.inferenceConfig = {});
+  const currentMax = typeof inference.maxTokens === "number" ? inference.maxTokens : 0;
+  const requiredMax = Math.max(THINKING_MIN_MAX_TOKENS, budget + THINKING_OUTPUT_RESERVE);
+  if (currentMax < requiredMax) {
+    inference.maxTokens = requiredMax;
+  }
+  budget = clampBudget(budget, inference.maxTokens);
+  const extra = body.additionalModelRequestFields ?? (body.additionalModelRequestFields = {});
+  const thinking = { type: "enabled", budget_tokens: budget };
+  if (reasoning.providerExtras) Object.assign(thinking, reasoning.providerExtras);
+  extra.thinking = thinking;
+  stripSamplingParams(inference, ["temperature", "topP"]);
 }
 function applyGeminiReasoning(generationConfig, reasoning) {
   if (!reasoning) return;
-  const budget = resolveBudget(reasoning, { low: 1024, medium: 4096, high: 12e3, minimal: 512 });
+  const budget = resolveBudget(reasoning, GEMINI_EFFORT_BUDGET);
   if (budget == null) return;
   const thinkingConfig = { thinkingBudget: budget };
   if (reasoning.includeThoughts) thinkingConfig.includeThoughts = true;
   if (reasoning.providerExtras) Object.assign(thinkingConfig, reasoning.providerExtras);
   generationConfig.thinkingConfig = thinkingConfig;
 }
+function stripSamplingParams(target, keys) {
+  for (const k of keys) {
+    if (k in target) delete target[k];
+  }
+}
+function clampBudget(budget, maxTokens) {
+  if (typeof maxTokens !== "number" || maxTokens <= 0) return budget;
+  const ceiling = maxTokens - THINKING_OUTPUT_RESERVE;
+  if (ceiling < 1024) return Math.max(1024, Math.floor(maxTokens / 2));
+  return Math.min(budget, ceiling);
+}
 function normalizeEffort(effort) {
   if (!effort) return void 0;
   const allowed = ["minimal", "low", "medium", "high"];
@@ -6887,13 +7056,38 @@ var OpenAIProvider = class extends BaseProvider {
     };
     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. */
+  useResponsesApi(request) {
+    if (!request.reasoning) return false;
+    return isReasoningModel(request.model || this.defaultModel);
+  }
   async complete(request) {
+    if (this.useResponsesApi(request)) {
+      return this.completeResponses(request);
+    }
     const body = this.buildRequestBody(request, false);
     const res = await this.doFetch(body);
     const json = await res.json();
     return this.parseResponse(json);
   }
   async *completeStream(request) {
+    if (this.useResponsesApi(request)) {
+      const response = await this.completeResponses(request);
+      yield {
+        id: response.id,
+        model: response.model,
+        delta: {
+          content: response.content ?? void 0,
+          toolCalls: response.toolCalls.length > 0 ? response.toolCalls : void 0,
+          reasoning: response.reasoning
+        },
+        usage: response.usage,
+        finishReason: response.finishReason
+      };
+      return;
+    }
     const body = this.buildRequestBody(request, true);
     const res = await this.doFetch(body);
     if (!res.body) throw new ProviderError("No response body for stream", this.providerName);
@@ -6992,6 +7186,156 @@ var OpenAIProvider = class extends BaseProvider {
     applyOpenAIReasoning(body, request.reasoning, "legacy_effort");
     return body;
   }
+  // ─── Responses API (reasoning models) ──────────────────────────────────────
+  async completeResponses(request) {
+    const body = this.buildResponsesBody(request);
+    const res = await this.responsesFetch(body);
+    const json = await res.json();
+    return this.parseResponsesResponse(json, request.model || this.defaultModel);
+  }
+  buildResponsesBody(request) {
+    const body = {
+      model: request.model || this.defaultModel,
+      input: request.messages.map((m) => this.toResponsesInput(m))
+    };
+    if (request.maxTokens != null) body.max_output_tokens = request.maxTokens;
+    if (request.topP != null) body.top_p = request.topP;
+    if (request.tools?.length) {
+      body.tools = request.tools.map((t) => ({
+        type: "function",
+        name: t.name,
+        description: t.description,
+        parameters: t.parameters,
+        ...t.strict ? { strict: true } : {}
+      }));
+    }
+    if (request.toolChoice != null && request.tools?.length) {
+      if (typeof request.toolChoice === "string") {
+        body.tool_choice = request.toolChoice;
+      } else {
+        body.tool_choice = { type: "function", name: request.toolChoice.name };
+      }
+    }
+    if (request.responseFormat) {
+      if (request.responseFormat.type === "json_schema") {
+        body.text = {
+          format: {
+            type: "json_schema",
+            name: request.responseFormat.name ?? "response",
+            schema: request.responseFormat.schema,
+            strict: true
+          }
+        };
+      } else if (request.responseFormat.type === "json_object") {
+        body.text = { format: { type: "json_object" } };
+      }
+    }
+    if (request.extra) Object.assign(body, request.extra);
+    applyOpenAIReasoning(body, request.reasoning, "responses");
+    return body;
+  }
+  /** Maps a unified message to a Responses API `input` item. */
+  toResponsesInput(m) {
+    if (m.role === "tool" && m.toolCallId) {
+      const output = typeof m.content === "string" ? m.content : JSON.stringify(m.content);
+      return { type: "function_call_output", call_id: m.toolCallId, output };
+    }
+    if (m.role === "assistant" && m.toolCalls?.length) {
+      return {
+        __assistantWithCalls: true,
+        text: typeof m.content === "string" ? m.content : "",
+        calls: m.toolCalls.map((tc) => ({
+          type: "function_call",
+          call_id: tc.id,
+          name: tc.name,
+          arguments: tc.arguments
+        }))
+      };
+    }
+    const role = m.role === "system" ? "system" : m.role === "assistant" ? "assistant" : "user";
+    const textType = role === "assistant" ? "output_text" : "input_text";
+    if (typeof m.content === "string") {
+      return { role, content: [{ type: textType, text: m.content }] };
+    }
+    const content = m.content.map((part) => {
+      if (part.type === "text") return { type: textType, text: part.text };
+      if (part.type === "image") {
+        const src = part.source;
+        const url = src.type === "url" ? src.url : `data:${src.mediaType};base64,${src.data}`;
+        return { type: "input_image", image_url: url };
+      }
+      return { type: textType, text: "" };
+    });
+    return { role, content };
+  }
+  async responsesFetch(body) {
+    body.input = expandResponsesInput(body.input);
+    const url = `${this.baseURL}/responses`;
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.apiKey}`,
+      ...this.defaultHeaders
+    };
+    const payload = JSON.stringify(body);
+    const res = await this.doFetchWithRetry(() => fetch(url, { method: "POST", headers, body: payload }));
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new ProviderError(
+        `OpenAI Responses API error ${res.status}: ${text}`,
+        this.providerName,
+        res.status,
+        text
+      );
+    }
+    return res;
+  }
+  parseResponsesResponse(json, modelId) {
+    const textParts = [];
+    const toolCalls = [];
+    const summaryParts = [];
+    for (const item of json.output ?? []) {
+      if (item.type === "message") {
+        for (const c of item.content ?? []) {
+          if (c.type === "output_text" && typeof c.text === "string") textParts.push(c.text);
+        }
+      } else if (item.type === "function_call") {
+        toolCalls.push({
+          id: item.call_id ?? item.id ?? "",
+          name: item.name ?? "",
+          arguments: typeof item.arguments === "string" ? item.arguments : JSON.stringify(item.arguments ?? {})
+        });
+      } else if (item.type === "reasoning") {
+        for (const s of item.summary ?? []) {
+          if (typeof s.text === "string") summaryParts.push(s.text);
+        }
+      }
+    }
+    if (textParts.length === 0 && typeof json.output_text === "string") {
+      textParts.push(json.output_text);
+    }
+    const usage = json.usage ?? {};
+    const reasoningTokens = usage.output_tokens_details?.reasoning_tokens ?? 0;
+    const tokenUsage = {
+      inputTokens: usage.input_tokens ?? 0,
+      outputTokens: usage.output_tokens ?? 0,
+      totalTokens: usage.total_tokens ?? (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0),
+      cachedInputTokens: usage.input_tokens_details?.cached_tokens ?? 0,
+      cachedWriteTokens: 0,
+      cachedOutputTokens: 0,
+      reasoningTokens
+    };
+    const finishReason = toolCalls.length > 0 ? "tool_calls" : json.status === "incomplete" ? "length" : "stop";
+    return {
+      id: json.id ?? "",
+      model: json.model ?? modelId,
+      content: textParts.join("") || null,
+      toolCalls,
+      usage: tokenUsage,
+      finishReason,
+      reasoning: summaryParts.length > 0 ? { summary: summaryParts.join("\n").trim() || void 0 } : void 0,
+      raw: json
+    };
+  }
   toOpenAIMessage(m) {
     const msg = { role: m.role };
     if (typeof m.content === "string") {
@@ -7084,6 +7428,25 @@ var OpenAIProvider = class extends BaseProvider {
     };
   }
 };
+function isReasoningModel(model) {
+  if (!model) return false;
+  const m = model.toLowerCase();
+  return /(^|[/_-])o[0-9]/.test(m) || m.startsWith("o1") || m.startsWith("o3") || m.startsWith("o4") || m.includes("gpt-5") || m.includes("gpt5");
+}
+function expandResponsesInput(input) {
+  const out = [];
+  for (const item of input) {
+    if (item && item.__assistantWithCalls) {
+      if (item.text) {
+        out.push({ role: "assistant", content: [{ type: "output_text", text: item.text }] });
+      }
+      for (const call of item.calls) out.push(call);
+    } else {
+      out.push(item);
+    }
+  }
+  return out;
+}
 function mapFinishReason(reason) {
   switch (reason) {
     case "stop":
@@ -7129,6 +7492,7 @@ var AnthropicProvider = class extends BaseProvider {
     let cacheReadInputTokens = 0;
     let cacheCreationInputTokens = 0;
     const currentToolCalls = /* @__PURE__ */ new Map();
+    const reasoningBlocks = /* @__PURE__ */ new Map();
     for await (const event of parseSSEStream(res.body)) {
       let data;
       try {
@@ -7158,6 +7522,10 @@ var AnthropicProvider = class extends BaseProvider {
               name: block.name ?? "",
               arguments: ""
             });
+          } else if (block?.type === "thinking") {
+            reasoningBlocks.set(idx, { type: "thinking", text: block.thinking ?? "", signature: block.signature });
+          } else if (block?.type === "redacted_thinking") {
+            reasoningBlocks.set(idx, { type: "redacted_thinking", data: block.data });
           }
           break;
         }
@@ -7170,6 +7538,19 @@ var AnthropicProvider = class extends BaseProvider {
               model,
               delta: { content: delta.text }
             };
+          } else if (delta?.type === "thinking_delta" && delta.thinking) {
+            const blk = reasoningBlocks.get(idx) ?? { type: "thinking", text: "" };
+            blk.text = (blk.text ?? "") + delta.thinking;
+            reasoningBlocks.set(idx, blk);
+            yield {
+              id,
+              model,
+              delta: { reasoning: { summary: delta.thinking } }
+            };
+          } else if (delta?.type === "signature_delta" && delta.signature) {
+            const blk = reasoningBlocks.get(idx) ?? { type: "thinking", text: "" };
+            blk.signature = (blk.signature ?? "") + delta.signature;
+            reasoningBlocks.set(idx, blk);
           } else if (delta?.type === "input_json_delta" && delta.partial_json) {
             const tc = currentToolCalls.get(idx);
             if (tc) {
@@ -7202,10 +7583,13 @@ var AnthropicProvider = class extends BaseProvider {
             cachedOutputTokens: 0,
             reasoningTokens: 0
           };
+          const blocks = [...reasoningBlocks.values()].filter(
+            (b) => b.type === "thinking" && b.signature || b.type === "redacted_thinking" && b.data
+          );
           yield {
             id,
             model,
-            delta: {},
+            delta: blocks.length > 0 ? { reasoning: { blocks } } : {},
             finishReason,
             usage
           };
@@ -7297,6 +7681,7 @@ var AnthropicProvider = class extends BaseProvider {
     }
     if (m.role === "assistant" && m.toolCalls?.length) {
       const content = [];
+      appendReasoningBlocks(content, m.reasoning?.blocks);
       if (typeof m.content === "string" && m.content) {
         content.push({ type: "text", text: m.content });
       }
@@ -7310,6 +7695,13 @@ var AnthropicProvider = class extends BaseProvider {
       }
       return { role: "assistant", content };
     }
+    if (m.role === "assistant" && m.reasoning?.blocks?.length) {
+      const content = [];
+      appendReasoningBlocks(content, m.reasoning.blocks);
+      const text = typeof m.content === "string" ? m.content : "";
+      if (text) content.push({ type: "text", text });
+      return { role: "assistant", content };
+    }
     const msg = { role: m.role };
     if (typeof m.content === "string") {
       msg.content = m.content;
@@ -7365,9 +7757,20 @@ var AnthropicProvider = class extends BaseProvider {
   parseResponse(json) {
     const textParts = [];
     const toolCalls = [];
+    const reasoningBlocks = [];
+    const summaryParts = [];
     for (const block of json.content ?? []) {
       if (block.type === "text") {
         textParts.push(block.text);
+      } else if (block.type === "thinking") {
+        reasoningBlocks.push({
+          type: "thinking",
+          text: block.thinking ?? "",
+          signature: block.signature
+        });
+        if (block.thinking) summaryParts.push(block.thinking);
+      } else if (block.type === "redacted_thinking") {
+        reasoningBlocks.push({ type: "redacted_thinking", data: block.data });
       } else if (block.type === "tool_use") {
         toolCalls.push({
           id: block.id,
@@ -7384,6 +7787,9 @@ var AnthropicProvider = class extends BaseProvider {
       cachedInputTokens: usage.cache_read_input_tokens ?? 0,
       cachedWriteTokens: usage.cache_creation_input_tokens ?? 0,
       cachedOutputTokens: 0,
+      // Anthropic bills thinking tokens inside `output_tokens` and does not
+      // expose a separate count, so reasoningTokens stays 0 here (cost is still
+      // captured via outputTokens). See docs for the limitation.
       reasoningTokens: 0
     };
     return {
@@ -7393,6 +7799,7 @@ var AnthropicProvider = class extends BaseProvider {
       toolCalls,
       usage: tokenUsage,
       finishReason: mapAnthropicStopReason(json.stop_reason),
+      reasoning: reasoningBlocks.length > 0 ? { blocks: reasoningBlocks, summary: summaryParts.join("\n").trim() || void 0 } : void 0,
       raw: json
     };
   }
@@ -7417,6 +7824,18 @@ function safeJsonParse(str) {
     return {};
   }
 }
+function appendReasoningBlocks(content, blocks) {
+  if (!blocks?.length) return;
+  for (const b of blocks) {
+    if (b.type === "redacted_thinking") {
+      if (b.data) content.push({ type: "redacted_thinking", data: b.data });
+    } else if (b.type === "thinking") {
+      if (b.signature) {
+        content.push({ type: "thinking", thinking: b.text ?? "", signature: b.signature });
+      }
+    }
+  }
+}
 
 // src/providers/azure.ts
 var AzureProvider = class extends OpenAIProvider {
@@ -7460,7 +7879,52 @@ var AzureProvider = class extends OpenAIProvider {
     }
     return res;
   }
+  /** Azure exposes the Responses API at /openai/responses with api-key auth.
+   * Reasoning summaries require a preview api-version; callers can override via
+   * the `apiVersion` config. */
+  async responsesFetch(body) {
+    body.input = expandAzureResponsesInput(body.input);
+    const deployment = this.deploymentName ?? body.model;
+    if (!deployment) {
+      throw new ProviderError("Azure requires a deploymentName or model", this.providerName);
+    }
+    const url = `${this.endpoint}/openai/responses?api-version=${this.apiVersion}`;
+    const payload = JSON.stringify({ ...body, model: deployment });
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "api-key": this.azureApiKey,
+        ...this.defaultHeaders
+      },
+      body: payload
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new ProviderError(
+        `Azure OpenAI Responses API error ${res.status}: ${text}`,
+        this.providerName,
+        res.status,
+        text
+      );
+    }
+    return res;
+  }
 };
+function expandAzureResponsesInput(input) {
+  const out = [];
+  for (const item of input) {
+    if (item && item.__assistantWithCalls) {
+      if (item.text) {
+        out.push({ role: "assistant", content: [{ type: "output_text", text: item.text }] });
+      }
+      for (const call of item.calls) out.push(call);
+    } else {
+      out.push(item);
+    }
+  }
+  return out;
+}
 
 // src/providers/openaiCompatible.ts
 var OpenAICompatibleProvider = class extends OpenAIProvider {
@@ -7633,6 +8097,7 @@ var BedrockProvider = class extends BaseProvider {
     if (request.extra) {
       Object.assign(body, request.extra);
     }
+    applyBedrockReasoning(body, request.reasoning);
     return body;
   }
   splitSystemMessages(messages) {
@@ -7666,6 +8131,7 @@ var BedrockProvider = class extends BaseProvider {
     }
     if (m.role === "assistant" && m.toolCalls?.length) {
       const content2 = [];
+      appendBedrockReasoning(content2, m.reasoning?.blocks);
       if (typeof m.content === "string" && m.content) {
         content2.push({ text: m.content });
       }
@@ -7746,9 +8212,23 @@ var BedrockProvider = class extends BaseProvider {
     const output = json.output?.message;
     const textParts = [];
     const toolCalls = [];
+    const reasoningBlocks = [];
+    const summaryParts = [];
     for (const block of output?.content ?? []) {
       if (block.text) {
         textParts.push(block.text);
+      } else if (block.reasoningContent) {
+        const rc = block.reasoningContent;
+        if (rc.reasoningText) {
+          reasoningBlocks.push({
+            type: "thinking",
+            text: rc.reasoningText.text ?? "",
+            signature: rc.reasoningText.signature
+          });
+          if (rc.reasoningText.text) summaryParts.push(rc.reasoningText.text);
+        } else if (rc.redactedContent) {
+          reasoningBlocks.push({ type: "redacted_thinking", data: rc.redactedContent });
+        }
       } else if (block.toolUse) {
         toolCalls.push({
           id: block.toolUse.toolUseId,
@@ -7765,6 +8245,7 @@ var BedrockProvider = class extends BaseProvider {
       cachedInputTokens: usage.cacheReadInputTokenCount ?? 0,
       cachedWriteTokens: usage.cacheWriteInputTokenCount ?? 0,
       cachedOutputTokens: 0,
+      // Bedrock bills thinking tokens inside outputTokens; no separate count.
       reasoningTokens: 0
     };
     return {
@@ -7774,10 +8255,25 @@ var BedrockProvider = class extends BaseProvider {
       toolCalls,
       usage: tokenUsage,
       finishReason: mapBedrockStopReason(json.stopReason),
+      reasoning: reasoningBlocks.length > 0 ? { blocks: reasoningBlocks, summary: summaryParts.join("\n").trim() || void 0 } : void 0,
       raw: json
     };
   }
 };
+function appendBedrockReasoning(content, blocks) {
+  if (!blocks?.length) return;
+  for (const b of blocks) {
+    if (b.type === "redacted_thinking") {
+      if (b.data) content.push({ reasoningContent: { redactedContent: b.data } });
+    } else if (b.type === "thinking") {
+      if (b.signature) {
+        content.push({
+          reasoningContent: { reasoningText: { text: b.text ?? "", signature: b.signature } }
+        });
+      }
+    }
+  }
+}
 function mapBedrockStopReason(reason) {
   switch (reason) {
     case "end_turn":
@@ -8100,10 +8596,15 @@ var VertexProvider = class extends BaseProvider {
     const parts = candidate?.content?.parts ?? [];
     const textParts = [];
     const toolCalls = [];
+    const thoughtParts = [];
     let toolCallIdx = 0;
     for (const part of parts) {
       if (part.text) {
-        textParts.push(part.text);
+        if (part.thought === true) {
+          thoughtParts.push(part.text);
+        } else {
+          textParts.push(part.text);
+        }
       } else if (part.functionCall) {
         toolCalls.push({
           id: `call_${toolCallIdx++}`,
@@ -8129,6 +8630,7 @@ var VertexProvider = class extends BaseProvider {
       toolCalls,
       usage: tokenUsage,
       finishReason: mapGeminiFinishReason(candidate?.finishReason),
+      reasoning: thoughtParts.length > 0 ? { summary: thoughtParts.join("\n").trim() || void 0 } : void 0,
       raw: json
     };
   }
@@ -8138,7 +8640,11 @@ var VertexProvider = class extends BaseProvider {
     const delta = {};
     for (const part of parts) {
       if (part.text) {
-        delta.content = (delta.content ?? "") + part.text;
+        if (part.thought === true) {
+          delta.reasoning = { summary: (delta.reasoning?.summary ?? "") + part.text };
+        } else {
+          delta.content = (delta.content ?? "") + part.text;
+        }
       } else if (part.functionCall) {
         if (!delta.toolCalls) delta.toolCalls = [];
         delta.toolCalls.push({
@@ -8212,12 +8718,16 @@ function fromNativeProvider(provider, options) {
       let fullContent = "";
       let allToolCalls = [];
       let lastUsage;
+      let reasoningBlocks;
       const toolCallBuffers = /* @__PURE__ */ new Map();
       for await (const chunk of provider.completeStream(request)) {
         if (chunk.delta.content) {
           fullContent += chunk.delta.content;
           yield chunk.delta.content;
         }
+        if (chunk.delta.reasoning?.blocks?.length) {
+          reasoningBlocks = chunk.delta.reasoning.blocks;
+        }
         if (chunk.delta.toolCalls) {
           for (const tc of chunk.delta.toolCalls) {
             if (tc.id) {
@@ -8238,6 +8748,9 @@ function fromNativeProvider(provider, options) {
       }
       allToolCalls = [...toolCallBuffers.values()];
       const finalMessage = assembleMessage(fullContent, allToolCalls, lastUsage);
+      if (reasoningBlocks?.length) {
+        finalMessage.reasoning = { blocks: reasoningBlocks };
+      }
       yield finalMessage;
     },
     bindTools: (tools, _bindOptions) => {
@@ -8300,6 +8813,10 @@ function toUnifiedMessage(msg) {
       arguments: tc.function?.arguments ?? tc.arguments ?? "{}"
     }));
   }
+  const reasoning = msg.reasoning;
+  if (reasoning && (reasoning.blocks?.length || reasoning.summary)) {
+    unified.reasoning = reasoning;
+  }
   return unified;
 }
 function convertContent(content) {
@@ -8508,6 +9025,9 @@ function toBaseChatMessage(response) {
       function: { name: tc.name, arguments: tc.arguments }
     }));
   }
+  if (response.reasoning && (response.reasoning.blocks?.length || response.reasoning.summary)) {
+    msg.reasoning = response.reasoning;
+  }
   return msg;
 }
 function assembleMessage(content, toolCalls, usage) {
@@ -8667,6 +9187,7 @@ exports.otlpSink = otlpSink;
 exports.readMemoryFacts = readMemoryFacts;
 exports.regexRule = regexRule;
 exports.resolveMemoryStore = resolveMemoryStore;
+exports.resolveReasoning = resolveReasoning;
 exports.resolveStrategy = resolveStrategy;
 exports.resolveToolApprovalState = resolveToolApprovalState;
 exports.resolveUserQuestionState = resolveUserQuestionState;
@@ -8675,6 +9196,7 @@ exports.runSmartAgentEvalHarness = runSmartAgentEvalHarness;
 exports.setTokenCounter = setTokenCounter;
 exports.startStreamingSession = startStreamingSession;
 exports.traceSessionToOtlp = traceSessionToOtlp;
+exports.validateReasoningConfig = validateReasoningConfig;
 exports.withTools = withTools;
 exports.writeSummaryFactsToMemory = writeSummaryFactsToMemory;
 //# sourceMappingURL=index.cjs.map