@cuylabs/agent-core 4.8.1 → 4.10.0

package/dist/chunk-AAGKWUXR.js

@@ -0,0 +1,539 @@
+// src/context/text/truncation.ts
+var graphemeSegmenter;
+function getGraphemeSegmenter() {
+  if (graphemeSegmenter !== void 0) {
+    return graphemeSegmenter ?? void 0;
+  }
+  const Segmenter = Intl.Segmenter;
+  graphemeSegmenter = Segmenter ? new Segmenter(void 0, { granularity: "grapheme" }) : null;
+  return graphemeSegmenter ?? void 0;
+}
+function normalizeLimit(maxChars) {
+  if (maxChars === void 0 || !Number.isFinite(maxChars) || maxChars <= 0) {
+    return void 0;
+  }
+  return Math.floor(maxChars);
+}
+function needsGraphemeSafeSlice(text) {
+  for (let i = 0; i < text.length; i++) {
+    const charCode = text.charCodeAt(i);
+    if (isSurrogate(charCode) || isCombiningMark(charCode) || charCode === 8205 || charCode === 65038 || charCode === 65039) {
+      return true;
+    }
+  }
+  return false;
+}
+function isSurrogate(charCode) {
+  return charCode >= 55296 && charCode <= 57343;
+}
+function isCombiningMark(charCode) {
+  return charCode >= 768 && charCode <= 879 || charCode >= 6832 && charCode <= 6911 || charCode >= 7616 && charCode <= 7679 || charCode >= 8400 && charCode <= 8447 || charCode >= 65056 && charCode <= 65071;
+}
+function slicePrefixAtGraphemeBoundary(text, maxChars) {
+  if (text.length <= maxChars) return text;
+  if (!needsGraphemeSafeSlice(text)) return text.slice(0, maxChars);
+  const segmenter = getGraphemeSegmenter();
+  if (segmenter) {
+    let end2 = 0;
+    for (const part of segmenter.segment(text)) {
+      const nextEnd = part.index + part.segment.length;
+      if (nextEnd > maxChars) break;
+      end2 = nextEnd;
+    }
+    return text.slice(0, end2);
+  }
+  let end = 0;
+  for (const char of text) {
+    const nextEnd = end + char.length;
+    if (nextEnd > maxChars) break;
+    end = nextEnd;
+  }
+  return text.slice(0, end);
+}
+function sliceSuffixAtGraphemeBoundary(text, maxChars) {
+  if (maxChars <= 0) return "";
+  if (text.length <= maxChars) return text;
+  if (!needsGraphemeSafeSlice(text)) return text.slice(-maxChars);
+  const segmenter = getGraphemeSegmenter();
+  if (segmenter) {
+    let start2 = text.length;
+    for (const part of segmenter.segment(text)) {
+      if (text.length - part.index <= maxChars) {
+        start2 = part.index;
+        break;
+      }
+    }
+    return text.slice(start2);
+  }
+  let used = 0;
+  let start = text.length;
+  const chars = Array.from(text);
+  for (let i = chars.length - 1; i >= 0; i--) {
+    const char = chars[i];
+    const nextUsed = used + char.length;
+    if (nextUsed > maxChars) break;
+    used = nextUsed;
+    start -= char.length;
+  }
+  return text.slice(start);
+}
+function findLastBoundary(content, pattern, options = {}) {
+  let best = -1;
+  let match;
+  while ((match = pattern.exec(content)) !== null) {
+    const end = match.index + match[0].length;
+    if (options.after !== void 0 && end < options.after) continue;
+    best = end;
+  }
+  return best;
+}
+function sliceAtPreferredPrefixBoundary(text, limit, boundary) {
+  const prefix = slicePrefixAtGraphemeBoundary(text, limit);
+  if (boundary === "grapheme") return prefix;
+  const wordBoundary = () => findLastBoundary(prefix, /\s+/g);
+  if (boundary === "word") {
+    const index2 = wordBoundary();
+    return index2 > 0 ? prefix.slice(0, index2) : prefix;
+  }
+  const boundarySearchStart = Math.floor(prefix.length * 0.65);
+  const paragraphBoundary = findLastBoundary(prefix, /\n\s*\n/g, {
+    after: boundarySearchStart
+  });
+  if (paragraphBoundary > 0) return prefix.slice(0, paragraphBoundary);
+  const sentenceBoundary = findLastBoundary(prefix, /[.!?](?:\s+|$)/g, {
+    after: boundarySearchStart
+  });
+  if (sentenceBoundary > 0) return prefix.slice(0, sentenceBoundary);
+  const index = wordBoundary();
+  return index > 0 ? prefix.slice(0, index) : prefix;
+}
+function truncateTextPrefix(text, maxChars, options = {}) {
+  const limit = normalizeLimit(maxChars);
+  if (limit === void 0 || text.length <= limit) return text;
+  const marker = options.marker ?? "[truncated]";
+  const separator = options.separator ?? "\n";
+  const boundary = options.boundary ?? "semantic";
+  const prefix = sliceAtPreferredPrefixBoundary(
+    text,
+    limit,
+    boundary
+  ).trimEnd();
+  if (prefix.length === 0) return marker;
+  return `${prefix}${separator}${marker}`;
+}
+function truncateTextMiddle(text, maxChars, options = {}) {
+  const limit = normalizeLimit(maxChars);
+  if (limit === void 0 || text.length <= limit) return text;
+  const markerFor = options.marker ?? ((omittedChars) => `
+
+[...${omittedChars} characters omitted...]
+
+`);
+  const headRatio = Math.min(0.9, Math.max(0.1, options.headRatio ?? 0.5));
+  let marker = markerFor(Math.max(0, text.length - limit));
+  for (let attempt = 0; attempt < 3; attempt++) {
+    const available2 = limit - marker.length;
+    if (available2 <= 0) return marker;
+    const headChars2 = Math.max(1, Math.floor(available2 * headRatio));
+    const tailChars2 = Math.max(0, available2 - headChars2);
+    const head = slicePrefixAtGraphemeBoundary(text, headChars2);
+    const tail = sliceSuffixAtGraphemeBoundary(text, tailChars2);
+    const omittedChars = Math.max(0, text.length - head.length - tail.length);
+    const nextMarker = markerFor(omittedChars);
+    if (nextMarker.length === marker.length) {
+      return `${head}${nextMarker}${tail}`;
+    }
+    marker = nextMarker;
+  }
+  const available = limit - marker.length;
+  if (available <= 0) return marker;
+  const headChars = Math.max(1, Math.floor(available * headRatio));
+  const tailChars = Math.max(0, available - headChars);
+  return `${slicePrefixAtGraphemeBoundary(
+    text,
+    headChars
+  )}${marker}${sliceSuffixAtGraphemeBoundary(text, tailChars)}`;
+}
+
+// src/context/fragments/render.ts
+var AGENT_CONTEXT_FRAGMENT_TAG = "agent-context-fragment";
+var AGENT_CONTEXT_FRAGMENT_OPEN = `<${AGENT_CONTEXT_FRAGMENT_TAG}`;
+var AGENT_CONTEXT_FRAGMENT_CLOSE = `</${AGENT_CONTEXT_FRAGMENT_TAG}>`;
+function normalizeCreatedAt(value) {
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "string" && value.trim().length > 0) return value;
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function normalizeAgentContextFragment(input) {
+  const content = truncateTextPrefix(input.content.trim(), input.maxChars);
+  const createdAt = normalizeCreatedAt(input.createdAt);
+  return {
+    content,
+    metadata: {
+      id: input.id ?? crypto.randomUUID(),
+      kind: input.kind,
+      role: input.role ?? "user",
+      placement: input.placement ?? "after-latest-user",
+      lifetime: input.lifetime ?? "turn",
+      createdAt,
+      ...input.source ? { source: input.source } : {},
+      ...input.title ? { title: input.title } : {},
+      ...input.dedupeKey ? { dedupeKey: input.dedupeKey } : {},
+      ...input.budgetBehavior ? { budgetBehavior: input.budgetBehavior } : {},
+      ...input.metadata ? { metadata: structuredClone(input.metadata) } : {}
+    }
+  };
+}
+function escapeAttribute(value) {
+  return value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\n", " ").replaceAll("\r", " ").replaceAll("	", " ");
+}
+function unescapeAttribute(value) {
+  return value.replaceAll("&quot;", '"').replaceAll("&gt;", ">").replaceAll("&lt;", "<").replaceAll("&amp;", "&");
+}
+function renderAgentContextFragment(options) {
+  const attrs = [
+    ["id", options.metadata.id],
+    ["kind", options.metadata.kind],
+    ["role", options.metadata.role],
+    ["placement", options.metadata.placement],
+    ["lifetime", options.metadata.lifetime],
+    ["created-at", options.metadata.createdAt],
+    ["source", options.metadata.source],
+    ["title", options.metadata.title],
+    ["dedupe-key", options.metadata.dedupeKey],
+    ["budget-behavior", options.metadata.budgetBehavior]
+  ];
+  const renderedAttrs = attrs.filter((attr) => attr[1] !== void 0).map(([key, value]) => `${key}="${escapeAttribute(value)}"`).join(" ");
+  return `${AGENT_CONTEXT_FRAGMENT_OPEN} ${renderedAttrs}>
+${options.content}
+${AGENT_CONTEXT_FRAGMENT_CLOSE}`;
+}
+function isRenderedAgentContextFragment(content) {
+  const trimmed = content.trim();
+  return trimmed.startsWith(AGENT_CONTEXT_FRAGMENT_OPEN) && trimmed.endsWith(AGENT_CONTEXT_FRAGMENT_CLOSE);
+}
+function parseRenderedAgentContextFragment(content) {
+  const trimmed = content.trim();
+  if (!isRenderedAgentContextFragment(trimmed)) return void 0;
+  const openEnd = trimmed.indexOf(">");
+  if (openEnd < 0) return void 0;
+  const openTag = trimmed.slice(0, openEnd + 1);
+  const attrs = /* @__PURE__ */ new Map();
+  const attrPattern = /([a-zA-Z0-9_-]+)="([^"]*)"/g;
+  let match;
+  while ((match = attrPattern.exec(openTag)) !== null) {
+    attrs.set(match[1], unescapeAttribute(match[2]));
+  }
+  const id = attrs.get("id");
+  const kind = attrs.get("kind");
+  const role = attrs.get("role");
+  const placement = attrs.get("placement");
+  const lifetime = attrs.get("lifetime");
+  const createdAt = attrs.get("created-at");
+  const budgetBehavior = attrs.get("budget-behavior");
+  if (!id || !kind || !createdAt || role !== "system" && role !== "user" || placement !== "before-history" && placement !== "after-latest-user" && placement !== "after-history" || lifetime !== "turn" && lifetime !== "session" || budgetBehavior !== void 0 && budgetBehavior !== "required" && budgetBehavior !== "droppable") {
+    return void 0;
+  }
+  return {
+    id,
+    kind,
+    role,
+    placement,
+    lifetime,
+    createdAt,
+    ...attrs.get("source") ? { source: attrs.get("source") } : {},
+    ...attrs.get("title") ? { title: attrs.get("title") } : {},
+    ...attrs.get("dedupe-key") ? { dedupeKey: attrs.get("dedupe-key") } : {},
+    ...budgetBehavior ? { budgetBehavior } : {}
+  };
+}
+
+// src/context/window/estimation.ts
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function stringifyStructuredValue(value) {
+  if (typeof value === "string") return value;
+  if (value === void 0) return "";
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function estimateInternalToolCalls(message) {
+  if (message.role !== "assistant" || !("toolCalls" in message) || !Array.isArray(message.toolCalls)) {
+    return 0;
+  }
+  return message.toolCalls.reduce((total, toolCall) => {
+    return total + estimateTokens(toolCall.toolName) + estimateTokens(toolCall.toolCallId) + estimateTokens(stringifyStructuredValue(toolCall.args));
+  }, 0);
+}
+function estimateMessageTokens(message) {
+  const toolCallTokens = estimateInternalToolCalls(message);
+  if (typeof message.content === "string") {
+    return estimateTokens(message.content) + toolCallTokens;
+  }
+  if (Array.isArray(message.content)) {
+    let total = 0;
+    for (const part of message.content) {
+      if (typeof part === "string") {
+        total += estimateTokens(part);
+      } else if ("text" in part && typeof part.text === "string") {
+        total += estimateTokens(part.text);
+      } else if ("type" in part && part.type === "image") {
+        total += 765;
+      }
+    }
+    return total + toolCallTokens;
+  }
+  return toolCallTokens;
+}
+function estimateMessageWithOverhead(message) {
+  return estimateMessageTokens(message) + 4;
+}
+function estimateFromRecentUsage(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (message.role !== "assistant" || !("tokens" in message) || !message.tokens) {
+      continue;
+    }
+    const inputTokens = message.tokens.inputTokens;
+    if (inputTokens === void 0) {
+      continue;
+    }
+    const usageTokens = Math.max(
+      inputTokens + (message.tokens.outputTokens ?? 0),
+      message.tokens.totalTokens ?? 0
+    );
+    const trailingTokens = messages.slice(i + 1).reduce((total, trailingMessage) => {
+      return total + estimateMessageWithOverhead(trailingMessage);
+    }, 0);
+    return usageTokens + trailingTokens;
+  }
+  return void 0;
+}
+function estimateConversationTokens(messages) {
+  const heuristic = messages.reduce((total, message) => {
+    return total + estimateMessageWithOverhead(message);
+  }, 0);
+  const usageEstimate = estimateFromRecentUsage(messages);
+  return Math.max(heuristic, usageEstimate ?? 0);
+}
+
+// src/context/fragments/messages.ts
+function uniqueSorted(values) {
+  return [...new Set(values)].sort();
+}
+function createAgentContextFragmentMessage(input) {
+  const contextFragment = normalizeAgentContextFragment(input);
+  const content = renderAgentContextFragment(contextFragment);
+  return {
+    id: contextFragment.metadata.id,
+    role: contextFragment.metadata.role,
+    content,
+    createdAt: new Date(contextFragment.metadata.createdAt),
+    contextFragment: contextFragment.metadata
+  };
+}
+function getAgentContextFragmentMetadata(message) {
+  if (message.contextFragment) return message.contextFragment;
+  if ((message.role === "system" || message.role === "user") && typeof message.content === "string") {
+    return parseRenderedAgentContextFragment(message.content);
+  }
+  return void 0;
+}
+function isAgentContextFragmentMessage(message) {
+  return getAgentContextFragmentMetadata(message) !== void 0;
+}
+function collectExistingDedupeKeys(messages) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const message of messages) {
+    const metadata = getAgentContextFragmentMetadata(message);
+    if (metadata?.dedupeKey) {
+      keys.add(metadata.dedupeKey);
+    }
+  }
+  return keys;
+}
+function findLatestRealUserMessageIndex(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (message.role === "user" && !isAgentContextFragmentMessage(message)) {
+      return i;
+    }
+  }
+  return -1;
+}
+function incrementSkipped(skippedByReason, reason) {
+  skippedByReason[reason] = (skippedByReason[reason] ?? 0) + 1;
+}
+function contextFragmentBudgetBehavior(message) {
+  return message.contextFragment?.budgetBehavior ?? "droppable";
+}
+function applyContextFragmentBudget(candidates, budget, skippedByReason) {
+  const requestedEstimatedTokens = candidates.reduce(
+    (total, candidate) => total + candidate.estimatedTokenCount,
+    0
+  );
+  if (!budget) {
+    return void 0;
+  }
+  const maxEstimatedTokens = Math.max(0, Math.floor(budget.maxEstimatedTokens));
+  if (requestedEstimatedTokens <= maxEstimatedTokens) {
+    return {
+      selected: candidates,
+      report: {
+        applied: true,
+        maxEstimatedTokens,
+        requestedEstimatedTokens,
+        insertedEstimatedTokens: requestedEstimatedTokens,
+        skippedEstimatedTokens: 0
+      }
+    };
+  }
+  const selectedIds = /* @__PURE__ */ new Set();
+  let insertedEstimatedTokens = 0;
+  let skippedEstimatedTokens = 0;
+  const choose = (budgetBehavior) => {
+    for (const candidate of candidates) {
+      if (candidate.budgetBehavior !== budgetBehavior) continue;
+      const nextEstimatedTokens = insertedEstimatedTokens + candidate.estimatedTokenCount;
+      const mustKeep = budgetBehavior === "required";
+      if (mustKeep || nextEstimatedTokens <= maxEstimatedTokens) {
+        selectedIds.add(candidate.message.id);
+        insertedEstimatedTokens = nextEstimatedTokens;
+        continue;
+      }
+      skippedEstimatedTokens += candidate.estimatedTokenCount;
+      incrementSkipped(skippedByReason, "budget-exceeded");
+    }
+  };
+  choose("required");
+  choose("droppable");
+  const selected = candidates.filter(
+    (candidate) => selectedIds.has(candidate.message.id)
+  );
+  return {
+    selected,
+    report: {
+      applied: true,
+      maxEstimatedTokens,
+      requestedEstimatedTokens,
+      insertedEstimatedTokens,
+      skippedEstimatedTokens
+    }
+  };
+}
+function applyAgentContextFragmentsWithReport(messages, contextFragments = [], options = {}) {
+  const existingDedupeKeys = collectExistingDedupeKeys(messages);
+  const seenIncomingDedupeKeys = /* @__PURE__ */ new Set();
+  const skippedDedupeKeys = [];
+  const skippedByReason = {};
+  const candidates = [];
+  for (const [inputIndex, contextFragment] of contextFragments.entries()) {
+    if (contextFragment.content.trim().length === 0) {
+      incrementSkipped(skippedByReason, "empty");
+      continue;
+    }
+    const message = createAgentContextFragmentMessage(contextFragment);
+    const dedupeKey = message.contextFragment?.dedupeKey;
+    if (dedupeKey && existingDedupeKeys.has(dedupeKey)) {
+      incrementSkipped(skippedByReason, "duplicate-existing");
+      skippedDedupeKeys.push(dedupeKey);
+      continue;
+    }
+    if (dedupeKey && seenIncomingDedupeKeys.has(dedupeKey)) {
+      incrementSkipped(skippedByReason, "duplicate-incoming");
+      skippedDedupeKeys.push(dedupeKey);
+      continue;
+    }
+    if (dedupeKey) {
+      seenIncomingDedupeKeys.add(dedupeKey);
+    }
+    candidates.push({
+      inputIndex,
+      message,
+      budgetBehavior: contextFragmentBudgetBehavior(message),
+      estimatedTokenCount: estimateConversationTokens([message])
+    });
+  }
+  const budgeted = applyContextFragmentBudget(
+    candidates,
+    options.budget,
+    skippedByReason
+  );
+  const selectedCandidates = budgeted?.selected ?? candidates;
+  const selectedMessages = selectedCandidates.sort((left, right) => left.inputIndex - right.inputIndex).map((candidate) => candidate.message);
+  const beforeHistory = [];
+  const afterLatestUser = [];
+  const afterHistory = [];
+  for (const message of selectedMessages) {
+    switch (message.contextFragment?.placement) {
+      case "before-history":
+        beforeHistory.push(message);
+        break;
+      case "after-history":
+        afterHistory.push(message);
+        break;
+      case "after-latest-user":
+      default:
+        afterLatestUser.push(message);
+        break;
+    }
+  }
+  const baseMessages = [...messages];
+  const latestUserIndex = findLatestRealUserMessageIndex(baseMessages);
+  const insertAt = latestUserIndex >= 0 ? latestUserIndex + 1 : baseMessages.length;
+  const assembledMessages = [
+    ...beforeHistory,
+    ...baseMessages.slice(0, insertAt),
+    ...afterLatestUser,
+    ...baseMessages.slice(insertAt),
+    ...afterHistory
+  ];
+  const insertedCount = beforeHistory.length + afterLatestUser.length + afterHistory.length;
+  const report = {
+    requestedCount: contextFragments.length,
+    insertedCount,
+    skippedCount: Math.max(0, contextFragments.length - insertedCount),
+    skippedByReason,
+    insertedKinds: uniqueSorted(
+      selectedMessages.map((message) => message.contextFragment?.kind).filter((kind) => kind !== void 0)
+    ),
+    insertedPlacements: uniqueSorted(
+      selectedMessages.map((message) => message.contextFragment?.placement).filter(
+        (placement) => placement !== void 0
+      )
+    ),
+    insertedDedupeKeys: uniqueSorted(
+      selectedMessages.map((message) => message.contextFragment?.dedupeKey).filter((key) => key !== void 0)
+    ),
+    skippedDedupeKeys: uniqueSorted(skippedDedupeKeys),
+    ...budgeted?.report ? { budget: budgeted.report } : {}
+  };
+  return { messages: assembledMessages, report };
+}
+function applyAgentContextFragments(messages, contextFragments = []) {
+  return applyAgentContextFragmentsWithReport(messages, contextFragments).messages;
+}
+
+export {
+  truncateTextPrefix,
+  truncateTextMiddle,
+  AGENT_CONTEXT_FRAGMENT_TAG,
+  AGENT_CONTEXT_FRAGMENT_OPEN,
+  AGENT_CONTEXT_FRAGMENT_CLOSE,
+  normalizeAgentContextFragment,
+  renderAgentContextFragment,
+  isRenderedAgentContextFragment,
+  parseRenderedAgentContextFragment,
+  estimateTokens,
+  estimateMessageTokens,
+  estimateConversationTokens,
+  createAgentContextFragmentMessage,
+  getAgentContextFragmentMetadata,
+  isAgentContextFragmentMessage,
+  applyAgentContextFragmentsWithReport,
+  applyAgentContextFragments
+};

