@cognipeer/agent-sdk 0.7.0 → 0.7.2

package/dist/index.cjs

@@ -3036,6 +3036,17 @@ function createToolsNode(initialTools, opts) {
         }
         const durationMs = Date.now() - start;
         const executionId = nanoid.nanoid();
+        if (output && typeof output === "object" && Array.isArray(output.__runtimeToolsDelta)) {
+          const delta = output.__runtimeToolsDelta;
+          delete output.__runtimeToolsDelta;
+          const currentRuntime = state.agent || runtime;
+          const currentTools = currentRuntime?.tools ?? [];
+          const present = new Set(currentTools.map((tool2) => tool2?.name));
+          const additions = delta.filter((tool2) => tool2 && tool2.name && !present.has(tool2.name));
+          if (additions.length > 0 && currentRuntime) {
+            state.agent = { ...currentRuntime, tools: [...currentTools, ...additions] };
+          }
+        }
         if (output && typeof output === "object" && output.__handoff && output.__handoff.runtime) {
           toolHistory.push({ executionId, toolName, args, output: "handoff:ok", rawOutput: output, timestamp: (/* @__PURE__ */ new Date()).toISOString(), tool_call_id: tc.id, status: "handoff" });
           push({ role: "tool", content: "ok", tool_call_id: tc.id || `${tc.name}_${toolCount}`, name: tc.name });
@@ -3345,15 +3356,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 +3406,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 +3443,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 +3493,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 +3515,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 +3557,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 +3650,8 @@ function resolveReflection(input, preset) {
       keepLast: 3,
       summarize: false,
       emitEvents: true,
-      everyNTurns: 1
+      everyNTurns: 1,
+      feedTo: "none"
     };
   }
   const cfg = input ?? {};
@@ -3556,7 +3668,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 +4398,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 +4453,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 +4499,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 +4685,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 {
           }
@@ -6073,6 +6204,190 @@ async function writeSummaryFactsToMemory(store, config, summary, sourceTurn) {
   return store.get(config.memory.scope, { limit: config.context.lastTurnsToKeep + summary.stable_facts.length });
 }
 
