@nyte-ai/ai 0.0.0-stage → 0.0.19

package/dist/chunks/account-limits-cache-75smws02.js

@@ -0,0 +1,213 @@
+import {
+  getProviderEnvValue2
+} from "./account-limits-cache-b23sbrke.js";
+import {
+  ANTHROPIC_FEDERATION_RULE_ID_ENV2,
+  ANTHROPIC_ORGANIZATION_ID_ENV2,
+  ANTHROPIC_SERVICE_ACCOUNT_ID_ENV2,
+  ANTHROPIC_IDENTITY_TOKEN_FILE_ENV2,
+  ANTHROPIC_WORKSPACE_ID_ENV2
+} from "./account-limits-cache-hyzn1jmk.js";
+import {
+  mergeProviderHeaders2,
+  hasHeader2
+} from "./account-limits-cache-ag5b8dja.js";
+import {
+  getNyteUserAgent2
+} from "./account-limits-cache-gknnm1kv.js";
+import {
+  getCurrentTools2
+} from "./account-limits-cache-6250ykn6.js";
+import {
+  claudeCodeVersion2,
+  usesClaudeSubscription2
+} from "./account-limits-cache-ks1sjym9.js";
+
+// src/api/anthropic-client.ts
+import Anthropic from "@anthropic-ai/sdk";
+var FINE_GRAINED_TOOL_STREAMING_BETA = "fine-grained-tool-streaming-2025-05-14";
+var FAST_MODE_BETA2 = "fast-mode-2026-02-01";
+var INTERLEAVED_THINKING_BETA = "interleaved-thinking-2025-05-14";
+var SERVER_SIDE_FALLBACK_BETA = "server-side-fallback-2026-07-01";
+var MID_CONVERSATION_TOOL_CHANGES_BETA2 = "mid-conversation-tool-changes-2026-07-01";
+function shouldUseServerSideFallbackBeta2(model) {
+  return (model.compat?.allowedFallbackModels?.length ?? 0) > 0;
+}
+function getAnthropicCompat2(model) {
+  return {
+    supportsEagerToolInputStreaming: model.compat?.supportsEagerToolInputStreaming ?? true,
+    supportsLongCacheRetention: model.compat?.supportsLongCacheRetention ?? true,
+    sendSessionAffinityHeaders: model.compat?.sendSessionAffinityHeaders ?? false,
+    supportsCacheControlOnTools: model.compat?.supportsCacheControlOnTools ?? true,
+    supportsTemperature: model.compat?.supportsTemperature ?? true,
+    allowEmptySignature: model.compat?.allowEmptySignature ?? false,
+    supportsStrictTools: model.compat?.supportsStrictTools ?? false,
+    supportsMidConvoSystemMessages: model.compat?.supportsMidConvoSystemMessages ?? false,
+    supportsMidConvoToolChanges: model.compat?.supportsMidConvoToolChanges ?? false,
+    supportsToolReferences: model.compat?.supportsToolReferences ?? defaultSupportsToolReferences(model)
+  };
+}
+function defaultSupportsToolReferences(model) {
+  if (model.provider !== "anthropic" || model.id.includes("haiku"))
+    return false;
+  const version = model.id.match(/^claude-(?:opus|sonnet|fable)-(\d+)(?:-(\d+))?(?:-|$)/);
+  if (!version)
+    return false;
+  const major = Number(version[1]);
+  const minor = version[2] && version[2].length < 8 ? Number(version[2]) : 0;
+  return major > 4 || major === 4 && minor >= 5;
+}
+function mergeAnthropicHeaders2(...headerSources) {
+  const merged = mergeProviderHeaders2(...headerSources);
+  for (const name of Object.keys(merged)) {
+    if (name.toLowerCase() === "anthropic-beta")
+      delete merged[name];
+  }
+  for (const headers of headerSources) {
+    for (const [name, value] of Object.entries(headers ?? {})) {
+      if (name.toLowerCase() === "anthropic-beta")
+        merged[name] = value;
+    }
+  }
+  return merged;
+}
+function appendAnthropicBeta2(headers, beta) {
+  if (!beta)
+    return headers;
+  const values = [];
+  for (const [name, value] of Object.entries(headers)) {
+    if (name.toLowerCase() !== "anthropic-beta")
+      continue;
+    delete headers[name];
+    if (value === null)
+      continue;
+    for (const entry of value.split(",")) {
+      const normalized = entry.trim();
+      if (normalized && !values.includes(normalized))
+        values.push(normalized);
+    }
+  }
+  if (!values.includes(beta))
+    values.push(beta);
+  headers["anthropic-beta"] = values.join(",");
+  return headers;
+}
+function mergeClientHeaders(...headerSources) {
+  return mergeAnthropicHeaders2({ "User-Agent": getNyteUserAgent2() }, ...headerSources);
+}
+function hasRequestAuth(apiKey, headers) {
+  return !!apiKey || hasHeader2(headers, "authorization") || hasHeader2(headers, "x-api-key") || hasHeader2(headers, "cf-aig-authorization");
+}
+function assertRequestAuth2(provider, apiKey, headers) {
+  if (!hasRequestAuth(apiKey, headers))
+    throw new Error(`No API key for provider: ${provider}`);
+}
+
+class PiAnthropic extends Anthropic {
+  _shouldResolveDefaultCredentials() {
+    return false;
+  }
+}
+function getAnthropicFederation2(model, apiKey, headers, env) {
+  if (model.provider !== "anthropic" || hasRequestAuth(apiKey, headers))
+    return;
+  const federationRuleId = getProviderEnvValue2(ANTHROPIC_FEDERATION_RULE_ID_ENV2, env);
+  const organizationId = getProviderEnvValue2(ANTHROPIC_ORGANIZATION_ID_ENV2, env);
+  const identityTokenFile = getProviderEnvValue2(ANTHROPIC_IDENTITY_TOKEN_FILE_ENV2, env);
+  if (!federationRuleId || !organizationId || !identityTokenFile)
+    return;
+  return {
+    organization_id: organizationId,
+    workspace_id: getProviderEnvValue2(ANTHROPIC_WORKSPACE_ID_ENV2, env),
+    authentication: {
+      type: "oidc_federation",
+      federation_rule_id: federationRuleId,
+      service_account_id: getProviderEnvValue2(ANTHROPIC_SERVICE_ACCOUNT_ID_ENV2, env),
+      identity_token: { source: "file", path: identityTokenFile }
+    }
+  };
+}
+var federationClient;
+function createClient2(model, apiKey, interleavedThinking, useFineGrainedToolStreamingBeta, useServerSideFallbackBeta, useFastModeBeta, useMidConversationToolChangesBeta, optionsHeaders, fetch, dynamicHeaders, sessionId, federation) {
+  const needsInterleavedBeta = interleavedThinking && model.compat?.forceAdaptiveThinking !== true;
+  const betaFeatures = [];
+  if (useFineGrainedToolStreamingBeta) {
+    betaFeatures.push(FINE_GRAINED_TOOL_STREAMING_BETA);
+  }
+  if (needsInterleavedBeta) {
+    betaFeatures.push(INTERLEAVED_THINKING_BETA);
+  }
+  if (useServerSideFallbackBeta) {
+    betaFeatures.push(SERVER_SIDE_FALLBACK_BETA);
+  }
+  if (useMidConversationToolChangesBeta) {
+    betaFeatures.push(MID_CONVERSATION_TOOL_CHANGES_BETA2);
+  }
+  const browserHeaders = {
+    accept: "application/json",
+    "anthropic-dangerous-direct-browser-access": "true"
+  };
+  if (betaFeatures.length > 0)
+    browserHeaders["anthropic-beta"] = betaFeatures.join(",");
+  if (model.provider === "github-copilot") {
+    const client = new PiAnthropic({
+      apiKey: null,
+      authToken: apiKey ?? null,
+      baseURL: model.baseUrl,
+      dangerouslyAllowBrowser: true,
+      fetch,
+      defaultHeaders: appendAnthropicBeta2(mergeClientHeaders(browserHeaders, model.headers, dynamicHeaders, optionsHeaders), useFastModeBeta ? FAST_MODE_BETA2 : undefined)
+    });
+    return { client, isOAuthToken: false };
+  }
+  if (apiKey && usesClaudeSubscription2(apiKey)) {
+    const client = new PiAnthropic({
+      apiKey: null,
+      authToken: apiKey,
+      baseURL: model.baseUrl,
+      dangerouslyAllowBrowser: true,
+      fetch,
+      defaultHeaders: appendAnthropicBeta2(mergeClientHeaders({
+        accept: "application/json",
+        "anthropic-dangerous-direct-browser-access": "true",
+        "anthropic-beta": ["claude-code-20250219", "oauth-2025-04-20", ...betaFeatures].join(","),
+        "user-agent": `claude-cli/${claudeCodeVersion2}`,
+        "x-app": "cli"
+      }, model.headers, optionsHeaders), useFastModeBeta ? FAST_MODE_BETA2 : undefined)
+    });
+    return { client, isOAuthToken: true };
+  }
+  const sessionAffinityHeaders = sessionId && getAnthropicCompat2(model).sendSessionAffinityHeaders ? { "x-session-affinity": sessionId } : {};
+  const defaultHeaders = mergeClientHeaders(browserHeaders, sessionAffinityHeaders, model.headers, optionsHeaders);
+  if (useFastModeBeta)
+    appendAnthropicBeta2(defaultHeaders, FAST_MODE_BETA2);
+  if (federation) {
+    const key = JSON.stringify([model.baseUrl, federation]);
+    if (federationClient?.key !== key || federationClient.fetch !== fetch) {
+      const client = new PiAnthropic({
+        apiKey: null,
+        authToken: null,
+        config: federation,
+        baseURL: model.baseUrl,
+        dangerouslyAllowBrowser: true,
+        fetch
+      });
+      federationClient = { key, fetch, client };
+    }
+    return { client: federationClient.client.withOptions({ defaultHeaders }), isOAuthToken: false };
+  }
+  const client = new PiAnthropic({
+    apiKey: apiKey ?? null,
+    authToken: null,
+    baseURL: model.baseUrl,
+    dangerouslyAllowBrowser: true,
+    fetch,
+    defaultHeaders
+  });
+  return { client, isOAuthToken: false };
+}
+function shouldUseFineGrainedToolStreamingBeta2(model, context) {
+  return getCurrentTools2(context.messages).length > 0 && !getAnthropicCompat2(model).supportsEagerToolInputStreaming;
+}
+
+export { FAST_MODE_BETA2, MID_CONVERSATION_TOOL_CHANGES_BETA2, shouldUseServerSideFallbackBeta2, getAnthropicCompat2, mergeAnthropicHeaders2, appendAnthropicBeta2, assertRequestAuth2, getAnthropicFederation2, createClient2, shouldUseFineGrainedToolStreamingBeta2 };