package/dist/chunk-AHDCR7SX.js

@@ -0,0 +1,83 @@
+// src/execution/scope/store.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { randomUUID } from "crypto";
+var scopeStore = new AsyncLocalStorage();
+function cloneAttributes(attributes) {
+  return { ...attributes };
+}
+function cloneScope(scope) {
+  return {
+    ...scope,
+    attributes: cloneAttributes(scope.attributes)
+  };
+}
+function getStoredScope() {
+  return scopeStore.getStore();
+}
+function buildScope(options, current) {
+  const parent = options.parent === void 0 ? current : options.parent ?? void 0;
+  const id = options.id ?? randomUUID();
+  return {
+    id,
+    rootId: parent?.rootId ?? id,
+    kind: options.kind,
+    name: options.name,
+    parentId: parent?.id,
+    depth: (parent?.depth ?? -1) + 1,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    sessionId: options.sessionId ?? parent?.sessionId,
+    taskId: options.taskId ?? parent?.taskId,
+    step: options.step ?? parent?.step,
+    attributes: cloneAttributes(options.attributes ?? {})
+  };
+}
+function runWithScope(scope, fn) {
+  return Promise.resolve(scopeStore.run(scope, fn));
+}
+
+// src/execution/scope/run.ts
+function currentScope() {
+  const scope = getStoredScope();
+  return scope ? cloneScope(scope) : void 0;
+}
+function snapshotScope(scope = getStoredScope()) {
+  return scope ? cloneScope(scope) : void 0;
+}
+function withinScope(options, fn) {
+  return runWithScope(buildScope(options, getStoredScope()), fn);
+}
+function restoreScope(snapshot, fn) {
+  if (!snapshot) {
+    return Promise.resolve(fn());
+  }
+  return runWithScope(cloneScope(snapshot), fn);
+}
+async function* streamWithinScope(options, iterable) {
+  const scope = buildScope(options, getStoredScope());
+  const iterator = await runWithScope(
+    scope,
+    () => iterable[Symbol.asyncIterator]()
+  );
+  try {
+    while (true) {
+      const next = await runWithScope(scope, () => iterator.next());
+      if (next.done) {
+        return next.value;
+      }
+      yield next.value;
+    }
+  } finally {
+    const returnFn = iterator.return?.bind(iterator);
+    if (returnFn) {
+      await runWithScope(scope, () => returnFn(void 0));
+    }
+  }
+}
+
+export {
+  currentScope,
+  snapshotScope,
+  withinScope,
+  restoreScope,
+  streamWithinScope
+};