+// src/smart/skills/types.ts
+var DEFAULT_SKILL_POLICY = {
+  maxOpenSkills: 4,
+  maxBoundToolsPerSkill: 12,
+  maxBoundToolsTotal: 40
+};
+var SMALL_TIER_SKILL_POLICY = {
+  maxOpenSkills: 1,
+  maxBoundToolsPerSkill: 6,
+  maxBoundToolsTotal: 18,
+  modelTier: "small"
+};
+function createSkillRegistryRef() {
+  return { openedSkillKeys: [], boundSkillTools: [] };
+}
+
+// src/smart/skills/registry.ts
+function composeToolSets(input) {
+  const without = [...input.base, ...input.boundSkillTools];
+  const withRec = input.recoveryTool ? [...without, input.recoveryTool] : [...without];
+  return { toolsWithoutRecovery: without, toolsWithRecovery: withRec };
+}
+function appendBoundTools(ref, newTools, policy) {
+  const present = new Set(ref.boundSkillTools.map((tool) => tool.name));
+  const added = [];
+  for (const tool of newTools) {
+    if (ref.boundSkillTools.length >= policy.maxBoundToolsTotal) break;
+    if (present.has(tool.name)) continue;
+    present.add(tool.name);
+    ref.boundSkillTools.push(tool);
+    added.push(tool);
+  }
+  return added;
+}
+function canOpenSkill(ref, policy) {
+  if (ref.openedSkillKeys.length >= policy.maxOpenSkills) {
+    return { ok: false, reason: `max ${policy.maxOpenSkills} skill(s) already open` };
+  }
+  if (ref.boundSkillTools.length >= policy.maxBoundToolsTotal) {
+    return { ok: false, reason: "skill tool budget exhausted" };
+  }
+  return { ok: true };
+}
+async function resolveAvailableSkills(skills, opts = {}) {
+  const out = [];
+  for (const skill of skills) {
+    if (skill.minModelTier === "large" && opts.modelTier === "small") continue;
+    const available = skill.isAvailable ? await skill.isAvailable() : true;
+    if (available) out.push(skill);
+  }
+  return out;
+}
+function buildSkillHeaderBlock(skills) {
+  if (skills.length === 0) return "";
+  const lines = skills.map((skill) => `- ${skill.key}: ${skill.header}`);
+  return [
+    "<available_skills>",
+    "Open a skill with open_skill(skillKey) to load its tools on demand. Only open what the task needs; close nothing \u2014 opened skills stay available for the rest of the run.",
+    ...lines,
+    "</available_skills>"
+  ].join("\n");
+}
+function dedupeToolsByName(tools) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const tool of tools) {
+    if (seen.has(tool.name)) continue;
+    seen.add(tool.name);
+    out.push(tool);
+  }
+  return out;
+}
+
+// src/smart/skills/skillTools.ts
+var MAX_RETURNED_INDEX = 40;
+var OPEN_SKILL_DESCRIPTION = "Load a capability on demand. Pass a skillKey from <available_skills>. A small skill binds all its tools immediately; a large one returns a tool index \u2014 then call bind_skill_tools with only the tools you need. Open only what the task needs.";
+var BIND_SKILL_TOOLS_DESCRIPTION = "After open_skill on a large skill, bind a chosen subset of its tools by name. Pick the few tools the task actually needs.";
+function findSkill(deps, key) {
+  return deps.skills.find((skill) => skill.key === key);
+}
+function createOpenSkillTool(deps) {
+  const tool = createTool({
+    name: "open_skill",
+    description: OPEN_SKILL_DESCRIPTION,
+    schema: zod.z.object({
+      skillKey: zod.z.string().min(1).describe("A key from <available_skills>."),
+      query: zod.z.string().optional().describe("What you need from the skill \u2014 used to rank a large skill's tools.")
+    }).strict(),
+    func: async ({ skillKey, query }) => {
+      const { registryRef: ref, policy } = tool._deps;
+      const skill = findSkill(tool._deps, skillKey);
+      if (!skill) {
+        return { error: `Unknown skill: ${skillKey}. Choose a key listed in <available_skills>.` };
+      }
+      if (skill.isAvailable && !await skill.isAvailable()) {
+        return { error: `Skill ${skillKey} is not available in this workspace.` };
+      }
+      const alreadyOpen = ref.openedSkillKeys.includes(skillKey);
+      if (!alreadyOpen) {
+        const guard = canOpenSkill(ref, policy);
+        if (!guard.ok) {
+          return {
+            error: `Cannot open ${skillKey}: ${guard.reason}. Work with the skills already open.`
+          };
+        }
+        ref.openedSkillKeys.push(skillKey);
+      }
+      const prompt = typeof skill.prompt === "function" ? await skill.prompt() : skill.prompt;
+      const index = await skill.listToolIndex();
+      if (index.length <= policy.maxBoundToolsPerSkill) {
+        const bound = await skill.bindTools();
+        const added = appendBoundTools(ref, bound, policy);
+        if (added.length > 0) ref.__onToolsChanged?.();
+        return {
+          skillKey,
+          prompt,
+          needsSandbox: Boolean(skill.needsSandbox),
+          boundTools: added.map((t) => t.name),
+          // Inject the bound tools into the live runtime for this loop.
+          __runtimeToolsDelta: added
+        };
+      }
+      let defaultBound = [];
+      let defaultAdded = [];
+      if ((!query || query.trim().length < 3) && skill.defaultBindNames?.length) {
+        const bound = await skill.bindTools(skill.defaultBindNames.slice(0, policy.maxBoundToolsPerSkill));
+        defaultAdded = appendBoundTools(ref, bound, policy);
+        if (defaultAdded.length > 0) ref.__onToolsChanged?.();
+        defaultBound = defaultAdded.map((t) => t.name);
+      }
+      const headers = query && query.trim().length >= 3 && skill.rankToolHeaders ? await skill.rankToolHeaders(query, index) : index;
+      return {
+        skillKey,
+        prompt,
+        needsSandbox: Boolean(skill.needsSandbox),
+        boundTools: defaultBound,
+        toolIndex: headers.slice(0, MAX_RETURNED_INDEX).map((h) => ({ name: h.name, description: h.description })),
+        hint: "Call bind_skill_tools(skillKey, toolNames) with only the tools you need.",
+        ...defaultAdded.length > 0 ? { __runtimeToolsDelta: defaultAdded } : {}
+      };
+    }
+  });
+  tool._deps = deps;
+  tool.__source = "smart-skills";
+  return tool;
+}
+function createBindSkillToolsTool(deps) {
+  const tool = createTool({
+    name: "bind_skill_tools",
+    description: BIND_SKILL_TOOLS_DESCRIPTION,
+    schema: zod.z.object({
+      skillKey: zod.z.string().min(1),
+      toolNames: zod.z.array(zod.z.string().min(1)).min(1).describe("Tool names from the skill's index.")
+    }).strict(),
+    func: async ({ skillKey, toolNames }) => {
+      const { registryRef: ref, policy } = tool._deps;
+      const skill = findSkill(tool._deps, skillKey);
+      if (!skill) {
+        return { error: `Unknown skill: ${skillKey}.` };
+      }
+      if (!ref.openedSkillKeys.includes(skillKey)) {
+        return { error: `Call open_skill("${skillKey}") before binding its tools.` };
+      }
+      const capped = toolNames.slice(0, policy.maxBoundToolsPerSkill);
+      const bound = await skill.bindTools(capped);
+      const added = appendBoundTools(ref, bound, policy);
+      if (added.length > 0) ref.__onToolsChanged?.();
+      return {
+        skillKey,
+        boundTools: added.map((t) => t.name),
+        requested: capped.length,
+        truncated: toolNames.length > capped.length,
+        ...added.length > 0 ? { __runtimeToolsDelta: added } : {}
+      };
+    }
+  });
+  tool._deps = deps;
+  tool.__source = "smart-skills";
+  return tool;
+}
+function createSkillTools(deps) {
+  return [createOpenSkillTool(deps), createBindSkillToolsTool(deps)];
+}
+
 // src/smart/index.ts
 function createSmartAgent(opts) {
   const resolved = normalizeSmartAgentOptions(opts);
@@ -6107,6 +6422,9 @@ function createSmartAgent(opts) {
   if (askUserConfig) {
     factoryToolsWithoutRecovery.push(createAskUserQuestionTool(factoryStateRef, askUserConfig));
   }
+  const skills = opts.skills ?? [];
+  const skillPolicy = opts.skillPolicy ?? DEFAULT_SKILL_POLICY;
+  const skillsEnabled = skills.length > 0;
   const soManagerFactory = opts.outputSchema ? new StructuredOutputManager(opts.outputSchema, resolveStrategy(opts.model)) : void 0;
   const modelCapabilities = opts.outputSchema ? getModelCapabilities(opts.model) : void 0;
   const responseFinalizeTool = soManagerFactory && modelCapabilities?.structuredOutput !== "native" ? soManagerFactory.getResponseTool() : void 0;
@@ -6114,12 +6432,31 @@ function createSmartAgent(opts) {
     const ref = { toolHistory: void 0, toolHistoryArchived: void 0, todoList: void 0, planVersion: 0, adherenceScore: 0 };
     const ctxTools = createContextTools(ref, { planningEnabled, includeGetToolResponse: false });
     const recoveryTool = createGetToolResponseTool(ref);
-    const base2 = [...userTools, ...ctxTools];
-    if (responseFinalizeTool) base2.push(responseFinalizeTool);
-    if (askUserConfig) base2.push(createAskUserQuestionTool(ref, askUserConfig));
-    const without = base2;
-    const withRec = [...without, recoveryTool];
-    return { stateRef: ref, toolsWithoutRecovery: without, toolsWithRecovery: withRec };
+    const coreBase = [...userTools, ...ctxTools];
+    if (responseFinalizeTool) coreBase.push(responseFinalizeTool);
+    if (askUserConfig) coreBase.push(createAskUserQuestionTool(ref, askUserConfig));
+    if (!skillsEnabled) {
+      const without = coreBase;
+      const withRec = [...without, recoveryTool];
+      return { stateRef: ref, toolsWithoutRecovery: without, toolsWithRecovery: withRec };
+    }
+    const toolSet = { stateRef: ref, toolsWithoutRecovery: [], toolsWithRecovery: [] };
+    const skillRegistryRef = createSkillRegistryRef();
+    const skillMetaTools = createSkillTools({ registryRef: skillRegistryRef, skills, policy: skillPolicy });
+    const baseWithMeta = [...coreBase, ...skillMetaTools];
+    const rebuild = () => {
+      const composed = composeToolSets({
+        base: baseWithMeta,
+        boundSkillTools: skillRegistryRef.boundSkillTools,
+        recoveryTool
+      });
+      toolSet.toolsWithoutRecovery = composed.toolsWithoutRecovery;
+      toolSet.toolsWithRecovery = composed.toolsWithRecovery;
+    };
+    skillRegistryRef.__onToolsChanged = rebuild;
+    toolSet.skillRegistryRef = skillRegistryRef;
+    rebuild();
+    return toolSet;
   };
   const base = createAgent({ ...runtimeOpts, tools: factoryToolsWithoutRecovery });
   base.__runtime.runtimeProfile = resolved.runtimeProfile;
@@ -6170,9 +6507,9 @@ function createSmartAgent(opts) {
       planVersion: ref.planVersion || state.planVersion || 1
     };
   }
-  function systemMessage2() {
+  function systemMessage2(extraBlock) {
     const sys = buildSystemPrompt(
-      [opts.systemPrompt, runtimeHint, structuredOutputHint].filter(Boolean).join("\n"),
+      [opts.systemPrompt, runtimeHint, structuredOutputHint, extraBlock].filter(Boolean).join("\n"),
       planningEnabled,
       opts.name || "Agent",
       opts.todoListPrompt
@@ -6222,8 +6559,10 @@ function createSmartAgent(opts) {
       stateRef.planVersion = input.planVersion || input.plan?.version || 0;
       stateRef.adherenceScore = input.plan?.adherenceScore || 0;
       const syncPlanFromRef = (state2) => syncPlanStateWith(stateRef, state2);
+      const availableSkills = skillsEnabled ? await resolveAvailableSkills(skills, { modelTier: skillPolicy.modelTier }) : [];
+      const skillBlock = availableSkills.length > 0 ? buildSkillHeaderBlock(availableSkills) : void 0;
       const alreadyHasSystem = Array.isArray(input.messages) && input.messages[0]?.role === "system";
-      const seedMessages = alreadyHasSystem ? [...input.messages || []] : [systemMessage2(), ...input.messages || []];
+      const seedMessages = alreadyHasSystem ? [...input.messages || []] : [systemMessage2(skillBlock), ...input.messages || []];
       let state = syncRuntimeTools(await syncMemory({ ...input, messages: seedMessages }), seedMessages, toolSet);
       let lastResult = null;
       let rawMessages = [...seedMessages];
@@ -6828,6 +7167,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 +7197,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 +7275,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 +7405,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 +7647,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 +7711,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 +7741,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 +7757,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 +7802,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 +7900,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 +7914,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 +7976,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 +8006,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 +8018,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 +8043,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 +8098,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 +8316,7 @@ var BedrockProvider = class extends BaseProvider {
     if (request.extra) {
       Object.assign(body, request.extra);
     }
+    applyBedrockReasoning(body, request.reasoning);
     return body;
   }
   splitSystemMessages(messages) {
@@ -7666,6 +8350,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 +8431,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 +8464,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 +8474,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 +8815,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 +8849,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 +8859,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 +8937,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 +8967,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 +9032,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 +9244,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) {
@@ -8609,25 +9348,32 @@ exports.AzureProvider = AzureProvider;
 exports.BaseProvider = BaseProvider;
 exports.BedrockProvider = BedrockProvider;
 exports.DEFAULT_PROFILE_CONFIGS = DEFAULT_PROFILE_CONFIGS;
+exports.DEFAULT_SKILL_POLICY = DEFAULT_SKILL_POLICY;
 exports.GuardrailPhase = GuardrailPhase;
 exports.InMemoryMemoryStore = InMemoryMemoryStore;
 exports.NativeJsonSchemaStrategy = NativeJsonSchemaStrategy;
 exports.OpenAICompatibleProvider = OpenAICompatibleProvider;
 exports.OpenAIProvider = OpenAIProvider;
 exports.ProviderError = ProviderError;
+exports.SMALL_TIER_SKILL_POLICY = SMALL_TIER_SKILL_POLICY;
 exports.StructuredOutputManager = StructuredOutputManager;
 exports.ToolBasedStrategy = ToolBasedStrategy;
 exports.VertexProvider = VertexProvider;
 exports.agentVerdictRule = agentVerdictRule;
+exports.appendBoundTools = appendBoundTools;
+exports.buildSkillHeaderBlock = buildSkillHeaderBlock;
 exports.buildSystemPrompt = buildSystemPrompt;
+exports.canOpenSkill = canOpenSkill;
 exports.captureSnapshot = captureSnapshot;
 exports.codePresenceRule = codePresenceRule;
 exports.cognipeerSink = cognipeerSink;
+exports.composeToolSets = composeToolSets;
 exports.countApproxTokens = countApproxTokens;
 exports.countMessagesTokens = countMessagesTokens;
 exports.createAgent = createAgent;
 exports.createAgentNode = createAgentNode;
 exports.createAskUserQuestionTool = createAskUserQuestionTool;
+exports.createBindSkillToolsTool = createBindSkillToolsTool;
 exports.createCodeGuardrail = createCodeGuardrail;
 exports.createContextSummarizeNode = createContextSummarizeNode;
 exports.createContextTools = createContextTools;
@@ -8635,15 +9381,19 @@ exports.createGetToolResponseTool = createGetToolResponseTool;
 exports.createGuardrail = createGuardrail;
 exports.createJsonGuardrail = createJsonGuardrail;
 exports.createManageTodoTool = createManageTodoTool;
+exports.createOpenSkillTool = createOpenSkillTool;
 exports.createProvider = createProvider;
 exports.createRegexGuardrail = createRegexGuardrail;
 exports.createResolverNode = createResolverNode;
+exports.createSkillRegistryRef = createSkillRegistryRef;
+exports.createSkillTools = createSkillTools;
 exports.createSmartAgent = createSmartAgent;
 exports.createTool = createTool;
 exports.createToolLimitFinalizeNode = createToolLimitFinalizeNode;
 exports.createToolsNode = createToolsNode;
 exports.customCallbackRule = customCallbackRule;
 exports.customSink = customSink;
+exports.dedupeToolsByName = dedupeToolsByName;
 exports.defaultTokenCounter = defaultTokenCounter;
 exports.emptyUsage = emptyUsage;
 exports.evaluateGuardrails = evaluateGuardrails;
@@ -8666,7 +9416,9 @@ exports.normalizeSmartAgentOptions = normalizeSmartAgentOptions;
 exports.otlpSink = otlpSink;
 exports.readMemoryFacts = readMemoryFacts;
 exports.regexRule = regexRule;
+exports.resolveAvailableSkills = resolveAvailableSkills;
 exports.resolveMemoryStore = resolveMemoryStore;
+exports.resolveReasoning = resolveReasoning;
 exports.resolveStrategy = resolveStrategy;
 exports.resolveToolApprovalState = resolveToolApprovalState;
 exports.resolveUserQuestionState = resolveUserQuestionState;
@@ -8675,6 +9427,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