package/dist/chunks/account-limits-cache-7z9s8j16.js

@@ -0,0 +1,139 @@
+import {
+  operationSignal2,
+  raceWithAbortSignal2
+} from "./account-limits-cache-j2bt392s.js";
+import {
+  formatThrownValue2
+} from "./account-limits-cache-9wqk28n5.js";
+
+// src/auth/resolve.ts
+class ModelsError2 extends Error {
+  code;
+  constructor(code, message, options) {
+    super(withCauseDetail(message, options?.cause), options);
+    this.name = "ModelsError";
+    this.code = code;
+  }
+}
+function withCauseDetail(message, cause) {
+  if (cause === undefined || cause === null)
+    return message;
+  const detail = formatThrownValue2(cause).trim();
+  if (!detail || message.includes(detail))
+    return message;
+  return `${message}: ${detail}`;
+}
+function resolveProviderAuth2(provider, credentials, authContext, overrides) {
+  const signal = operationSignal2(overrides?.signal);
+  return raceWithAbortSignal2(resolveProviderAuthWithSignal(provider, credentials, authContext, overrides, signal), signal);
+}
+async function resolveProviderAuthWithSignal(provider, credentials, authContext, overrides, signal) {
+  signal.throwIfAborted();
+  const requestAuthContext = overrides?.env ? overlayEnvAuthContext(authContext, overrides.env) : authContext;
+  if (overrides?.apiKey !== undefined && provider.auth.apiKey) {
+    return resolveApiKey(requestAuthContext, provider.auth.apiKey, provider.id, {
+      type: "api_key",
+      key: overrides.apiKey,
+      env: overrides.env
+    }, signal);
+  }
+  const stored = await readCredential(credentials, provider.id, signal);
+  const account = stored?.accounts.find((entry) => entry.id === stored.active);
+  if (stored) {
+    if (!account)
+      return;
+    const credential = account.credential;
+    if (credential.type === "oauth" && provider.auth.oauth) {
+      return resolveStoredOAuth(credentials, provider.id, account.id, provider.auth.oauth, credential, signal, overrides?.minOAuthValidityMs);
+    }
+    if (credential.type === "api_key" && provider.auth.apiKey) {
+      const effective = overrides?.env ? { ...credential, env: { ...credential.env, ...overrides.env } } : credential;
+      const result = await resolveApiKey(requestAuthContext, provider.auth.apiKey, provider.id, effective, signal);
+      return result ? { ...result, accountId: account.id } : undefined;
+    }
+    return;
+  }
+  return provider.auth.apiKey ? resolveApiKey(requestAuthContext, provider.auth.apiKey, provider.id, undefined, signal) : undefined;
+}
+function overlayEnvAuthContext(base, env) {
+  return {
+    env: async (name) => env[name] || await base.env(name),
+    fileExists: (path) => base.fileExists(path)
+  };
+}
+var DEFAULT_OAUTH_MINIMUM_VALIDITY_MS = 5 * 60 * 1000;
+var DEFAULT_OAUTH_REFRESH_TIMEOUT_MS2 = 15000;
+async function resolveStoredOAuth(credentials, providerId, accountId, oauth, stored, signal, minOAuthValidityMs) {
+  const minimumValidityMs = Math.max(DEFAULT_OAUTH_MINIMUM_VALIDITY_MS, minOAuthValidityMs ?? 0);
+  const expiresSoon = (credential) => Date.now() + minimumValidityMs >= credential.expires;
+  let credential = stored;
+  let refreshed;
+  if (expiresSoon(credential)) {
+    let post;
+    try {
+      post = await credentials.modify(providerId, async (current) => {
+        const account = current?.accounts.find((entry) => entry.id === accountId);
+        if (!current || account?.credential.type !== "oauth")
+          return;
+        const previous = account.credential;
+        if (!expiresSoon(previous))
+          return;
+        try {
+          if (refreshed?.token !== previous.refresh) {
+            const next = await oauth.refresh(previous, AbortSignal.any([signal, AbortSignal.timeout(DEFAULT_OAUTH_REFRESH_TIMEOUT_MS2)]));
+            refreshed = { token: previous.refresh, credential: next };
+          }
+          const next = refreshed.credential;
+          return {
+            ...current,
+            accounts: current.accounts.map((entry) => entry.id === accountId ? { ...entry, credential: next } : entry)
+          };
+        } catch (error) {
+          throw new ModelsError2("oauth", `OAuth refresh failed for ${providerId}`, {
+            cause: error
+          });
+        }
+      }, { signal });
+    } catch (error) {
+      if (error instanceof ModelsError2)
+        throw error;
+      throw new ModelsError2("auth", `Credential store modify failed for ${providerId}`, {
+        cause: error
+      });
+    }
+    const account = post?.accounts.find((entry) => entry.id === accountId);
+    if (account?.credential.type !== "oauth")
+      return;
+    credential = account.credential;
+    if (minOAuthValidityMs !== undefined && expiresSoon(credential)) {
+      throw new ModelsError2("oauth", `OAuth refresh returned a token that expires too soon for ${providerId}`);
+    }
+  }
+  try {
+    return { auth: await oauth.toAuth(credential), source: "OAuth", accountId };
+  } catch (error) {
+    throw new ModelsError2("oauth", `OAuth auth derivation failed for ${providerId}`, {
+      cause: error
+    });
+  }
+}
+async function resolveApiKey(authContext, apiKey, providerId, credential, signal) {
+  try {
+    return await apiKey.resolve({ ctx: authContext, credential, signal });
+  } catch (error) {
+    throw new ModelsError2("auth", `API key auth failed for provider ${providerId}`, {
+      cause: error
+    });
+  }
+}
+async function readCredential(credentials, providerId, signal) {
+  try {
+    return await credentials.read(providerId, { signal });
+  } catch (error) {
+    throw new ModelsError2("auth", `Credential store read failed for ${providerId}`, {
+      cause: error
+    });
+  }
+}
+
+export { ModelsError2, resolveProviderAuth2, DEFAULT_OAUTH_REFRESH_TIMEOUT_MS2 };

