interference-agent 0.1.0

package/src/config-file.ts

@@ -0,0 +1,109 @@
+import * as path from "node:path";
+import { readFile } from "node:fs/promises";
+import { setRules, type PermRule } from "./permissions.ts";
+import { setMode, type AgentMode } from "./config.ts";
+import type { InstructionBlock } from "./context.ts";
+
+interface InterferenceConfig {
+  model?: string;
+  mode?: "plan" | "build";
+  permissions?: Record<string, string | Record<string, string>>;
+  instructions?: string[];
+}
+
+let loadedConfig: InterferenceConfig | null = null;
+
+export function getLoadedConfig(): InterferenceConfig | null {
+  return loadedConfig;
+}
+
+export async function loadConfig(): Promise<InterferenceConfig | null> {
+  const filePath = findConfigFile();
+  if (!filePath) return null;
+
+  try {
+    const raw = await readFile(filePath, "utf-8");
+    const config = JSON.parse(raw) as InterferenceConfig;
+    loadedConfig = config;
+    return config;
+  } catch {
+    return null;
+  }
+}
+
+function findConfigFile(): string | null {
+  let dir = process.cwd();
+  const root = path.parse(dir).root;
+
+  while (dir !== root) {
+    const fp = path.join(dir, "interference.json");
+    try {
+      const stat = Bun.file(fp);
+      if (stat.size > 0) return fp;
+    } catch {}
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+export function applyConfig(config: InterferenceConfig): void {
+  // Model override (env INTERFERENCE_MODEL still wins in config.ts)
+  if (config.model && !process.env.INTERFERENCE_MODEL) {
+    process.env.INTERFERENCE_MODEL = config.model;
+  }
+
+  // Mode
+  if (config.mode) {
+    setMode(config.mode as AgentMode);
+  }
+
+  // Permissions: merge user rules with defaults
+  if (config.permissions) {
+    const rules = parsePermissionRules(config.permissions);
+    setRules(rules);
+  }
+}
+
+function parsePermissionRules(
+  permissions: Record<string, string | Record<string, string>>,
+): PermRule[] {
+  const rules: PermRule[] = [];
+
+  for (const [tool, value] of Object.entries(permissions)) {
+    if (typeof value === "string") {
+      rules.push({
+        tool,
+        decision: value as "allow" | "ask" | "deny",
+      });
+    } else {
+      for (const [pattern, decision] of Object.entries(value)) {
+        rules.push({
+          tool,
+          pattern,
+          decision: decision as "allow" | "ask" | "deny",
+        });
+      }
+    }
+  }
+
+  return rules;
+}
+
+export async function loadConfigInstructions(
+  config: InterferenceConfig,
+): Promise<InstructionBlock[]> {
+  const blocks: InstructionBlock[] = [];
+  if (!config.instructions) return blocks;
+
+  for (const filePath of config.instructions) {
+    const abs = path.resolve(process.cwd(), filePath);
+    try {
+      const content = await readFile(abs, "utf-8");
+      blocks.push({ source: abs, content });
+    } catch {}
+  }
+
+  return blocks;
+}

package/src/config.ts

@@ -0,0 +1,212 @@
+// Configurazione centralizzata (RF-CORE-02/03). Letta da env / `.env` (Bun carica
+// `.env` in automatico). Nessun segreto hardcoded: le API key arrivano da env.
+//
+// Multi-provider con REASONING/THINKING a livello selezionabile a runtime
+// (`/thinking`). Il meccanismo differisce per provider:
+//  - dedicati (anthropic/deepseek) → `providerOptions.<id>` passato a streamText
+//  - openai-compatible (glm/kimi)  → campo `thinking` iniettato nel body (extraBody)
+// `reasoningConfig()` traduce il livello corrente nelle opzioni giuste per provider.
+
+export type ProviderId = "anthropic" | "deepseek" | "openai" | "glm" | "kimi";
+
+export type ProviderKind = "anthropic" | "deepseek" | "openai-compatible";
+
+/** Livello di ragionamento unificato. I provider mappano sul proprio meccanismo. */
+export type ThinkingLevel = "off" | "low" | "medium" | "high" | "max";
+
+export interface ProviderDef {
+  label: string;
+  /** Nome della env var con la API key. */
+  envKey: string;
+  /** Model id di default (override con INTERFERENCE_MODEL). */
+  defaultModel: string;
+  kind: ProviderKind;
+  /** Per kind "openai-compatible": baseURL ESATTO (non normalizzare). */
+  baseURL?: string;
+  /** Context window size in tokens (per compaction threshold). Default 200K. */
+  contextLimit?: number;
+  /** Livelli di thinking supportati (per /thinking). off = disabilitato. */
+  thinkingLevels: ThinkingLevel[];
+  /** Livello di default del provider. */
+  defaultThinking: ThinkingLevel;
+  /** Modelli conosciuti per questo provider (per /model picker). */
+  models: { id: string; label: string }[];
+}
+
+export const PROVIDERS: Record<ProviderId, ProviderDef> = {
+  deepseek: {
+    label: "DeepSeek",
+    envKey: "DEEPSEEK_API_KEY",
+    defaultModel: "deepseek-v4-pro",
+    kind: "deepseek",
+    contextLimit: 1_000_000,
+    thinkingLevels: ["off", "low", "medium", "high", "max"],
+    defaultThinking: "max",
+    models: [
+      { id: "deepseek-v4-pro", label: "DeepSeek V4 Pro (1M ctx)" },
+      { id: "deepseek-v4-flash", label: "DeepSeek V4 Flash" },
+    ],
+  },
+  openai: {
+    label: "OpenAI",
+    envKey: "OPENAI_API_KEY",
+    defaultModel: "gpt-5.5",
+    kind: "openai-compatible",
+    baseURL: "https://api.openai.com/v1",
+    contextLimit: 1_000_000,
+    thinkingLevels: ["off", "low", "medium", "high", "max"],
+    defaultThinking: "high",
+    models: [
+      { id: "gpt-5.5", label: "GPT-5.5 (1M ctx)" },
+      { id: "gpt-5.4", label: "GPT-5.4 (1M ctx)" },
+    ],
+  },
+  anthropic: {
+    label: "Anthropic (Claude)",
+    envKey: "ANTHROPIC_API_KEY",
+    defaultModel: "claude-opus-4-8",
+    kind: "anthropic",
+    contextLimit: 1_000_000,
+    thinkingLevels: ["off", "low", "medium", "high", "max"],
+    defaultThinking: "high",
+    models: [
+      { id: "claude-opus-4-8", label: "Claude Opus 4.8 (1M ctx)" },
+      { id: "claude-sonnet-4-6", label: "Claude Sonnet 4.6 (1M ctx)" },
+    ],
+  },
+  glm: {
+    label: "Zhipu GLM",
+    envKey: "GLM_API_KEY",
+    defaultModel: "glm-5.2",
+    kind: "openai-compatible",
+    contextLimit: 1_000_000,
+    baseURL: "https://api.z.ai/api/paas/v4",
+    thinkingLevels: ["off", "max"],
+    defaultThinking: "max",
+    models: [
+      { id: "glm-5.2", label: "GLM-5.2 (1M ctx)" },
+    ],
+  },
+  kimi: {
+    label: "Moonshot Kimi",
+    envKey: "KIMI_API_KEY",
+    defaultModel: "kimi-k2.7",
+    kind: "openai-compatible",
+    contextLimit: 1_000_000,
+    baseURL: "https://api.moonshot.ai/v1",
+    thinkingLevels: ["off", "max"],
+    defaultThinking: "max",
+    models: [
+      { id: "kimi-k2.7", label: "Kimi K2.7 (1M ctx)" },
+    ],
+  },
+};
+
+function parseProvider(raw: string | undefined): ProviderId {
+  const id = (raw ?? "deepseek") as ProviderId;
+  return id in PROVIDERS ? id : "deepseek";
+}
+
+export const config = {
+  provider: parseProvider(process.env.INTERFERENCE_PROVIDER),
+  /** Override esplicito del modello; se assente si usa il default del provider. */
+  modelOverride: process.env.INTERFERENCE_MODEL,
+};
+
+/** Definizione del provider attualmente selezionato (override runtime > env var > default). */
+let _providerOverride: ProviderId | null = null;
+
+export function currentProvider(): ProviderDef {
+  const id = (_providerOverride ?? config.provider) as ProviderId;
+  return PROVIDERS[id] ?? PROVIDERS.deepseek;
+}
+
+export function setProvider(providerId: ProviderId) {
+  _providerOverride = providerId;
+}
+
+/** Model id effettivo (override runtime > env var > default del provider). */
+let _modelOverride: string | null = null;
+
+export function currentModel(): string {
+  return _modelOverride ?? config.modelOverride ?? currentProvider().defaultModel;
+}
+
+export function setModel(modelId: string) {
+  _modelOverride = modelId;
+}
+
+export function resetModel() {
+  _modelOverride = null;
+}
+
+// --- Mode (Plan/Build) ------------------------------------------------------
+export type AgentMode = "plan" | "build";
+
+let _mode: AgentMode = "build";
+
+export function currentMode(): AgentMode {
+  return _mode;
+}
+
+export function setMode(mode: AgentMode) {
+  _mode = mode;
+}
+
+// --- Thinking level (runtime, /thinking) ------------------------------------
+let _thinking: ThinkingLevel | null = null;
+
+/** Livello di thinking corrente (override runtime o default del provider). */
+export function currentThinking(): ThinkingLevel {
+  return _thinking ?? currentProvider().defaultThinking;
+}
+
+export function setThinking(level: ThinkingLevel) {
+  _thinking = level;
+}
+
+export interface ReasoningConfig {
+  providerOptions?: Record<string, unknown>;
+  extraBody?: Record<string, unknown>;
+  maxOutputTokens?: number;
+}
+
+// Anthropic: livello → budget token del thinking (maxOutputTokens deve superarlo).
+const ANTHROPIC_BUDGET: Record<Exclude<ThinkingLevel, "off">, number> = {
+  low: 8_000,
+  medium: 16_000,
+  high: 32_000,
+  max: 60_000,
+};
+
+/** Traduce il livello di thinking corrente nelle opzioni del provider attivo. */
+export function reasoningConfig(): ReasoningConfig {
+  const level = currentThinking();
+
+  switch (config.provider) {
+    case "deepseek":
+      if (level === "off") {
+        return { providerOptions: { deepseek: { thinking: { type: "disabled" } } } };
+      }
+      return {
+        providerOptions: { deepseek: { thinking: { type: "enabled" }, reasoningEffort: level } },
+      };
+
+    case "anthropic": {
+      if (level === "off") return {};
+      const budget = ANTHROPIC_BUDGET[level];
+      return {
+        providerOptions: { anthropic: { thinking: { type: "enabled", budgetTokens: budget } } },
+        maxOutputTokens: budget + 8_000,
+      };
+    }
+
+    case "openai":
+    case "glm":
+      return { extraBody: { thinking: { type: level === "off" ? "disabled" : "enabled" } } };
+
+    case "kimi":
+      if (level === "off") return { extraBody: { thinking: { type: "disabled" } } };
+      return { extraBody: { thinking: { type: "enabled", keep: "all" } } };
+  }
+}

package/src/context.ts

@@ -0,0 +1,96 @@
+import { readFile } from "node:fs/promises";
+import * as path from "node:path";
+import { existsSync } from "node:fs";
+
+const GLOBAL_CONFIG = path.join(
+  process.env.HOME ?? process.env.USERPROFILE ?? "/tmp",
+  ".config",
+  "interference",
+);
+
+const GLOBAL_AGENTS = path.join(GLOBAL_CONFIG, "AGENTS.md");
+const GLOBAL_CLAUDE = path.join(
+  process.env.HOME ?? "/tmp",
+  ".claude",
+  "CLAUDE.md",
+);
+
+const PROJECT_FILES = ["AGENTS.md", "CLAUDE.md"] as const;
+
+export interface InstructionBlock {
+  source: string;
+  content: string;
+}
+
+export async function loadInstructions(): Promise<InstructionBlock[]> {
+  const blocks: InstructionBlock[] = [];
+
+  // 1. Global AGENTS.md
+  try {
+    const content = await readFile(GLOBAL_AGENTS, "utf-8");
+    blocks.push({ source: GLOBAL_AGENTS, content });
+  } catch {}
+
+  // 2. ~/.claude/CLAUDE.md
+  try {
+    const content = await readFile(GLOBAL_CLAUDE, "utf-8");
+    blocks.push({ source: GLOBAL_CLAUDE, content });
+  } catch {}
+
+  // 3. Project instructions — walk up from cwd, first match wins per file
+  let dir = process.cwd();
+  const root = path.parse(dir).root;
+  const found = new Set<string>();
+
+  while (dir !== root) {
+    for (const name of PROJECT_FILES) {
+      if (found.has(name)) continue;
+      const fp = path.join(dir, name);
+      try {
+        const content = await readFile(fp, "utf-8");
+        blocks.push({ source: fp, content });
+        found.add(name);
+      } catch {}
+    }
+    if (found.size >= PROJECT_FILES.length) break;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+
+  return blocks;
+}
+
+export function findProjectInstructionPath(): string | null {
+  let dir = process.cwd();
+  const root = path.parse(dir).root;
+
+  while (dir !== root) {
+    for (const name of PROJECT_FILES) {
+      const fp = path.join(dir, name);
+      if (existsSync(fp)) return fp;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+export async function loadInstructionContent(filePath: string): Promise<string | null> {
+  try {
+    return await readFile(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+export function formatInstructionBlock(block: InstructionBlock): string {
+  const short = block.source.startsWith(process.env.HOME ?? "/")
+    ? block.source.replace(process.env.HOME ?? "/tmp", "~")
+    : block.source;
+  const trimmed = block.content.length > 4000
+    ? block.content.slice(0, 4000) + "\n… [truncated]"
+    : block.content;
+  return `--- Instructions from: ${short} ---\n${trimmed}`;
+}

package/src/cost.ts

@@ -0,0 +1,54 @@
+import { currentModel } from "./config.ts";
+
+interface Pricing {
+  inputPer1M: number;
+  outputPer1M: number;
+}
+
+const PRICING: Record<string, Pricing> = {
+  "deepseek-v4-pro": { inputPer1M: 2.0, outputPer1M: 8.0 },
+  "deepseek-v4-flash": { inputPer1M: 0.27, outputPer1M: 1.10 },
+  "gpt-5.5": { inputPer1M: 5.0, outputPer1M: 30.0 },
+  "gpt-5.4": { inputPer1M: 2.50, outputPer1M: 15.0 },
+  "claude-opus-4-8": { inputPer1M: 5.0, outputPer1M: 25.0 },
+  "claude-sonnet-4-6": { inputPer1M: 3.0, outputPer1M: 15.0 },
+  "glm-5.2": { inputPer1M: 1.0, outputPer1M: 1.0 },
+  "kimi-k2.7": { inputPer1M: 0.5, outputPer1M: 2.0 },
+};
+
+export function getPricing(modelId?: string): Pricing {
+  return PRICING[modelId ?? currentModel()] ?? { inputPer1M: 2.0, outputPer1M: 8.0 };
+}
+
+let totalInputTokens = 0;
+let totalOutputTokens = 0;
+
+export function trackUsage(inputTokens: number, outputTokens: number) {
+  totalInputTokens += inputTokens;
+  totalOutputTokens += outputTokens;
+}
+
+export function getTotalCost(): number {
+  const pricing = getPricing(currentModel());
+  return (
+    (totalInputTokens / 1_000_000) * pricing.inputPer1M +
+    (totalOutputTokens / 1_000_000) * pricing.outputPer1M
+  );
+}
+
+export function estimateCost(inputTokens: number): number {
+  const pricing = getPricing(currentModel());
+  return (inputTokens / 1_000_000) * pricing.inputPer1M;
+}
+
+export function formatCost(cost: number): string {
+  if (cost < 0.0001) return "<$0.01";
+  return `$${cost.toFixed(2)}`;
+}
+
+export function getUsageStats() {
+  return {
+    inputTokens: totalInputTokens,
+    outputTokens: totalOutputTokens,
+  };
+}

package/src/git.ts

@@ -0,0 +1,22 @@
+let cachedBranch: string | null = null;
+
+export async function getGitBranch(): Promise<string> {
+  if (cachedBranch !== null) return cachedBranch;
+  try {
+    const proc = Bun.spawn(["git", "rev-parse", "--abbrev-ref", "HEAD"], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const out = await proc.stdout.text();
+    if (proc.exitCode === 0) {
+      cachedBranch = out.trim();
+      return cachedBranch;
+    }
+  } catch {}
+  cachedBranch = "no-git";
+  return cachedBranch;
+}
+
+export function invalidateGitCache() {
+  cachedBranch = null;
+}

package/src/permissions.ts

@@ -0,0 +1,135 @@
+type Decision = "allow" | "ask" | "deny";
+
+export interface PermRule {
+  tool?: string;
+  pattern?: string;
+  decision: Decision;
+}
+
+const DEFAULT_RULES: PermRule[] = [
+  { pattern: "rm -rf*", decision: "deny" },
+  { pattern: "rm -r *", decision: "deny" },
+  { pattern: "rm -rf /*", decision: "deny" },
+  { pattern: "sudo *", decision: "deny" },
+  { pattern: "curl * | *sh*", decision: "deny" },
+  { pattern: "wget * -O *|*sh*", decision: "deny" },
+  { pattern: "git push --force*", decision: "deny" },
+  { pattern: "git push -f*", decision: "deny" },
+  { pattern: "> /dev/sda*", decision: "deny" },
+  { pattern: "mkfs.*", decision: "deny" },
+  { pattern: "dd if=*", decision: "deny" },
+  { pattern: "chmod 777 *", decision: "deny" },
+  { pattern: ":(){ :|:& };:*", decision: "deny" },
+  { tool: "write", pattern: "*.env", decision: "deny" },
+  { tool: "write", pattern: "**/*.env", decision: "deny" },
+  { tool: "write", pattern: "*.pem", decision: "deny" },
+  { tool: "write", pattern: "**/*.pem", decision: "deny" },
+  { tool: "write", pattern: "*.key", decision: "deny" },
+  { tool: "write", pattern: "**/*.key", decision: "deny" },
+  { tool: "write", pattern: "secrets/**", decision: "deny" },
+  { tool: "write", pattern: "**/secrets/**", decision: "deny" },
+  { tool: "edit", pattern: "*.env", decision: "deny" },
+  { tool: "edit", pattern: "**/*.env", decision: "deny" },
+  { tool: "edit", pattern: "*.pem", decision: "deny" },
+  { tool: "edit", pattern: "**/*.pem", decision: "deny" },
+  { tool: "edit", pattern: "*.key", decision: "deny" },
+  { tool: "edit", pattern: "**/*.key", decision: "deny" },
+  { tool: "edit", pattern: "secrets/**", decision: "deny" },
+  { tool: "edit", pattern: "**/secrets/**", decision: "deny" },
+];
+
+let rules: PermRule[] = [...DEFAULT_RULES];
+
+export function setRules(newRules: PermRule[]) {
+  rules = [...newRules, ...DEFAULT_RULES];
+}
+
+export function getRules(): PermRule[] {
+  return rules;
+}
+
+export function resetRules() {
+  rules = [...DEFAULT_RULES];
+}
+
+export function decide(toolName: string, subject: string): Decision {
+  if (toolName === "read" || toolName === "ls" || toolName === "glob" || toolName === "grep" || toolName === "webfetch") {
+    return "allow";
+  }
+
+  for (const rule of rules) {
+    if (rule.tool && rule.tool !== toolName) continue;
+    if (rule.pattern) {
+      if (toolName === "bash") {
+        if (matchBashPattern(rule.pattern, subject)) {
+          return rule.decision;
+        }
+      } else {
+        if (matchGlobPath(rule.pattern, subject)) {
+          return rule.decision;
+        }
+      }
+      continue;
+    }
+    return rule.decision;
+  }
+
+  return "allow";
+}
+
+function matchBashPattern(pattern: string, command: string): boolean {
+  return globMatch(command, pattern, ".");
+}
+
+function matchGlobPath(glob: string, filePath: string): boolean {
+  return globMatch(filePath, glob, "/");
+}
+
+function globMatch(str: string, glob: string, sep: string): boolean {
+  const single = sep === "/" ? "[^/]*" : ".*";
+  const any = sep === "/" ? ".*" : ".*";
+  let p = glob
+    .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+    .replace(/\*\*/g, "\u0000GLOBSTAR\u0000")
+    .replace(/\*/g, single)
+    .replace(/\u0000GLOBSTAR\u0000/g, any)
+    .replace(/\?/g, sep === "/" ? "[^/]" : ".");
+  return new RegExp(`^${p}$`).test(str);
+}
+
+// Conferma delle azioni `ask`. Modello EVENT-DRIVEN (niente race con lo stream):
+// la CLI registra un handler con setConfirmHandler; `requestConfirmation` (invocato
+// dentro l'execute del tool) lo chiama direttamente e ne attende la risposta.
+// Se nessun handler è registrato (es. nei test), si usa il fallback manuale
+// answerConfirmation/needsConfirmation.
+
+export type ConfirmHandler = (tool: string, preview: string) => Promise<boolean>;
+
+let confirmHandler: ConfirmHandler | null = null;
+let pendingResolver: ((answer: boolean) => void) | null = null;
+let pending: { tool: string; preview: string } | null = null;
+
+export function setConfirmHandler(handler: ConfirmHandler | null) {
+  confirmHandler = handler;
+}
+
+export async function requestConfirmation(tool: string, preview: string): Promise<boolean> {
+  if (confirmHandler) return confirmHandler(tool, preview);
+  // Fallback senza handler (test): risolto da answerConfirmation.
+  pending = { tool, preview };
+  return new Promise<boolean>((resolve) => {
+    pendingResolver = resolve;
+  });
+}
+
+export function needsConfirmation(): { tool: string; preview: string } | null {
+  return pending;
+}
+
+export function answerConfirmation(answer: boolean) {
+  if (pendingResolver) {
+    pendingResolver(answer);
+    pendingResolver = null;
+    pending = null;
+  }
+}

package/src/provider.ts

@@ -0,0 +1,58 @@
+// Astrazione provider (RF-CORE-03). Risolve un `LanguageModel` del Vercel AI SDK
+// per il provider selezionato. Reasoning/thinking abilitato per ogni provider:
+//  - anthropic/deepseek: via providerOptions (gestito nell'agent loop)
+//  - glm/kimi (openai-compatible): il campo `thinking` viene iniettato nel body
+//    con `transformRequestBody`; un middleware estrae eventuali <think> inline.
+
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createDeepSeek } from "@ai-sdk/deepseek";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { extractReasoningMiddleware, wrapLanguageModel, type LanguageModel } from "ai";
+import { currentModel, currentProvider, reasoningConfig, type ProviderDef } from "./config.ts";
+
+export class MissingApiKeyError extends Error {
+  constructor(provider: ProviderDef) {
+    super(
+      `${provider.label}: ${provider.envKey} non è impostata.\n` +
+        `  Aggiungila al file .env (o esportala):  ${provider.envKey}=...`,
+    );
+    this.name = "MissingApiKeyError";
+  }
+}
+
+/** Risolve il modello del provider selezionato. Solleva MissingApiKeyError se manca la key. */
+export function resolveModel(): LanguageModel {
+  const def = currentProvider();
+  const apiKey = process.env[def.envKey];
+  if (!apiKey) throw new MissingApiKeyError(def);
+
+  const model = currentModel();
+
+  switch (def.kind) {
+    case "anthropic":
+      return createAnthropic({ apiKey })(model);
+
+    case "deepseek":
+      return createDeepSeek({ apiKey })(model);
+
+    case "openai-compatible": {
+      // Opzioni di thinking per il livello corrente (/thinking), calcolate ad ogni turno.
+      const extraBody = reasoningConfig().extraBody;
+      const provider = createOpenAICompatible({
+        name: def.label,
+        baseURL: def.baseURL ?? "",
+        apiKey,
+        // Inietta i campi non-OpenAI-standard (es. `thinking`) nel body grezzo.
+        transformRequestBody: extraBody
+          ? (body: Record<string, unknown>) => ({ ...body, ...extraBody })
+          : undefined,
+      });
+      // Fallback: se il modello inlinea il reasoning tra <think>...</think>, estrailo
+      // come reasoning (per chi manda reasoning_content separato è un no-op).
+      return wrapLanguageModel({
+        model: provider(model),
+        middleware: extractReasoningMiddleware({ tagName: "think" }),
+      });
+    }
+  }
+}