nexus-agents 2.72.0 → 2.72.1

package/dist/{chunk-3HR6UJ2E.js → chunk-J4VR2WNI.js}

@@ -67,7 +67,7 @@ import {
   clampTaskTtl,
   getAvailabilityCache,
   resolveFallback
-} from "./chunk-XHVDKY3X.js";
+} from "./chunk-YOREAPF6.js";
 import {
   DEFAULTS
 } from "./chunk-2MD5MWCK.js";
@@ -14309,6 +14309,733 @@ async function loadAllExternalPacks(packs, logger55) {
   return { loaded, errors };
 }
 
+// src/config/model-identity.ts
+var VENDOR_PATTERNS = [
+  { vendor: "anthropic", regex: /\b(claude|anthropic)\b/ },
+  // OpenAI: gpt, o1-o9 reasoning, chatgpt, openai prefix
+  { vendor: "openai", regex: /\b(gpt|o[1-9]|chatgpt|openai)\b/ },
+  { vendor: "google", regex: /\b(gemini|bison|gecko|palm|google)\b/ },
+  { vendor: "meta", regex: /\b(llama|meta-llama|meta)\b/ },
+  { vendor: "qwen", regex: /\b(qwen)\b/ },
+  { vendor: "nvidia", regex: /\b(nemotron|nvidia)\b/ },
+  { vendor: "mistral", regex: /\b(mistral|mixtral|codestral)\b/ },
+  { vendor: "cohere", regex: /\b(command-r|command|cohere)\b/ },
+  { vendor: "deepseek", regex: /\b(deepseek)\b/ }
+];
+var FAMILY_PATTERNS = [
+  // Anthropic
+  { vendor: "anthropic", family: "claude-opus", regex: /\b(opus)\b/ },
+  { vendor: "anthropic", family: "claude-sonnet", regex: /\b(sonnet)\b/ },
+  { vendor: "anthropic", family: "claude-haiku", regex: /\b(haiku)\b/ },
+  // OpenAI
+  { vendor: "openai", family: "o-reasoning", regex: /\bo[1-9]\b/ },
+  { vendor: "openai", family: "gpt-4o", regex: /\b(gpt-4o|gpt4o|4o)\b/ },
+  { vendor: "openai", family: "gpt-4", regex: /\b(gpt-4)\b/ },
+  { vendor: "openai", family: "gpt-3.5", regex: /\b(gpt-3-5|gpt-3\.5|gpt35)\b/ },
+  // Google
+  { vendor: "google", family: "gemini-pro", regex: /\bgemini.*\bpro\b/ },
+  { vendor: "google", family: "gemini-flash", regex: /\bgemini.*\bflash\b/ },
+  { vendor: "google", family: "gemini", regex: /\bgemini\b/ },
+  // Meta
+  { vendor: "meta", family: "llama-3", regex: /\bllama-?3\b/ },
+  { vendor: "meta", family: "llama-2", regex: /\bllama-?2\b/ },
+  // Qwen — version is in the family name
+  { vendor: "qwen", family: "qwen-3", regex: /\bqwen-?3\b/ },
+  { vendor: "qwen", family: "qwen-2.5", regex: /\bqwen-?2-?5\b/ },
+  { vendor: "qwen", family: "qwen-2", regex: /\bqwen-?2\b/ },
+  // Mistral
+  { vendor: "mistral", family: "mixtral", regex: /\bmixtral\b/ },
+  { vendor: "mistral", family: "codestral", regex: /\bcodestral\b/ },
+  { vendor: "mistral", family: "mistral", regex: /\bmistral\b/ }
+];
+var QUIRK_PATTERNS = [
+  { regex: /\b(embedding|embed)\b/, quirk: "embedding" },
+  { regex: /\b(thinking|reasoning)\b/, quirk: "thinking" },
+  { regex: /\bvision\b/, quirk: "vision" },
+  { regex: /\b(coder|code)\b/, quirk: "coder" },
+  { regex: /\binstruct\b/, quirk: "instruct" },
+  { regex: /\b(mini|nano|tiny|small|lite)\b/, quirk: "small" },
+  { regex: /\b(large|xl|big|maxi)\b/, quirk: "large" },
+  { regex: /\bhigh\b/, quirk: "high-variant" },
+  { regex: /\b(\d+)b\b/, quirk: "sized-suffix" },
+  // 7b, 70b, 405b
+  { regex: /\b\d{8}\b/, quirk: "dated" }
+  // 20240806 etc
+];
+async function resolveModelIdentity(adapter, options = {}) {
+  const rawModelId = adapter.modelId;
+  const hints = options.hints ?? {};
+  let probe;
+  if (options.skipProbe !== true && typeof adapter.listModels === "function") {
+    probe = await runProbe(adapter, rawModelId);
+  }
+  const parsed = parseModelId(rawModelId);
+  return mergeIdentity({ rawModelId, hints, probe, parsed });
+}
+function resolveModelIdentitySync(modelId, hints) {
+  return mergeIdentity({
+    rawModelId: modelId,
+    hints: hints ?? {},
+    probe: void 0,
+    parsed: parseModelId(modelId)
+  });
+}
+function parseModelId(modelId) {
+  const normalised = normaliseModelId(modelId);
+  const vendor = detectVendor(normalised);
+  const family = vendor !== void 0 ? detectFamily(normalised, vendor) : void 0;
+  const version = vendor !== void 0 && family !== void 0 ? extractVersion(normalised, family) : void 0;
+  const quirks = detectQuirks(normalised);
+  return {
+    ...vendor !== void 0 && { vendor },
+    ...family !== void 0 && { family },
+    ...version !== void 0 && { version },
+    quirks
+  };
+}
+function normaliseModelId(modelId) {
+  return modelId.toLowerCase().replace(/[_/]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function detectVendor(normalised) {
+  for (const { vendor, regex } of VENDOR_PATTERNS) {
+    if (regex.test(normalised)) return vendor;
+  }
+  return void 0;
+}
+function detectFamily(normalised, vendor) {
+  for (const fp of FAMILY_PATTERNS) {
+    if (fp.vendor !== vendor) continue;
+    if (fp.regex.test(normalised)) return fp.family;
+  }
+  return void 0;
+}
+function extractVersion(normalised, family) {
+  const familyRoot = family.replace(/^claude-|^gemini-|^llama-|^qwen-|^gpt-/, "");
+  const idx = normalised.indexOf(familyRoot);
+  if (idx === -1) return void 0;
+  const tail = normalised.slice(idx + familyRoot.length);
+  const m = /^[-]?(\d[\d.\-]*)/.exec(tail);
+  if (m === null) return void 0;
+  return m[1]?.replace(/-+$/, "") ?? void 0;
+}
+function detectQuirks(normalised) {
+  const out = [];
+  for (const { regex, quirk } of QUIRK_PATTERNS) {
+    if (regex.test(normalised) && !out.includes(quirk)) out.push(quirk);
+  }
+  return out;
+}
+async function runProbe(adapter, modelId) {
+  try {
+    const capable = adapter;
+    const models = await capable.listModels();
+    const matched = models.find((m) => m.id === modelId);
+    if (matched === void 0) return void 0;
+    const result = { metadata: matched };
+    if (matched.ownedBy !== void 0) {
+      const vendor = vendorFromOwnedBy(matched.ownedBy);
+      if (vendor !== void 0) {
+        return { ...result, vendor };
+      }
+    }
+    return result;
+  } catch {
+    return void 0;
+  }
+}
+var OWNED_BY_PATTERNS = [
+  { substr: "anthropic", vendor: "anthropic" },
+  { substr: "openai", vendor: "openai" },
+  { substr: "google", vendor: "google" },
+  { substr: "meta", vendor: "meta" },
+  { substr: "alibaba", vendor: "qwen" },
+  { substr: "qwen", vendor: "qwen" },
+  { substr: "nvidia", vendor: "nvidia" },
+  { substr: "nemotron", vendor: "nvidia" },
+  { substr: "mistral", vendor: "mistral" },
+  { substr: "cohere", vendor: "cohere" },
+  { substr: "deepseek", vendor: "deepseek" }
+];
+function vendorFromOwnedBy(ownedBy) {
+  const lc = ownedBy.toLowerCase();
+  for (const { substr, vendor } of OWNED_BY_PATTERNS) {
+    if (lc.includes(substr)) return vendor;
+  }
+  return void 0;
+}
+function mergeIdentity(args) {
+  const { rawModelId, hints, probe, parsed } = args;
+  const version = pickVersion(hints, parsed);
+  return {
+    vendor: hints.vendor ?? probe?.vendor ?? parsed.vendor ?? "unknown",
+    family: hints.family ?? parsed.family ?? "unknown",
+    ...version !== void 0 && { version },
+    quirks: [.../* @__PURE__ */ new Set([...hints.quirks ?? [], ...parsed.quirks])],
+    source: pickSource(hints, probe, parsed),
+    rawModelId
+  };
+}
+function pickVersion(hints, parsed) {
+  return hints.version ?? parsed.version;
+}
+function pickSource(hints, probe, parsed) {
+  if (hints.vendor !== void 0) return "modelHints";
+  if (probe?.vendor !== void 0) return "probe";
+  if (parsed.vendor !== void 0) return "modelIdParse";
+  return "default";
+}
+
+// src/config/model-behavior-profile.ts
+var DEFAULT_PROFILE = {
+  parallelToolCalls: false,
+  promptCaching: "none",
+  toolDefinitionFormat: "openai",
+  maxRecommendedTurnBudget: 10,
+  strictJson: true,
+  quirks: [],
+  profileId: "default"
+};
+var VENDOR_PROFILES = {
+  anthropic: {
+    profileId: "anthropic-default",
+    promptCaching: "ephemeral",
+    toolDefinitionFormat: "anthropic",
+    parallelToolCalls: true,
+    // Claude 4.x supports parallel tool_use blocks
+    maxRecommendedTurnBudget: 15
+  },
+  openai: {
+    profileId: "openai-default",
+    parallelToolCalls: true,
+    toolDefinitionFormat: "openai",
+    maxRecommendedTurnBudget: 15
+  },
+  google: {
+    profileId: "google-default",
+    toolDefinitionFormat: "gemini",
+    parallelToolCalls: true,
+    maxRecommendedTurnBudget: 15
+  },
+  meta: {
+    profileId: "meta-default",
+    toolDefinitionFormat: "openai",
+    parallelToolCalls: false,
+    // many open-weight Llamas struggle with parallel tools
+    maxRecommendedTurnBudget: 8
+  },
+  qwen: {
+    profileId: "qwen-default",
+    toolDefinitionFormat: "openai",
+    parallelToolCalls: false,
+    maxRecommendedTurnBudget: 8
+  },
+  nvidia: {
+    profileId: "nvidia-nemotron-default",
+    toolDefinitionFormat: "openai",
+    parallelToolCalls: false,
+    maxRecommendedTurnBudget: 8
+  },
+  mistral: {
+    profileId: "mistral-default",
+    toolDefinitionFormat: "openai",
+    parallelToolCalls: false,
+    maxRecommendedTurnBudget: 8
+  },
+  cohere: {
+    profileId: "cohere-default",
+    toolDefinitionFormat: "openai",
+    parallelToolCalls: false,
+    maxRecommendedTurnBudget: 8
+  },
+  deepseek: {
+    profileId: "deepseek-default",
+    toolDefinitionFormat: "openai",
+    parallelToolCalls: false,
+    maxRecommendedTurnBudget: 10
+  }
+};
+var FAMILY_PROFILES = [
+  {
+    vendor: "anthropic",
+    family: "claude-opus",
+    override: { profileId: "claude-opus", maxRecommendedTurnBudget: 20 }
+  },
+  {
+    vendor: "anthropic",
+    family: "claude-haiku",
+    override: { profileId: "claude-haiku", maxRecommendedTurnBudget: 8 }
+  },
+  {
+    vendor: "openai",
+    family: "o-reasoning",
+    override: {
+      profileId: "openai-o-reasoning",
+      // o1-style reasoning models burn extra turns thinking; recommend
+      // a higher budget. They also don't support `temperature`.
+      maxRecommendedTurnBudget: 25
+    }
+  },
+  {
+    vendor: "google",
+    family: "gemini-flash",
+    override: { profileId: "gemini-flash", maxRecommendedTurnBudget: 8 }
+  }
+];
+function lookupModelProfile(identity) {
+  let profile = { ...DEFAULT_PROFILE };
+  const vendorOverride = VENDOR_PROFILES[identity.vendor];
+  if (vendorOverride !== void 0) profile = mergeProfile(profile, vendorOverride);
+  const familyOverride = FAMILY_PROFILES.find(
+    (e) => e.vendor === identity.vendor && e.family === identity.family
+  );
+  if (familyOverride !== void 0) profile = mergeProfile(profile, familyOverride.override);
+  profile = applyQuirkOverlay(profile, identity.quirks);
+  return profile;
+}
+function mergeProfile(base, override) {
+  return {
+    ...base,
+    ...override
+  };
+}
+function applyQuirkOverlay(profile, identityQuirks) {
+  if (identityQuirks.length === 0) return profile;
+  const merged = /* @__PURE__ */ new Set([...profile.quirks, ...identityQuirks]);
+  let maxBudget = profile.maxRecommendedTurnBudget;
+  if (identityQuirks.includes("thinking")) {
+    maxBudget = Math.ceil(maxBudget * 1.5);
+  }
+  return {
+    ...profile,
+    quirks: [...merged],
+    maxRecommendedTurnBudget: maxBudget
+  };
+}
+
+// src/agents/agentic/types.ts
+var AgentError9 = class extends Error {
+  causeData;
+  constructor(message, cause) {
+    super(message);
+    this.name = "AgentError";
+    if (cause !== void 0) this.causeData = cause;
+  }
+};
+
+// src/agents/agentic/agentic-adapter.ts
+var AgenticAdapter = class {
+  providerId;
+  modelId;
+  /**
+   * Adapter strategy stamp — composed from the resolved model
+   * identity, NOT the IModelAdapter's providerId. For a custom OpenAI
+   * gateway fronting Claude, this reads `native:anthropic` even though
+   * `IModelAdapter.providerId === 'openai'`.
+   *
+   * Initialised eagerly from the modelId parse (sync); upgraded after
+   * the first `runAgent` if the probe contributes a higher-confidence
+   * vendor signal.
+   */
+  adapterStrategy;
+  model;
+  options;
+  semaphore;
+  resolvedIdentity;
+  profile;
+  profileResolutionPromise = null;
+  constructor(modelAdapter, options = {}) {
+    this.model = modelAdapter;
+    this.options = options;
+    this.providerId = modelAdapter.providerId;
+    this.modelId = modelAdapter.modelId;
+    this.resolvedIdentity = resolveModelIdentitySync(modelAdapter.modelId, options.modelHints);
+    this.profile = options.forceProfile ?? lookupModelProfile(this.resolvedIdentity);
+    this.adapterStrategy = stampStrategy(this.resolvedIdentity);
+    if (this.profile.quirks.includes("embedding")) {
+      throw new AgentError9(
+        `Refusing to construct AgenticAdapter for an embedding model (${modelAdapter.modelId}). Agentic loops require a chat-completion model.`
+      );
+    }
+    this.semaphore = options.maxConcurrent !== void 0 && options.maxConcurrent > 0 ? new Semaphore(options.maxConcurrent) : null;
+  }
+  /**
+   * Read-only accessor for the resolved profile. Mostly used in tests
+   * + observability surfaces; production callers shouldn't need this.
+   */
+  getProfile() {
+    return this.profile;
+  }
+  /**
+   * Read-only accessor for the resolved identity. After the first
+   * `runAgent` call (if a probe ran), this may differ from what the
+   * sync constructor stored — useful for audit logs.
+   */
+  getResolvedIdentity() {
+    return this.resolvedIdentity;
+  }
+  /**
+   * Lazily resolve identity via the async probe + refresh the profile.
+   * Idempotent + concurrent-call-safe (multiple `runAgent`s share the
+   * same in-flight resolution).
+   */
+  async ensureIdentityResolved() {
+    if (this.options.forceProfile !== void 0) return;
+    if (this.options.skipProbe === true) return;
+    if (typeof this.model.listModels !== "function") return;
+    if (this.profileResolutionPromise !== null) {
+      await this.profileResolutionPromise;
+      return;
+    }
+    this.profileResolutionPromise = this.doResolveIdentity();
+    try {
+      await this.profileResolutionPromise;
+    } finally {
+    }
+  }
+  /**
+   * If the resolved profile asks for `'ephemeral'` prompt caching,
+   * mark the LAST tool definition with `cache_control: { type:
+   * 'ephemeral' }`. Anthropic interprets this as "cache everything up
+   * to and including the tool definitions"; other providers strip the
+   * unknown field at the canonical-request mapper.
+   *
+   * Last-tool placement is the Anthropic convention: cache key is the
+   * prefix, so caching the final tool block caches the entire tools
+   * section. Per-turn the system prompt + user prompt + tools are
+   * stable, so cache-hit rate on multi-turn agent runs is high.
+   */
+  applyCacheControlIfRequested(tools) {
+    if (this.profile.promptCaching !== "ephemeral") return [...tools];
+    if (tools.length === 0) return [];
+    return tools.map(
+      (tool, idx) => idx === tools.length - 1 ? {
+        ...tool,
+        cacheControl: { type: "ephemeral" }
+      } : tool
+    );
+  }
+  async doResolveIdentity() {
+    const refined = await resolveModelIdentity(this.model, {
+      ...this.options.modelHints !== void 0 && { hints: this.options.modelHints }
+    });
+    if (refined.source === "probe" || refined.source === "modelHints") {
+      this.resolvedIdentity = refined;
+      this.profile = lookupModelProfile(refined);
+      this.adapterStrategy = stampStrategy(refined);
+    }
+  }
+  async runAgent(args) {
+    await this.ensureIdentityResolved();
+    const turnBudget = args.turnBudget ?? this.profile.maxRecommendedTurnBudget;
+    if (turnBudget <= 0) {
+      return err(new AgentError9(`turnBudget must be > 0, got ${String(turnBudget)}`));
+    }
+    const resolvedArgs = { ...args, turnBudget };
+    const state = {
+      turns: [],
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      finalContent: "",
+      messages: [{ role: "user", content: args.userPrompt }]
+    };
+    while (state.turns.length < turnBudget) {
+      if (args.signal?.aborted === true) {
+        return ok(this.buildFromState(state, "cancelled"));
+      }
+      const turnOutcome = await this.runOneTurn(resolvedArgs, state);
+      if (turnOutcome.kind === "error") return err(turnOutcome.error);
+      if (turnOutcome.kind === "stop") {
+        return ok(this.buildFromState(state, turnOutcome.reason));
+      }
+    }
+    return ok(this.buildFromState(state, "turn-budget"));
+  }
+  /**
+   * Run one model-call cycle: call → check for tool_use → execute tool
+   * calls → append results. Returns one of three outcomes describing
+   * whether the loop continues, stops naturally, or hit a model error.
+   */
+  async runOneTurn(args, state) {
+    const t0 = Date.now();
+    const completion = await this.callModelGated({
+      messages: state.messages,
+      systemPrompt: args.systemPrompt,
+      tools: this.applyCacheControlIfRequested([...args.tools]),
+      ...args.temperature !== void 0 && { temperature: args.temperature },
+      ...args.maxTokens !== void 0 && { maxTokens: args.maxTokens }
+    });
+    const modelLatencyMs = Date.now() - t0;
+    if (!completion.ok) {
+      return {
+        kind: "error",
+        error: new AgentError9(
+          `Model call failed at turn ${String(state.turns.length)}: ${completion.error.message}`,
+          completion.error
+        )
+      };
+    }
+    const response = completion.value;
+    state.totalInputTokens += response.usage.inputTokens;
+    state.totalOutputTokens += response.usage.outputTokens;
+    const toolUses = response.content.filter(
+      (c) => c.type === "tool_use"
+    );
+    if (toolUses.length === 0) {
+      state.finalContent = extractFinalText(response.content);
+      return { kind: "stop", reason: "agent-stopped" };
+    }
+    state.messages.push({ role: "assistant", content: response.content });
+    return this.processToolCalls(args, state, toolUses, response, modelLatencyMs);
+  }
+  async processToolCalls(args, state, toolUses, response, modelLatencyMs) {
+    if (this.profile.parallelToolCalls && toolUses.length > 1) {
+      return this.processToolCallsParallel(args, state, toolUses, response, modelLatencyMs);
+    }
+    return this.processToolCallsSequential(args, state, toolUses, response, modelLatencyMs);
+  }
+  async processToolCallsSequential(args, state, toolUses, response, modelLatencyMs) {
+    const toolResultBlocks = [];
+    for (const toolUse of toolUses) {
+      if (state.turns.length >= args.turnBudget) break;
+      const outcome = await this.invokeToolAndRecord(
+        args,
+        state,
+        toolUse,
+        response,
+        modelLatencyMs
+      );
+      if (outcome.kind === "stop") return outcome;
+      toolResultBlocks.push(outcome.toolResultBlock);
+    }
+    if (toolResultBlocks.length > 0) {
+      state.messages.push({ role: "user", content: toolResultBlocks });
+    }
+    return { kind: "continue" };
+  }
+  /**
+   * Profile-driven parallel tool execution. Used when
+   * `profile.parallelToolCalls === true` AND the model emitted >1
+   * tool_use block in a single turn.
+   *
+   * Each tool call still produces its own `AgentTurn`; turn-budget
+   * applies to the post-completion count (we don't pre-cap the
+   * Promise.all because the model already issued all calls — better
+   * to record everything and let the next turn be the budget breaker).
+   */
+  async processToolCallsParallel(args, state, toolUses, response, modelLatencyMs) {
+    const startIndex = state.turns.length;
+    const promises2 = toolUses.map(
+      (toolUse, offset) => this.invokeToolForParallel(args, toolUse, response, modelLatencyMs, startIndex + offset)
+    );
+    const outcomes = await Promise.all(promises2);
+    const toolResultBlocks = [];
+    for (const outcome of outcomes) {
+      if (outcome.kind === "stop-tool-error") {
+        state.turns.push(outcome.turn);
+        args.onTurn?.(outcome.turn);
+        return { kind: "stop", reason: "tool-error" };
+      }
+      state.turns.push(outcome.turn);
+      args.onTurn?.(outcome.turn);
+      toolResultBlocks.push(outcome.toolResultBlock);
+    }
+    if (toolResultBlocks.length > 0) {
+      state.messages.push({ role: "user", content: toolResultBlocks });
+    }
+    return { kind: "continue" };
+  }
+  /**
+   * Per-call wrapper used by parallel execution. Returns a captured
+   * outcome (turn + result-block, OR turn + tool-error flag) without
+   * touching shared state — `processToolCallsParallel` reduces the
+   * outcomes deterministically afterwards.
+   */
+  async invokeToolForParallel(args, toolUse, response, modelLatencyMs, turnIndex) {
+    const toolCall = {
+      id: toolUse.id,
+      name: toolUse.name,
+      arguments: toolUse.input
+    };
+    const tt0 = Date.now();
+    try {
+      const toolResult = await args.onToolCall(toolCall);
+      const turn = buildTurn({
+        turnIndex,
+        toolCall,
+        toolResult,
+        modelLatencyMs,
+        toolLatencyMs: Date.now() - tt0,
+        response
+      });
+      return {
+        kind: "recorded",
+        turn,
+        toolResultBlock: {
+          type: "tool_result",
+          tool_use_id: toolUse.id,
+          content: toolResult.content,
+          ...toolResult.isError === true && { is_error: true }
+        }
+      };
+    } catch (caught) {
+      const turn = buildTurn({
+        turnIndex,
+        toolCall,
+        toolResult: {
+          content: caught instanceof Error ? caught.message : String(caught),
+          isError: true
+        },
+        modelLatencyMs,
+        toolLatencyMs: Date.now() - tt0,
+        response
+      });
+      return { kind: "stop-tool-error", turn };
+    }
+  }
+  async invokeToolAndRecord(args, state, toolUse, response, modelLatencyMs) {
+    const toolCall = {
+      id: toolUse.id,
+      name: toolUse.name,
+      arguments: toolUse.input
+    };
+    const tt0 = Date.now();
+    try {
+      const toolResult = await args.onToolCall(toolCall);
+      return recordToolSuccess({
+        args,
+        state,
+        toolUse,
+        toolCall,
+        toolResult,
+        modelLatencyMs,
+        toolLatencyMs: Date.now() - tt0,
+        response
+      });
+    } catch (caught) {
+      const errTurn = buildTurn({
+        turnIndex: state.turns.length,
+        toolCall,
+        toolResult: {
+          content: caught instanceof Error ? caught.message : String(caught),
+          isError: true
+        },
+        modelLatencyMs,
+        toolLatencyMs: Date.now() - tt0,
+        response
+      });
+      state.turns.push(errTurn);
+      args.onTurn?.(errTurn);
+      return { kind: "stop", reason: "tool-error" };
+    }
+  }
+  buildFromState(state, stopReason) {
+    return this.buildResult(
+      state.turns,
+      state.totalInputTokens,
+      state.totalOutputTokens,
+      stopReason,
+      state.finalContent
+    );
+  }
+  /**
+   * Wrap `model.complete` in an optional concurrency gate. The
+   * semaphore is held only across the model API call — released
+   * before tool execution so harnesses doing slow tool calls don't
+   * starve other concurrent `runAgent` calls.
+   */
+  async callModelGated(request) {
+    if (this.semaphore === null) {
+      return this.model.complete(request);
+    }
+    await this.semaphore.acquire();
+    try {
+      return await this.model.complete(request);
+    } finally {
+      this.semaphore.release();
+    }
+  }
+  buildResult(turns, totalInputTokens, totalOutputTokens, stopReason, finalContent) {
+    return {
+      turnsUsed: turns.length,
+      stopReason,
+      turns,
+      ...totalInputTokens > 0 && { totalInputTokens },
+      ...totalOutputTokens > 0 && { totalOutputTokens },
+      providerId: this.providerId,
+      modelId: this.modelId,
+      adapterStrategy: this.adapterStrategy,
+      finalContent
+    };
+  }
+};
+function stampStrategy(identity) {
+  return identity.vendor === "unknown" ? "wrapper" : `native:${identity.vendor}`;
+}
+function recordToolSuccess(p) {
+  const turn = buildTurn({
+    turnIndex: p.state.turns.length,
+    toolCall: p.toolCall,
+    toolResult: p.toolResult,
+    modelLatencyMs: p.modelLatencyMs,
+    toolLatencyMs: p.toolLatencyMs,
+    response: p.response
+  });
+  p.state.turns.push(turn);
+  p.args.onTurn?.(turn);
+  return {
+    kind: "recorded",
+    toolResultBlock: {
+      type: "tool_result",
+      tool_use_id: p.toolUse.id,
+      content: p.toolResult.content,
+      ...p.toolResult.isError === true && { is_error: true }
+    }
+  };
+}
+function buildTurn(b) {
+  return {
+    turnIndex: b.turnIndex,
+    toolCall: b.toolCall,
+    toolResult: b.toolResult,
+    modelLatencyMs: b.modelLatencyMs,
+    toolLatencyMs: b.toolLatencyMs,
+    inputTokens: b.response.usage.inputTokens,
+    outputTokens: b.response.usage.outputTokens
+  };
+}
+function extractFinalText(content) {
+  return content.filter((c) => c.type === "text").map((c) => c.text).join("\n").trim();
+}
+var Semaphore = class {
+  waiters = [];
+  available;
+  constructor(capacity) {
+    this.available = capacity;
+  }
+  acquire() {
+    if (this.available > 0) {
+      this.available -= 1;
+      return Promise.resolve();
+    }
+    return new Promise((resolve19) => {
+      this.waiters.push(resolve19);
+    });
+  }
+  release() {
+    const next = this.waiters.shift();
+    if (next !== void 0) {
+      next();
+      return;
+    }
+    this.available += 1;
+  }
+};
+
+// src/agents/agentic/factory.ts
+function createAgenticAdapter(modelAdapter, options = {}) {
+  return new AgenticAdapter(modelAdapter, options);
+}
+
 // src/agents/reasoning/forest-node-types.ts
 import { z as z20 } from "zod";
 var NodeStateSchema = z20.enum(["pending", "active", "completed", "pruned", "error"]);
@@ -49406,6 +50133,8 @@ export {
   SkillLoader,
   createSkillLoader,
   loadAllExternalPacks,
+  AgenticAdapter,
+  createAgenticAdapter,
   NodeStateSchema,
   ReasoningStepTypeSchema,
   ReasoningNodeMetadataSchema,
@@ -49816,4 +50545,4 @@ export {
   detectBackend,
   createTaskTracker
 };
-//# sourceMappingURL=chunk-3HR6UJ2E.js.map
+//# sourceMappingURL=chunk-J4VR2WNI.js.map