package/dist/chunks/account-limits-cache-8137j3zp.js

@@ -0,0 +1,37 @@
+// src/utils/uuid.ts
+var MAX_UUID_V7_TIMESTAMP = 281474976710655;
+var MAX_SEQUENCE = (1n << 41n) - 1n;
+var lastOrdinaryTimestamp = -1;
+var sequence;
+function uuidv72(timestampMs) {
+  const requestedTimestamp = timestampMs ?? Date.now();
+  if (!Number.isInteger(requestedTimestamp) || requestedTimestamp < 0 || requestedTimestamp > MAX_UUID_V7_TIMESTAMP) {
+    throw new RangeError(`UUIDv7 timestamp must be an integer between 0 and ${MAX_UUID_V7_TIMESTAMP}`);
+  }
+  const effectiveTimestamp = timestampMs === undefined ? Math.max(requestedTimestamp, lastOrdinaryTimestamp) : timestampMs;
+  if (timestampMs === undefined)
+    lastOrdinaryTimestamp = effectiveTimestamp;
+  const bytes = new Uint8Array(16);
+  globalThis.crypto.getRandomValues(bytes);
+  if (sequence === undefined) {
+    sequence = BigInt(bytes[1]) << 32n | BigInt(bytes[2]) << 24n | BigInt(bytes[3]) << 16n | BigInt(bytes[4]) << 8n | BigInt(bytes[5]);
+  } else {
+    if (sequence === MAX_SEQUENCE)
+      throw new RangeError("UUIDv7 generator sequence exhausted");
+    sequence++;
+  }
+  const timestamp = BigInt(effectiveTimestamp);
+  for (let index = 5;index >= 0; index--) {
+    bytes[index] = Number(timestamp >> BigInt((5 - index) * 8)) & 255;
+  }
+  bytes[6] = 112 | Number(sequence >> 37n & 0x0fn);
+  bytes[7] = Number(sequence >> 29n & 0xffn);
+  bytes[8] = 128 | Number(sequence >> 23n & 0x3fn);
+  bytes[9] = Number(sequence >> 15n & 0xffn);
+  bytes[10] = Number(sequence >> 7n & 0xffn);
+  bytes[11] = Number((sequence & 0x7fn) << 1n) | bytes[11] & 1;
+  const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0"));
+  return `${hex.slice(0, 4).join("")}-${hex.slice(4, 6).join("")}-${hex.slice(6, 8).join("")}-${hex.slice(8, 10).join("")}-${hex.slice(10).join("")}`;
+}
+
+export { uuidv72 };