package/dist/{chunk-CSR75JVC.js → chunk-ASXF5AC6.js}

@@ -1,6 +1,6 @@
 import {
   Tool
-} from "./chunk-Q742PSH3.js";
+} from "./chunk-MJML3A2F.js";
 
 // src/skill/tools.ts
 import { z } from "zod";

package/dist/{chunk-2TTOLHBT.js → chunk-CFBSQLP5.js}

@@ -1,4 +1,4 @@
-// src/events/local.ts
+// src/events/event-bus/local.ts
 function createEventBus(options = {}) {
   const channels = /* @__PURE__ */ new Map();
   const maxHistoryMessages = Math.max(1, options.maxHistoryMessages ?? 1024);

package/dist/{chunk-GJFP5L2V.js → chunk-CNM6OROH.js}

@@ -910,7 +910,13 @@ function shouldIncludeReasoningSummary() {
 // src/models/reasoning/providers.ts
 function buildOpenAIOptions(level, compat) {
   if (level === "off") return void 0;
-  const options = {};
+  const options = {
+    // The OpenAI SDK only enables reasoning options for model IDs it recognizes.
+    // We may intentionally run OpenAI-compatible gateways or prefixed IDs such
+    // as "openai/gpt-5.4", so force the SDK's reasoning path once our resolver
+    // has already classified the model as reasoning-capable.
+    forceReasoning: true
+  };
   if (compat?.supportsReasoningEffort !== false) {
     options.reasoningEffort = level;
   }
@@ -1128,7 +1134,10 @@ function getReasoningConfigSync(model) {
     getProviderOptions: (level) => {
       if (level === "off") return void 0;
       if (isOpenAI) {
-        const opts = { reasoningEffort: level };
+        const opts = {
+          forceReasoning: true,
+          reasoningEffort: level
+        };
         if (shouldIncludeReasoningSummary()) opts.reasoningSummary = "auto";
         return opts;
       }
@@ -1138,7 +1147,10 @@ function getReasoningConfigSync(model) {
       if (isBedrock) return buildBedrockOptions(level, modelId);
       if (isGroq) return buildGroqOptions(level);
       if (isOpenRouter) return buildOpenRouterOptions(level);
-      const defaultOpts = { reasoningEffort: level };
+      const defaultOpts = {
+        forceReasoning: true,
+        reasoningEffort: level
+      };
       if (shouldIncludeReasoningSummary())
         defaultOpts.reasoningSummary = "auto";
       return defaultOpts;