package/dist/chunks/account-limits-cache-8qzk56vj.js

@@ -0,0 +1,160 @@
+// src/api/transform-messages.ts
+var NON_VISION_USER_IMAGE_PLACEHOLDER = "(image omitted: model does not support images)";
+var NON_VISION_TOOL_IMAGE_PLACEHOLDER = "(tool image omitted: model does not support images)";
+function replaceImagesWithPlaceholder(content, placeholder) {
+  const result = [];
+  let previousWasPlaceholder = false;
+  for (const block of content) {
+    if (block.type === "image") {
+      if (!previousWasPlaceholder) {
+        result.push({ type: "text", text: placeholder });
+      }
+      previousWasPlaceholder = true;
+      continue;
+    }
+    result.push(block);
+    previousWasPlaceholder = block.text === placeholder;
+  }
+  return result;
+}
+function downgradeUnsupportedImages(messages, model) {
+  if (model.input.includes("image")) {
+    return messages;
+  }
+  return messages.map((msg) => {
+    if (msg.role === "user" && Array.isArray(msg.content)) {
+      return {
+        ...msg,
+        content: replaceImagesWithPlaceholder(msg.content, NON_VISION_USER_IMAGE_PLACEHOLDER)
+      };
+    }
+    if (msg.role === "toolResult") {
+      return {
+        ...msg,
+        content: replaceImagesWithPlaceholder(msg.content, NON_VISION_TOOL_IMAGE_PLACEHOLDER)
+      };
+    }
+    return msg;
+  });
+}
+function transformMessages2(messages, model, normalizeToolCallId) {
+  const toolCallIdMap = new Map;
+  const normalizedMessages = messages.map((msg) => msg.content == null ? { ...msg, content: [] } : msg);
+  const imageAwareMessages = downgradeUnsupportedImages(normalizedMessages, model);
+  const transformed = imageAwareMessages.map((msg) => {
+    if (msg.role === "system" || msg.role === "user") {
+      return msg;
+    }
+    if (msg.role === "toolResult") {
+      const normalizedId = toolCallIdMap.get(msg.toolCallId);
+      if (normalizedId && normalizedId !== msg.toolCallId) {
+        return { ...msg, toolCallId: normalizedId };
+      }
+      return msg;
+    }
+    if (msg.role === "assistant") {
+      const isSameModel = msg.provider === model.provider && msg.api === model.api && msg.model === model.id;
+      const transformedContent = msg.content.flatMap((block) => {
+        if (block.type === "thinking") {
+          if (block.redacted) {
+            return isSameModel ? block : [];
+          }
+          if (isSameModel && block.thinkingSignature)
+            return block;
+          if (!block.thinking || block.thinking.trim() === "")
+            return [];
+          if (isSameModel)
+            return block;
+          return {
+            type: "text",
+            text: block.thinking
+          };
+        }
+        if (block.type === "text") {
+          if (isSameModel)
+            return block;
+          return {
+            type: "text",
+            text: block.text
+          };
+        }
+        if (block.type === "toolCall") {
+          let normalizedToolCall = block;
+          if (!isSameModel && block.thoughtSignature) {
+            normalizedToolCall = { ...block };
+            delete normalizedToolCall.thoughtSignature;
+          }
+          if (!isSameModel && normalizeToolCallId) {
+            const normalizedId = normalizeToolCallId(block.id, model, msg);
+            if (normalizedId !== block.id) {
+              toolCallIdMap.set(block.id, normalizedId);
+              normalizedToolCall = { ...normalizedToolCall, id: normalizedId };
+            }
+          }
+          return normalizedToolCall;
+        }
+        return block;
+      });
+      return {
+        ...msg,
+        content: transformedContent
+      };
+    }
+    return msg;
+  });
+  const result = [];
+  let pendingToolCalls = [];
+  let existingToolResultIds = new Set;
+  const heldSystemMessages = [];
+  const closePendingToolCalls = () => {
+    if (pendingToolCalls.length > 0) {
+      for (const tc of pendingToolCalls) {
+        if (!existingToolResultIds.has(tc.id)) {
+          result.push({
+            role: "toolResult",
+            toolCallId: tc.id,
+            toolName: tc.name,
+            content: [{ type: "text", text: "No result provided" }],
+            isError: true,
+            timestamp: Date.now()
+          });
+        }
+      }
+      pendingToolCalls = [];
+      existingToolResultIds = new Set;
+    }
+    result.push(...heldSystemMessages);
+    heldSystemMessages.length = 0;
+  };
+  for (let i = 0;i < transformed.length; i++) {
+    const msg = transformed[i];
+    if (msg.role === "assistant") {
+      closePendingToolCalls();
+      if (msg.stopReason === "error" || msg.stopReason === "aborted") {
+        continue;
+      }
+      const toolCalls = msg.content.filter((b) => b.type === "toolCall");
+      if (toolCalls.length > 0) {
+        pendingToolCalls = toolCalls;
+        existingToolResultIds = new Set;
+      }
+      result.push(msg);
+    } else if (msg.role === "toolResult") {
+      existingToolResultIds.add(msg.toolCallId);
+      result.push(msg);
+    } else if (msg.role === "system") {
+      if (pendingToolCalls.length > 0) {
+        heldSystemMessages.push(msg);
+      } else {
+        result.push(msg);
+      }
+    } else {
+      closePendingToolCalls();
+      result.push(msg);
+    }
+  }
+  closePendingToolCalls();
+  return result;
+}
+
+export { transformMessages2 };

package/dist/chunks/account-limits-cache-8s8bz4dr.js

@@ -0,0 +1,36 @@
+// src/utils/deferred-tools.ts
+var identityToolName = (name) => name;
+function splitDeferredTools2(context, enabled, normalizeName = identityToolName) {
+  const uniqueTools = new Map;
+  for (const tool of context.tools ?? [])
+    uniqueTools.set(normalizeName(tool.name), tool);
+  if (!enabled)
+    return { immediate: [...uniqueTools.values()], deferred: new Map };
+  const deferredNames = new Set;
+  const usedNames = new Set;
+  for (const message of context.messages) {
+    if (message.role === "assistant") {
+      for (const block of message.content) {
+        if (block.type === "toolCall")
+          usedNames.add(normalizeName(block.name));
+      }
+    } else if (message.role === "toolResult") {
+      for (const name of message.addedToolNames ?? []) {
+        const normalizedName = normalizeName(name);
+        if (!usedNames.has(normalizedName))
+          deferredNames.add(normalizedName);
+      }
+    }
+  }
+  const immediate = [];
+  const deferred = new Map;
+  for (const [name, tool] of uniqueTools) {
+    if (deferredNames.has(name))
+      deferred.set(name, tool);
+    else
+      immediate.push(tool);
+  }
+  return { immediate, deferred };
+}
+
+export { splitDeferredTools2 };