nexus-agents 2.160.2 → 2.161.1

package/dist/chunk-4KRO6NTX.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/config/model-parameter-support.ts","../src/config/temperature-support.ts","../src/adapters/optional-params.ts","../src/adapters/base-adapter.ts","../src/adapters/streaming-types.ts","../src/adapters/stream-operators-helpers.ts","../src/adapters/stream-operators.ts","../src/adapters/streaming.ts"],"sourcesContent":["/**\n * nexus-agents/config — data-driven model request-parameter capability resolver\n * (#4067, epic #4066 layer 1).\n *\n * Generalizes the ad-hoc `temperatureUnsupportedForModel` (#4061/#4062) into a\n * registry-first resolver. Two questions every adapter param-builder asks before\n * forwarding a request parameter:\n *\n * 1. Does this model REJECT a given parameter (so the adapter must omit it)?\n *    {@link unsupportedParametersForModel} / {@link modelSupportsParameter}.\n * 2. Which max-tokens param name does it expect — `max_tokens` (chat-completions\n *    default) or `max_completion_tokens` (OpenAI reasoning models, #4049)?\n *    {@link getMaxTokensParamForModel}.\n *\n * RESOLUTION ORDER (each function): (a) registry capability data — the in-tree\n * `ModelCapability.unsupportedParameters` / `.maxTokensParam` looked up via\n * `lookupInTreeCapability`; if present, it WINS; (b) otherwise the regex fallback\n * below, preserving the EXACT logic that lived in `temperature-support.ts` so\n * unregistered ids (Claude 4.7/4.8, bare o-series) keep resolving correctly.\n *\n * Deterministic: a given id (with a stable registry) yields the same result every\n * call. Biased AGAINST false-positive stripping — a missed rejection is a 400\n * outage, a wrongly-stripped param only loses a tuning knob (the same bias the\n * temperature predicate documented). `temperature-support.ts` is now a thin shim\n * over {@link modelSupportsParameter}.\n *\n * @module config/model-parameter-support\n */\n\nimport { lookupInTreeCapability } from './model-config-helpers.js';\n\n// ---------------------------------------------------------------------------\n// Regex fallback internals (moved verbatim from temperature-support.ts, #4061)\n// ---------------------------------------------------------------------------\n\ninterface ClaudeMajorMinor {\n  readonly major: number;\n  readonly minor: number;\n}\n\n/**\n * Parse the FIRST numeric version from a (provider-prefix-stripped) Claude model\n * id — a major with an OPTIONAL minor, tolerating `-`, `_`, and `.` separators.\n *\n * A trailing snapshot date (`-20250514`, 6+ digits) is stripped FIRST so it cannot\n * be mistaken for a minor: `claude-opus-4-20250514` is Opus **4.0**, not 4.20250514.\n * A bare major with no minor is treated as `.0` (`claude-opus-4` → 4.0,\n * `claude-fable-5` → 5.0). major/minor are kept as separate integers so `4.10`\n * compares ABOVE `4.6` (a `parseFloat` would collapse to 4.1). Returns `null` only\n * when the id carries no version digits at all (e.g. `claude-instant`,\n * `claude-newfamily`).\n */\nfunction parseClaudeMajorMinor(bareId: string): ClaudeMajorMinor | null {\n  const undated = bareId.replace(/[-_]\\d{6,}$/, '');\n  const match = /(\\d+)(?:[-_.](\\d+))?/.exec(undated);\n  if (match === null) return null;\n  const major = Number.parseInt(match[1] as string, 10);\n  const minor = match[2] !== undefined ? Number.parseInt(match[2], 10) : 0;\n  if (Number.isNaN(major) || Number.isNaN(minor)) return null;\n  return { major, minor };\n}\n\n/** Recognized LEGACY Claude families that still support `temperature` (pre-4.x). */\nconst LEGACY_TEMPERATURE_SUPPORTING = /claude[-_](?:instant|1|2|3)(?:[-_.]|$)/;\n\n/**\n * Claude branch of the temperature regex fallback (#4061). `bare` is the id\n * sliced from the first `claude` (provider prefix stripped). Unsupported when the\n * version is after Opus 4.6, or the family is unrecognized/non-numbered\n * (`claude-fable-5`, future) — a deliberate SAFE-DROP, since a benign fall-back to\n * the API default beats a 400.\n */\nfunction claudeTemperatureUnsupported(bare: string): boolean {\n  const version = parseClaudeMajorMinor(bare);\n  if (version !== null) {\n    // \"after Opus 4.6\": major > 4, or 4.7+ within the 4.x line.\n    return version.major > 4 || (version.major === 4 && version.minor >= 7);\n  }\n  if (LEGACY_TEMPERATURE_SUPPORTING.test(bare)) return false;\n  return true;\n}\n\n/**\n * OpenAI REASONING-model detection (#4062). True ONLY for the reasoning models\n * documented to reject `temperature` and to use `max_completion_tokens`;\n * everything else (gpt-4o, gpt-4, gpt-3.5, gemini, openrouter-*, …) returns false.\n * `id` is the full lower-cased model id.\n *\n * - o-series: `o1`/`o3`/`o3-mini`/`o4-mini` — `o` + digit at the START of the last\n *   path segment (so `claude-opus`/`openrouter-*` cannot match).\n * - codex: all current `codex…` routes are GPT-5-reasoning-based.\n * - GPT-5 family: `gpt-5` / `gpt5` (anchored after the `5` so `gpt-50`/`gpt-512`\n *   do NOT match) — EXCEPT the non-reasoning `gpt-5-chat` variant.\n */\nfunction openAiReasoning(id: string): boolean {\n  const segment = id.includes('/') ? id.slice(id.lastIndexOf('/') + 1) : id;\n  if (/^o[0-9]/.test(segment)) return true;\n  if (segment.includes('codex')) return true;\n  if (/gpt-?5(?![0-9])/.test(segment) && !segment.includes('gpt-5-chat')) return true;\n  return false;\n}\n\n/**\n * Regex fallback for whether `modelId` rejects a non-default `temperature`. The\n * EXACT predicate that was `temperatureUnsupportedForModel` before #4067 — Claude\n * after Opus 4.6, OpenAI o-series / GPT-5 family / codex; everything else false.\n * Robust to gateway id variants (provider prefixes, `-`/`_` separators, dated\n * suffixes).\n */\nfunction regexRejectsTemperature(modelId: string): boolean {\n  const id = modelId.toLowerCase();\n  const claudeAt = id.indexOf('claude');\n  if (claudeAt !== -1) {\n    return claudeTemperatureUnsupported(id.slice(claudeAt)); // strip provider prefix\n  }\n  return openAiReasoning(id);\n}\n\n/** Regex fallback for OpenAI-reasoning detection (Claude ids are never reasoning here). */\nfunction regexIsOpenAiReasoning(modelId: string): boolean {\n  const id = modelId.toLowerCase();\n  if (id.includes('claude')) return false;\n  return openAiReasoning(id);\n}\n\n// ---------------------------------------------------------------------------\n// Public resolver API\n// ---------------------------------------------------------------------------\n\n/**\n * Parameters `modelId` REJECTS. Registry capability data first\n * (`ModelCapability.unsupportedParameters`), else the regex fallback for\n * unregistered models (Claude>4.6, OpenAI o-series/codex/gpt-5 reject\n * `'temperature'`; nothing else, for now). Deterministic.\n */\nexport function unsupportedParametersForModel(modelId: string): readonly string[] {\n  const cap = lookupInTreeCapability(modelId);\n  if (cap?.unsupportedParameters !== undefined) return cap.unsupportedParameters;\n  return regexRejectsTemperature(modelId) ? ['temperature'] : [];\n}\n\n/** True iff `modelId` accepts `param`. */\nexport function modelSupportsParameter(modelId: string, param: string): boolean {\n  return !unsupportedParametersForModel(modelId).includes(param);\n}\n\n/**\n * The max-tokens param name `modelId` expects: registry `maxTokensParam` first,\n * else regex fallback (OpenAI reasoning → `'max_completion_tokens'`, else\n * `'max_tokens'`).\n */\nexport function getMaxTokensParamForModel(modelId: string): 'max_tokens' | 'max_completion_tokens' {\n  const cap = lookupInTreeCapability(modelId);\n  if (cap?.maxTokensParam !== undefined) return cap.maxTokensParam;\n  return regexIsOpenAiReasoning(modelId) ? 'max_completion_tokens' : 'max_tokens';\n}\n\n// ---------------------------------------------------------------------------\n// Known-incompatibility registry — the drift guard's source of truth (#4070)\n// ---------------------------------------------------------------------------\n\n/**\n * One DOCUMENTED model-parameter incompatibility — a real incident the resolver\n * MUST keep handling. A `param` entry asserts the model rejects that request\n * parameter ({@link modelSupportsParameter} must be false); a `maxTokensParam`\n * entry asserts the max-tokens field name ({@link getMaxTokensParamForModel}).\n */\nexport interface KnownParameterIncompatibility {\n  /** A model id that hits the case (registry-encoded OR regex-fallback). */\n  readonly modelId: string;\n  /** The rejected request parameter (mutually exclusive with `maxTokensParam`). */\n  readonly param?: string;\n  /** The expected max-tokens field name (mutually exclusive with `param`). */\n  readonly maxTokensParam?: 'max_tokens' | 'max_completion_tokens';\n  /** The GitHub incident this case locks in, so a reviewer sees WHY it matters. */\n  readonly issue: number;\n}\n\n/**\n * The documented model-parameter incompatibilities (#4061/#4062/#4049) as a single\n * declarative, greppable source of truth. The layer-4 drift guard (#4070) asserts\n * every entry against the resolver, so the next param drift — a bumped Claude\n * threshold, an edited regex, a removed `unsupportedParameters` on a registered\n * model — fails CI instead of silently 400-ing in production. Exported so it doubles\n * as documentation and as the anchor the (deferred) provider-reality reconciliation\n * checks against. Spans BOTH the registry data path and the regex fallback path.\n */\nexport const KNOWN_PARAMETER_INCOMPATIBILITIES: readonly KnownParameterIncompatibility[] = [\n  // #4061 — Claude after Opus 4.6 rejects a non-1.0 temperature with a 400 (regex fallback; unregistered concrete id).\n  { modelId: 'claude-opus-4-8', param: 'temperature', issue: 4061 },\n  // #4062 — OpenAI reasoning families reject temperature (o-series/gpt-5 via regex fallback; codex via registry data).\n  { modelId: 'o3-mini', param: 'temperature', issue: 4062 },\n  { modelId: 'gpt-5', param: 'temperature', issue: 4062 },\n  { modelId: 'codex-5.3', param: 'temperature', issue: 4062 },\n  // #4049 — OpenAI reasoning models expect `max_completion_tokens`, not `max_tokens` (codex via registry; o-series via fallback).\n  { modelId: 'codex-5.3', maxTokensParam: 'max_completion_tokens', issue: 4049 },\n  { modelId: 'o3-mini', maxTokensParam: 'max_completion_tokens', issue: 4049 },\n];\n","/**\n * nexus-agents/config — model `temperature` support (#4061, #4062).\n *\n * Some models reject a custom `temperature` with a hard 400, so both adapters\n * must OMIT the param for them. Two families:\n *\n * 1. Anthropic Claude AFTER Opus 4.6 (#4061). Per the installed `@anthropic-ai/sdk`\n *    (messages.d.ts): \"Models released after Claude Opus 4.6 do not support setting\n *    temperature. A value of 1.0 will be accepted for backwards compatibility, all\n *    other values will be rejected with a 400 error.\"\n * 2. OpenAI REASONING models (#4062): the o-series (o1/o3/o3-mini/o4-mini) reject\n *    `temperature` outright (\"Unsupported parameter\"), and the GPT-5 family accepts\n *    only the default (\"Only the default (1) value is supported\") — except the\n *    non-reasoning `gpt-5-chat` variant. This repo routes codex-5.3→gpt-5.4,\n *    codex-5.2→gpt-5.2-codex, codex-5.1-mini→o3-mini, so gateway voters at the\n *    default 0.3 400 on all of them.\n *\n * {@link temperatureUnsupportedForModel} is the single source of truth both the\n * native Claude adapter and the OpenAI-compatible gateway adapter consult before\n * forwarding `temperature`. When it returns true the adapter OMITS the param\n * (value 1.0 is the API default, so omitting is equivalent). It returns FALSE for\n * every model NOT known to reject temperature (gpt-4o, gpt-4, gemini, …), biasing\n * AGAINST false-positive stripping — a false negative is a 400, a false positive\n * only loses the consistency setting.\n *\n * As of #4067 the predicate is a THIN SHIM over the data-driven resolver in\n * `model-parameter-support.ts` (registry `unsupportedParameters` first, then the\n * same regex fallback that used to live here). The three adapter call sites and\n * the `warnTemperatureDropped` / `_resetTemperatureWarnings` surface are unchanged.\n *\n * @module config/temperature-support\n */\n\nimport { createLogger } from '../core/index.js';\nimport { modelSupportsParameter } from './model-parameter-support.js';\n\nconst logger = createLogger({ component: 'temperature-support' });\n\n/**\n * Models we have ALREADY warned about dropping `temperature` for, so the loud\n * warning fires once per model per process rather than on every request (a voter\n * panel makes many calls). Repeats log at debug.\n */\nconst warnedDroppedModels = new Set<string>();\n\n/**\n * FAIL LOUDLY when `temperature` is omitted because the target model rejects it\n * (#4066 layer 3). `temperature` is a BEHAVIORAL parameter — silently dropping it\n * means a determinism/consistency setting is ignored with no signal (e.g. 0.0 and\n * 0.7 yield identical output), the canonical footgun. So the first drop per model\n * is a WARN that says the param was omitted and the request runs at the provider\n * default; subsequent drops for that model log at debug to avoid per-call spam.\n */\nexport function warnTemperatureDropped(modelId: string): void {\n  if (warnedDroppedModels.has(modelId)) {\n    logger.debug('Omitted unsupported temperature (already warned for this model)', {\n      modelId,\n      parameter: 'temperature',\n    });\n    return;\n  }\n  warnedDroppedModels.add(modelId);\n  logger.warn(\n    `Model \"${modelId}\" does not support a custom \\`temperature\\` (the provider rejects ` +\n      `non-default values with a 400). nexus-agents omitted it; the request runs at the ` +\n      `provider default. Any determinism/consistency you expected from temperature has NO ` +\n      `effect on this model.`,\n    { modelId, parameter: 'temperature', severity: 'behavioral' }\n  );\n}\n\n/** Test seam: clear the once-per-model warning dedupe set. */\nexport function _resetTemperatureWarnings(): void {\n  warnedDroppedModels.clear();\n}\n\n/**\n * Whether `modelId` REJECTS a non-default `temperature` and the param must be\n * dropped before the request is sent. Single source of truth for both adapters.\n *\n * Thin shim over {@link modelSupportsParameter} (#4067): registry\n * `unsupportedParameters` data wins, else the regex fallback (Claude after Opus\n * 4.6 #4061; OpenAI o-series / GPT-5 family / codex #4062; everything else\n * `false`). Biased AGAINST false positives: a missed model is a 400 outage, a\n * wrongly matched one only loses the consistency setting. Robust to gateway id\n * variants — provider prefixes (`anthropic/…`, `openai/…`), `-`/`_` separators,\n * dated suffixes.\n */\nexport function temperatureUnsupportedForModel(modelId: string): boolean {\n  return !modelSupportsParameter(modelId, 'temperature');\n}\n","/**\n * nexus-agents/adapters — shared optional-parameter decision seam (#4068, epic #4066 layer 2).\n *\n * The claude / openai / sdk adapters each inlined an IDENTICAL temperature\n * drop-decision before forwarding a request: consult the layer-1 capability\n * resolver, drop `temperature` (and warn once) when the model rejects it, else\n * pass it through. This module is the single seam for that decision so the three\n * call sites stop duplicating it.\n *\n * It returns DECISION METADATA, not a provider-neutral params dict: each adapter\n * still owns its own wire shape (field names + nesting for stop/tools/\n * response_format/max-tokens), so the seam only decides the shared bit\n * (temperature) and records what it dropped/transformed for the layer-3 telemetry\n * child (#4069). Behavior-preserving by construction.\n *\n * @module adapters/optional-params\n */\n\nimport { modelSupportsParameter } from '../config/model-parameter-support.js';\nimport { warnTemperatureDropped } from '../config/temperature-support.js';\nimport type { CompletionRequest } from '../core/index.js';\n\n/**\n * Severity of a dropped param (#4069, epic #4066 layer 3). Behavioral params\n * (temperature/seed/top_p) affect determinism/output — dropping one silently is\n * the canonical footgun, so it is surfaced LOUDLY (WARN). Everything else is\n * cosmetic — dropping it is quiet (DEBUG).\n */\nexport type ParamSeverity = 'behavioral' | 'cosmetic';\n\n/** Params whose silent drop changes model output/determinism — loud when dropped. */\nconst BEHAVIORAL_PARAMS = new Set<string>(['temperature', 'seed', 'top_p']);\n\n/** Classify a request param as behavioral (loud-on-drop) or cosmetic (quiet). */\nexport function parameterSeverity(param: string): ParamSeverity {\n  return BEHAVIORAL_PARAMS.has(param) ? 'behavioral' : 'cosmetic';\n}\n\n/** A request param the seam dropped, with why (feeds the layer-3 telemetry child #4069). */\nexport interface DroppedParam {\n  readonly param: string;\n  readonly reason: string;\n  /** Behavioral (loud) vs cosmetic (quiet) — see {@link parameterSeverity}. */\n  readonly severity: ParamSeverity;\n}\n\n/**\n * Would-have-self-healed counter (#4069, epic #4066 layer 3). Keyed\n * `${modelId}:${param}`. Counts every PROACTIVE drop (this module) AND every\n * REACTIVE param-naming 400 the adapter classifies as MODEL_PARAMETER_UNSUPPORTED\n * (base-adapter). Both are exactly the events the reactive self-heal path (#4071)\n * would catch, so this single counter measures how often #4071 would have fired.\n */\nconst wouldHaveSelfHealed = new Map<string, number>();\n\n/** Record one would-have-self-healed event for `modelId`'s `param` (#4069). */\nexport function recordWouldHaveSelfHealed(modelId: string, param: string): void {\n  const key = `${modelId}:${param}`;\n  wouldHaveSelfHealed.set(key, (wouldHaveSelfHealed.get(key) ?? 0) + 1);\n}\n\n/** Snapshot of the would-have-self-healed counts (defensive copy). */\nexport function getWouldHaveSelfHealedCounts(): ReadonlyMap<string, number> {\n  return new Map(wouldHaveSelfHealed);\n}\n\n/** Test seam: clear the would-have-self-healed counter. */\nexport function _resetWouldHaveSelfHealed(): void {\n  wouldHaveSelfHealed.clear();\n}\n\n/** A request param the seam transformed (name/value). Reserved for #4069 / a later max-tokens increment; empty today. */\nexport interface TransformedParam {\n  readonly param: string;\n  readonly from: unknown;\n  readonly to: unknown;\n}\n\n/** The provider-NEUTRAL decision the adapters apply to their own wire shape. */\nexport interface OptionalParamPlan {\n  /** Present iff temperature should be sent (the adapter sets it under its own field name — all 3 use `temperature`). Absent = drop it. */\n  readonly temperature?: number;\n  readonly dropped: readonly DroppedParam[];\n  readonly transformed: readonly TransformedParam[];\n}\n\n/**\n * Centralizes the temperature drop-decision shared by the claude/openai/sdk adapters\n * (#4068, epic #4066 layer 2). Consults the layer-1 resolver; when the model rejects\n * temperature it is dropped (and `warnTemperatureDropped` fires, exactly as before) and\n * recorded in `dropped` for the layer-3 telemetry child (#4069). Behavior-preserving:\n * the adapters previously inlined this identically. Returns DECISION METADATA, not a\n * neutral params dict (each adapter still owns its wire names/nesting for stop/tools/etc).\n */\nexport function planOptionalParams(request: CompletionRequest, modelId: string): OptionalParamPlan {\n  const dropped: DroppedParam[] = [];\n  let temperature: number | undefined;\n  if (request.temperature !== undefined) {\n    if (modelSupportsParameter(modelId, 'temperature')) {\n      temperature = request.temperature;\n    } else {\n      // ONE loud line per drop, deduped: warnTemperatureDropped is the consolidated\n      // behavioral WARN (severity:'behavioral'), once per model then debug (#4066\n      // layer 3). temperature is the only param dropped today and it is behavioral,\n      // so there is no second emit — adding one would double-warn.\n      warnTemperatureDropped(modelId);\n      // Record the proactive drop: every time the reactive self-heal path (#4071)\n      // would have fired on a temperature-rejecting 400.\n      recordWouldHaveSelfHealed(modelId, 'temperature');\n      dropped.push({\n        param: 'temperature',\n        reason: `model_rejects:${modelId}`,\n        severity: parameterSeverity('temperature'),\n      });\n    }\n  }\n  return { ...(temperature !== undefined ? { temperature } : {}), dropped, transformed: [] };\n}\n","/**\n * nexus-agents/adapters - Base Adapter\n *\n * Abstract base class that all model adapters extend.\n * Provides common functionality for token counting, logging, error transformation,\n * and capability checking.\n */\n\nimport type {\n  Result,\n  IModelAdapter,\n  CompletionRequest,\n  CompletionResponse,\n  StreamChunk,\n  ILogger,\n  ModelCapability,\n} from '../core/index.js';\nimport { getErrorMessage } from '../core/index.js';\nimport { isRateLimitLikeError } from './rate-limit-detector.js';\nimport { recordWouldHaveSelfHealed } from './optional-params.js';\n\nimport {\n  ok,\n  err,\n  ConfigError,\n  ModelError,\n  ErrorCode,\n  createLogger,\n  getTokenEstimator,\n  type NexusErrorOptions,\n} from '../core/index.js';\n\n/**\n * Configuration options for BaseAdapter.\n */\nexport interface BaseAdapterConfig {\n  /** Provider identifier (e.g., 'anthropic', 'openai') */\n  providerId: string;\n  /** Model identifier (e.g., 'claude-sonnet-4', 'gpt-4o') */\n  modelId: string;\n  /** Capabilities this model supports */\n  capabilities: readonly ModelCapability[];\n  /** Optional custom logger */\n  logger?: ILogger;\n  /** API key for authentication (optional, may come from environment) */\n  apiKey?: string;\n  /** Base URL for the API (optional, uses provider default) */\n  baseUrl?: string;\n  /** Request timeout in milliseconds */\n  timeout?: number;\n  /** Maximum number of retries for failed requests */\n  maxRetries?: number;\n}\n\n/**\n * Extended ModelError that supports specific error codes.\n *\n * While ModelError from core uses MODEL_ERROR by default, this subclass\n * allows adapters to specify more granular error codes like\n * MODEL_RATE_LIMITED, MODEL_TIMEOUT, etc.\n *\n * Extends ModelError so `instanceof ModelError` checks pass naturally\n * without requiring `as unknown as ModelError` casts.\n */\nexport class AdapterModelError extends ModelError {\n  constructor(message: string, options: NexusErrorOptions) {\n    super(message, options);\n    this.name = 'ModelError';\n  }\n}\n\n// ============================================================================\n// API Key Validation Helpers (#1446 — DRY extraction)\n// ============================================================================\n\n/**\n * Returns true if the given API key is missing or blank.\n */\nexport function isApiKeyMissing(apiKey: string | undefined): boolean {\n  return apiKey === undefined || apiKey === '' || apiKey.trim() === '';\n}\n\n/**\n * Validates API key presence in constructor — throws ConfigError if missing.\n * Use in adapter constructors where throwing is appropriate.\n */\nexport function requireApiKey(\n  apiKey: string | undefined,\n  providerName: string,\n  modelId: string\n): void {\n  if (isApiKeyMissing(apiKey)) {\n    throw new ConfigError(`${providerName} API key is required`, {\n      context: { providerId: providerName.toLowerCase(), modelId },\n    });\n  }\n}\n\n/**\n * Validates API key presence — returns Result for validate-style methods.\n * Use in adapter validateConfig() methods that return Result.\n */\nexport function validateApiKeyPresence(\n  apiKey: string | undefined,\n  providerId: string,\n  modelId: string\n): Result<void, ConfigError> {\n  if (isApiKeyMissing(apiKey)) {\n    return err(\n      new ConfigError(`${providerId} API key is required`, {\n        context: { providerId, modelId },\n      })\n    );\n  }\n  return ok(undefined);\n}\n\n/**\n * Abstract base class for model adapters.\n *\n * Provides default implementations for common adapter functionality while\n * leaving the core API interaction methods abstract for provider-specific\n * implementations.\n *\n * @example\n * ```typescript\n * class ClaudeAdapter extends BaseAdapter {\n *   constructor(config: ClaudeAdapterConfig) {\n *     super({\n *       providerId: 'anthropic',\n *       modelId: config.modelId,\n *       capabilities: [ModelCapability.COMPLETION, ModelCapability.STREAMING],\n *       apiKey: config.apiKey,\n *     });\n *   }\n *\n *   async complete(request: CompletionRequest): Promise<Result<CompletionResponse, ModelError>> {\n *     this.logRequest(request);\n *     // Provider-specific implementation...\n *   }\n *\n *   async *stream(request: CompletionRequest): AsyncIterable<StreamChunk> {\n *     this.logRequest(request);\n *     // Provider-specific streaming implementation...\n *   }\n * }\n * ```\n */\nexport abstract class BaseAdapter implements IModelAdapter {\n  readonly providerId: string;\n  readonly modelId: string;\n  readonly capabilities: readonly ModelCapability[];\n\n  /** Logger for request/response logging */\n  protected readonly logger: ILogger;\n\n  /** Configuration for the adapter */\n  protected readonly config: BaseAdapterConfig;\n\n  /**\n   * Creates a new BaseAdapter instance.\n   *\n   * @param config - Adapter configuration\n   */\n  constructor(config: BaseAdapterConfig) {\n    this.providerId = config.providerId;\n    this.modelId = config.modelId;\n    this.capabilities = config.capabilities;\n    this.config = config;\n    this.logger =\n      config.logger ??\n      createLogger({\n        adapter: config.providerId,\n        model: config.modelId,\n      });\n  }\n\n  /**\n   * Send a completion request to the model.\n   * Must be implemented by concrete adapter classes.\n   *\n   * @param request - The completion request\n   * @returns Result with response or ModelError\n   */\n  abstract complete(request: CompletionRequest): Promise<Result<CompletionResponse, ModelError>>;\n\n  /**\n   * Stream a completion request from the model.\n   * Must be implemented by concrete adapter classes.\n   *\n   * @param request - The completion request\n   * @yields StreamChunk objects as they arrive\n   */\n  abstract stream(request: CompletionRequest): AsyncIterable<StreamChunk>;\n\n  /**\n   * Count tokens in text using the unified TokenEstimator.\n   *\n   * This provides a reasonable estimate for most use cases.\n   * Concrete adapters may override this with provider-specific tokenizers.\n   *\n   * @param text - Text to count tokens for\n   * @returns Approximate token count\n   */\n  countTokens(text: string): Promise<number> {\n    return Promise.resolve(getTokenEstimator().estimateText(text));\n  }\n\n  /**\n   * Validate adapter configuration.\n   *\n   * Checks that required configuration fields are present and valid.\n   * Concrete adapters may override to add provider-specific validation.\n   *\n   * @returns Ok if valid, ConfigError if invalid\n   */\n  validateConfig(): Result<void, ConfigError> {\n    const errors: string[] = [];\n\n    if (!this.providerId || this.providerId.trim() === '') {\n      errors.push('Provider ID is required');\n    }\n\n    if (!this.modelId || this.modelId.trim() === '') {\n      errors.push('Model ID is required');\n    }\n\n    if (this.config.timeout !== undefined && this.config.timeout <= 0) {\n      errors.push('Timeout must be positive');\n    }\n\n    if (this.config.maxRetries !== undefined && this.config.maxRetries < 0) {\n      errors.push('Max retries cannot be negative');\n    }\n\n    if (errors.length > 0) {\n      return err(\n        new ConfigError(`Invalid adapter configuration: ${errors.join('; ')}`, {\n          context: {\n            providerId: this.providerId,\n            modelId: this.modelId,\n            errors,\n          },\n        })\n      );\n    }\n\n    return ok(undefined);\n  }\n\n  /**\n   * Check if this adapter supports a specific capability.\n   *\n   * @param capability - The capability to check for\n   * @returns True if the capability is supported\n   */\n  hasCapability(capability: ModelCapability): boolean {\n    return this.capabilities.includes(capability);\n  }\n\n  /**\n   * Log details about an outgoing request.\n   * Sanitizes sensitive information before logging.\n   *\n   * @param request - The completion request to log\n   */\n  protected logRequest(request: CompletionRequest): void {\n    const messageCount = request.messages.length;\n    const hasTools = request.tools !== undefined && request.tools.length > 0;\n    const toolCount = request.tools?.length ?? 0;\n\n    this.logger.debug('Sending completion request', {\n      messageCount,\n      hasSystemPrompt: request.systemPrompt !== undefined,\n      temperature: request.temperature,\n      maxTokens: request.maxTokens,\n      hasTools,\n      toolCount,\n      responseFormat: request.responseFormat?.type,\n      stopSequences: request.stop?.length ?? 0,\n    });\n  }\n\n  /**\n   * Log details about a received response.\n   *\n   * @param response - The completion response to log\n   */\n  protected logResponse(response: CompletionResponse): void {\n    this.logger.debug('Received completion response', {\n      contentBlocks: response.content.length,\n      stopReason: response.stopReason,\n      inputTokens: response.usage.inputTokens,\n      outputTokens: response.usage.outputTokens,\n      totalTokens: response.usage.totalTokens,\n      model: response.model,\n    });\n  }\n\n  /**\n   * Transform a provider-specific error into a standardized ModelError.\n   *\n   * Maps common error patterns to appropriate error codes:\n   * - Rate limiting (429, quota exceeded)\n   * - Timeouts (ETIMEDOUT, ESOCKETTIMEDOUT)\n   * - Authentication (401, 403)\n   * - Model unavailable (503, 502)\n   *\n   * @param error - The original error from the provider\n   * @returns A standardized ModelError\n   */\n  protected transformError(error: unknown): ModelError {\n    if (error instanceof ModelError) {\n      return error;\n    }\n\n    const errorMessage = getErrorMessage(error);\n    const errorCode = this.determineErrorCode(error);\n\n    // #4069: a param-naming 400 carries the offending param name in context, and\n    // counts as a would-have-self-healed event (the reactive #4071 path would catch\n    // exactly this 400). Only set for MODEL_PARAMETER_UNSUPPORTED — all other codes\n    // are unchanged.\n    const param =\n      errorCode === ErrorCode.MODEL_PARAMETER_UNSUPPORTED\n        ? this.extractErrorParam(error)\n        : undefined;\n    if (param !== undefined) {\n      recordWouldHaveSelfHealed(this.modelId, param);\n    }\n\n    const modelError = this.createModelError(errorMessage, errorCode, error, param);\n\n    this.logger.error('Model adapter error', modelError, {\n      errorCode,\n      providerId: this.providerId,\n      modelId: this.modelId,\n    });\n\n    return modelError;\n  }\n\n  /**\n   * Create a ModelError with appropriate error code.\n   */\n  private createModelError(\n    message: string,\n    errorCode: (typeof ErrorCode)[keyof typeof ErrorCode],\n    originalError: unknown,\n    param?: string\n  ): ModelError {\n    const fullMessage = `${this.providerId}/${this.modelId}: ${message}`;\n\n    // Build options object conditionally to satisfy exactOptionalPropertyTypes\n    const context: Record<string, unknown> = {\n      providerId: this.providerId,\n      modelId: this.modelId,\n    };\n    // #4069: surface the offending param name for a param-naming 400 so callers\n    // and the reactive self-heal path (#4071) can read which param to retry without.\n    if (param !== undefined) {\n      context.param = param;\n    }\n    const options: NexusErrorOptions = {\n      code: errorCode,\n      context,\n    };\n\n    // Only set cause if originalError is an Error\n    if (originalError instanceof Error) {\n      options.cause = originalError;\n    }\n\n    // AdapterModelError extends ModelError — no cast needed\n    return new AdapterModelError(fullMessage, options);\n  }\n\n  /**\n   * Determine the appropriate error code based on error characteristics.\n   */\n  private determineErrorCode(error: unknown): (typeof ErrorCode)[keyof typeof ErrorCode] {\n    if (!(error instanceof Error)) {\n      return ErrorCode.MODEL_ERROR;\n    }\n\n    const message = error.message.toLowerCase();\n    const errorObj = error as { status?: number; code?: string };\n\n    // Check for rate limiting (canonical detection from rate-limit-detector)\n    if (isRateLimitLikeError(error)) {\n      return ErrorCode.MODEL_RATE_LIMITED;\n    }\n\n    // Check for timeout\n    if (this.isTimeoutError(message, errorObj)) {\n      return ErrorCode.MODEL_TIMEOUT;\n    }\n\n    // Check for model-not-found (#2540 PR 8) — distinct from transient\n    // MODEL_UNAVAILABLE (502/503). 404 + vendor-specific phrases (\"model\n    // not found\", \"deprecated\", \"no such model\") all mean: this id is\n    // gone, retry won't help, route to a different one.\n    if (this.isModelNotFoundError(message, errorObj)) {\n      return ErrorCode.MODEL_NOT_FOUND;\n    }\n\n    // Check for model unavailable\n    if (this.isUnavailableError(message, errorObj)) {\n      return ErrorCode.MODEL_UNAVAILABLE;\n    }\n\n    // Check for a param-naming 400 (#4069): a 400 that identifies an unsupported\n    // parameter by name. Distinct from generic MODEL_ERROR — non-retryable, and the\n    // param name is threaded into context. Only changes 400s that NAME a param; a\n    // 400 with no param, and every non-400, stay MODEL_ERROR.\n    if (this.extractErrorParam(error) !== undefined) {\n      return ErrorCode.MODEL_PARAMETER_UNSUPPORTED;\n    }\n\n    return ErrorCode.MODEL_ERROR;\n  }\n\n  /**\n   * Extract the offending parameter name from a param-naming 400 (#4069).\n   *\n   * Returns the param only when the error is a 400 AND carries a non-empty `param`\n   * field (the OpenAI SDK / OpenAI-compatible gateways set this on a rejected\n   * parameter; the OpenAI adapter threads it onto the classification probe).\n   * Returns undefined otherwise, so non-400s and param-less 400s are untouched.\n   */\n  private extractErrorParam(error: unknown): string | undefined {\n    if (!(error instanceof Error)) {\n      return undefined;\n    }\n    const errorObj = error as { status?: number; param?: unknown };\n    if (errorObj.status !== 400) {\n      return undefined;\n    }\n    return typeof errorObj.param === 'string' && errorObj.param !== '' ? errorObj.param : undefined;\n  }\n\n  /**\n   * (#2540 PR 8) Detect model-retirement errors. Distinct from transient\n   * 502/503: 404 + vendor messages indicating the model id is gone.\n   */\n  private isModelNotFoundError(\n    message: string,\n    errorObj: { status?: number; code?: string }\n  ): boolean {\n    if (errorObj.status === 404) return true;\n    const patterns = [\n      'model not found',\n      'model_not_found',\n      'no such model',\n      'model is deprecated',\n      'model has been deprecated',\n      'model is no longer available',\n    ];\n    return patterns.some((p) => message.includes(p));\n  }\n\n  /**\n   * Check if error indicates a timeout.\n   */\n  private isTimeoutError(message: string, errorObj: { status?: number; code?: string }): boolean {\n    const timeoutPatterns = ['timeout', 'etimedout', 'esockettimedout'];\n    return (\n      errorObj.code === 'ETIMEDOUT' ||\n      errorObj.code === 'ESOCKETTIMEDOUT' ||\n      timeoutPatterns.some((pattern) => message.includes(pattern))\n    );\n  }\n\n  /**\n   * Check if error indicates model unavailability.\n   */\n  private isUnavailableError(\n    message: string,\n    errorObj: { status?: number; code?: string }\n  ): boolean {\n    const unavailablePatterns = ['unavailable', 'service unavailable', 'overloaded'];\n    return (\n      errorObj.status === 502 ||\n      errorObj.status === 503 ||\n      unavailablePatterns.some((pattern) => message.includes(pattern))\n    );\n  }\n}\n","/**\n * nexus-agents/adapters - Streaming Types and Core Utilities\n *\n * Shared types, errors, and core streaming primitives used by both\n * streaming.ts and stream-operators.ts to avoid circular dependencies.\n */\n\nimport { type Result, ok, err } from '../core/index.js';\nimport { NexusError, ErrorCode } from '../core/index.js';\n\n/**\n * Error thrown when a stream operation fails.\n */\nexport class StreamError extends NexusError {\n  constructor(message: string, options?: { cause?: Error; context?: Record<string, unknown> }) {\n    super(message, { code: ErrorCode.INTERNAL_ERROR, ...options });\n    this.name = 'StreamError';\n  }\n}\n\n/**\n * Error thrown when a stream is cancelled.\n */\nexport class StreamCancelledError extends NexusError {\n  constructor(reason?: string) {\n    super(reason ?? 'Stream was cancelled', { code: ErrorCode.INTERNAL_ERROR });\n    this.name = 'StreamCancelledError';\n  }\n}\n\n/**\n * State of a stream controller.\n */\nexport type StreamState = 'idle' | 'streaming' | 'paused' | 'cancelled' | 'completed' | 'error';\n\n/**\n * Options for creating a stream.\n */\nexport interface CreateStreamOptions {\n  /** AbortSignal for cancellation support */\n  signal?: AbortSignal;\n  /** Maximum buffer size for backpressure (default: 100) */\n  maxBufferSize?: number;\n}\n\n/**\n * Controller for managing stream lifecycle.\n * Provides push/complete/error methods and cancellation support.\n */\nexport class StreamController<T> {\n  private readonly chunks: T[] = [];\n  private readonly waiters: Array<{\n    resolve: (result: IteratorResult<T, void>) => void;\n    reject: (error: Error) => void;\n  }> = [];\n\n  private _state: StreamState = 'idle';\n  private _error: Error | undefined;\n  private readonly maxBufferSize: number;\n  private readonly abortHandler: (() => void) | undefined;\n  private readonly abortSignal: AbortSignal | undefined;\n\n  /**\n   * Creates a new StreamController.\n   * @param options - Stream creation options\n   */\n  constructor(options: CreateStreamOptions = {}) {\n    this.maxBufferSize = options.maxBufferSize ?? 100;\n\n    if (options.signal) {\n      this.abortSignal = options.signal;\n      this.abortHandler = (): void => {\n        this.cancel('AbortSignal triggered');\n      };\n      options.signal.addEventListener('abort', this.abortHandler);\n    }\n  }\n\n  /**\n   * Current state of the stream.\n   */\n  get state(): StreamState {\n    return this._state;\n  }\n\n  /**\n   * Whether the stream is still active (can receive chunks).\n   */\n  get isActive(): boolean {\n    return this._state === 'idle' || this._state === 'streaming' || this._state === 'paused';\n  }\n\n  /**\n   * Current buffer size.\n   */\n  get bufferSize(): number {\n    return this.chunks.length;\n  }\n\n  /**\n   * Push a chunk to the stream.\n   * @param chunk - The chunk to push\n   * @returns Result indicating success or backpressure\n   */\n  push(chunk: T): Result<void, StreamError> {\n    if (!this.isActive) {\n      return err(new StreamError(`Cannot push to stream in state: ${this._state}`));\n    }\n\n    if (this._state === 'idle') {\n      this._state = 'streaming';\n    }\n\n    // If there's a waiting consumer, deliver directly\n    const waiter = this.waiters.shift();\n    if (waiter) {\n      waiter.resolve({ done: false, value: chunk });\n      return ok(undefined);\n    }\n\n    // Check backpressure\n    if (this.chunks.length >= this.maxBufferSize) {\n      this._state = 'paused';\n      return err(\n        new StreamError('Buffer full - backpressure applied', {\n          context: { bufferSize: this.chunks.length, maxBufferSize: this.maxBufferSize },\n        })\n      );\n    }\n\n    this.chunks.push(chunk);\n    return ok(undefined);\n  }\n\n  /**\n   * Complete the stream successfully.\n   */\n  complete(): void {\n    if (!this.isActive) {\n      return;\n    }\n\n    this._state = 'completed';\n    this.removeAbortListener();\n    this.resolveAllWaiters();\n  }\n\n  /**\n   * Complete the stream with an error.\n   * @param error - The error that occurred\n   */\n  error(error: Error): void {\n    if (!this.isActive) {\n      return;\n    }\n\n    this._state = 'error';\n    this._error = error;\n    this.removeAbortListener();\n    this.rejectAllWaiters(error);\n  }\n\n  /**\n   * Cancel the stream.\n   * @param reason - Optional reason for cancellation\n   */\n  cancel(reason?: string): void {\n    if (!this.isActive) {\n      return;\n    }\n\n    this._state = 'cancelled';\n    this._error = new StreamCancelledError(reason);\n    this.removeAbortListener();\n    this.rejectAllWaiters(this._error);\n  }\n\n  /**\n   * Get the AsyncIterable for consuming the stream.\n   */\n  getIterable(): AsyncIterable<T> {\n    // Store reference to controller methods for closure\n    const nextChunk = (): Promise<IteratorResult<T, void>> => this.nextChunk();\n    const cancel = (reason: string): void => {\n      this.cancel(reason);\n    };\n\n    return {\n      [Symbol.asyncIterator](): AsyncIterator<T> {\n        return {\n          async next(): Promise<IteratorResult<T, void>> {\n            return nextChunk();\n          },\n          return(): Promise<IteratorResult<T, void>> {\n            cancel('Iterator returned');\n            return Promise.resolve({ done: true, value: undefined });\n          },\n        };\n      },\n    };\n  }\n\n  private async nextChunk(): Promise<IteratorResult<T, void>> {\n    // If we have buffered chunks, return one\n    const chunk = this.chunks.shift();\n    if (chunk !== undefined) {\n      // Resume if we were paused and buffer is now below threshold\n      if (this._state === 'paused' && this.chunks.length < this.maxBufferSize / 2) {\n        this._state = 'streaming';\n      }\n      return { done: false, value: chunk };\n    }\n\n    // Check terminal states\n    if (this._state === 'completed') {\n      return { done: true, value: undefined };\n    }\n\n    if (this._state === 'cancelled' || this._state === 'error') {\n      throw this._error ?? new StreamCancelledError();\n    }\n\n    // Wait for next chunk\n    return new Promise((resolve, reject) => {\n      this.waiters.push({ resolve, reject });\n    });\n  }\n\n  private removeAbortListener(): void {\n    if (this.abortSignal && this.abortHandler) {\n      this.abortSignal.removeEventListener('abort', this.abortHandler);\n    }\n  }\n\n  private resolveAllWaiters(): void {\n    for (const waiter of this.waiters) {\n      waiter.resolve({ done: true, value: undefined });\n    }\n    this.waiters.length = 0;\n  }\n\n  private rejectAllWaiters(error: Error): void {\n    for (const waiter of this.waiters) {\n      waiter.reject(error);\n    }\n    this.waiters.length = 0;\n  }\n}\n\n/**\n * Creates a controllable stream.\n * @param options - Stream creation options\n * @returns Tuple of [controller, iterable]\n */\nexport function createStream<T>(\n  options: CreateStreamOptions = {}\n): [StreamController<T>, AsyncIterable<T>] {\n  const controller = new StreamController<T>(options);\n  return [controller, controller.getIterable()];\n}\n","/**\n * nexus-agents/adapters - Stream Operators Helpers\n *\n * Helper functions for stream operations extracted for maintainability.\n */\n\nimport { type Result, ok, err } from '../core/index.js';\nimport { StreamError, StreamCancelledError } from './streaming-types.js';\n\n/**\n * Takes the first N chunks from a stream.\n * @param stream - The source stream\n * @param count - Number of chunks to take\n * @param options - Options including optional AbortSignal\n * @returns Stream of first N chunks\n */\nexport async function* take<T>(\n  stream: AsyncIterable<T>,\n  count: number,\n  options: { signal?: AbortSignal } = {}\n): AsyncIterable<T> {\n  if (count <= 0) {\n    return;\n  }\n\n  let taken = 0;\n\n  for await (const chunk of stream) {\n    if (options.signal?.aborted === true) {\n      throw new StreamCancelledError('take aborted');\n    }\n\n    yield chunk;\n    taken++;\n\n    if (taken >= count) {\n      return;\n    }\n  }\n}\n\n/**\n * Skips the first N chunks from a stream.\n * @param stream - The source stream\n * @param count - Number of chunks to skip\n * @param options - Options including optional AbortSignal\n * @returns Stream with first N chunks skipped\n */\nexport async function* skip<T>(\n  stream: AsyncIterable<T>,\n  count: number,\n  options: { signal?: AbortSignal } = {}\n): AsyncIterable<T> {\n  let skipped = 0;\n\n  for await (const chunk of stream) {\n    if (options.signal?.aborted === true) {\n      throw new StreamCancelledError('skip aborted');\n    }\n\n    if (skipped < count) {\n      skipped++;\n      continue;\n    }\n\n    yield chunk;\n  }\n}\n\n/**\n * Concatenates multiple streams sequentially.\n * @param streams - The streams to concatenate\n * @param options - Options including optional AbortSignal\n * @returns Concatenated stream\n */\nexport async function* concatStreams<T>(\n  streams: AsyncIterable<T>[],\n  options: { signal?: AbortSignal } = {}\n): AsyncIterable<T> {\n  for (const stream of streams) {\n    if (options.signal?.aborted === true) {\n      throw new StreamCancelledError('concat aborted');\n    }\n\n    yield* stream;\n  }\n}\n\n/**\n * Creates a stream from an array of values.\n * @param values - The values to stream\n * @param options - Options including optional delay between chunks\n * @returns Stream of values\n */\nexport async function* fromArray<T>(\n  values: T[],\n  options: { delayMs?: number; signal?: AbortSignal } = {}\n): AsyncIterable<T> {\n  for (const value of values) {\n    if (options.signal?.aborted === true) {\n      throw new StreamCancelledError('fromArray aborted');\n    }\n\n    if (options.delayMs !== undefined && options.delayMs > 0) {\n      await new Promise((resolve) => setTimeout(resolve, options.delayMs));\n    }\n\n    yield value;\n  }\n}\n\n/**\n * Taps into a stream without modifying it (for side effects like logging).\n * @param stream - The source stream\n * @param fn - Side effect function called for each chunk\n * @param options - Options including optional AbortSignal\n * @returns Original stream unchanged\n */\nexport async function* tapStream<T>(\n  stream: AsyncIterable<T>,\n  fn: (chunk: T, index: number) => void | Promise<void>,\n  options: { signal?: AbortSignal } = {}\n): AsyncIterable<T> {\n  let index = 0;\n\n  for await (const chunk of stream) {\n    if (options.signal?.aborted === true) {\n      throw new StreamCancelledError('tap aborted');\n    }\n\n    await fn(chunk, index);\n    yield chunk;\n    index++;\n  }\n}\n\n/**\n * Reduces a stream to a single value.\n * @param stream - The source stream\n * @param reducer - Reducer function\n * @param initialValue - Initial accumulator value\n * @param options - Options including optional AbortSignal\n * @returns Result containing the final value or error\n */\nexport async function reduceStream<T, U>(\n  stream: AsyncIterable<T>,\n  reducer: (accumulator: U, chunk: T, index: number) => U | Promise<U>,\n  initialValue: U,\n  options: { signal?: AbortSignal } = {}\n): Promise<Result<U, StreamError>> {\n  let accumulator = initialValue;\n  let index = 0;\n\n  try {\n    for await (const chunk of stream) {\n      if (options.signal?.aborted === true) {\n        return err(new StreamError('Reduce aborted'));\n      }\n\n      accumulator = await reducer(accumulator, chunk, index);\n      index++;\n    }\n\n    return ok(accumulator);\n  } catch (error) {\n    return err(\n      new StreamError('Failed to reduce stream', {\n        cause: error instanceof Error ? error : new Error(String(error)),\n      })\n    );\n  }\n}\n","/**\n * nexus-agents/adapters - Stream Operators\n *\n * Stream transformation operators for AsyncIterables.\n * Provides filter, map, merge, concat, buffer, and other stream operations.\n */\n\nimport { TimeoutError } from '../core/index.js';\nimport {\n  StreamError,\n  StreamCancelledError,\n  createStream,\n  type CreateStreamOptions,\n} from './streaming-types.js';\n\n// Re-export helper functions for backward compatibility\nexport {\n  take,\n  skip,\n  concatStreams,\n  fromArray,\n  tapStream,\n  reduceStream,\n} from './stream-operators-helpers.js';\n\n/**\n * Transforms stream chunks using a mapping function.\n * @param stream - The source stream\n * @param fn - Transformation function\n * @param options - Options including optional AbortSignal\n * @returns Transformed stream\n */\nexport async function* transformStream<T, U>(\n  stream: AsyncIterable<T>,\n  fn: (chunk: T, index: number) => U | Promise<U>,\n  options: { signal?: AbortSignal } = {}\n): AsyncIterable<U> {\n  let index = 0;\n\n  for await (const chunk of stream) {\n    if (options.signal?.aborted === true) {\n      throw new StreamCancelledError('Transform aborted');\n    }\n\n    yield await fn(chunk, index);\n    index++;\n  }\n}\n\n/**\n * Merges multiple streams into a single stream.\n * Chunks are yielded as they arrive from any source.\n * @param streams - The streams to merge\n * @param options - Options including optional AbortSignal\n * @returns Merged stream\n */\nexport async function* mergeStreams<T>(\n  streams: AsyncIterable<T>[],\n  options: { signal?: AbortSignal } = {}\n): AsyncIterable<T> {\n  if (streams.length === 0) {\n    return;\n  }\n\n  const streamOptions: CreateStreamOptions = {};\n  if (options.signal) {\n    streamOptions.signal = options.signal;\n  }\n  const [controller, merged] = createStream<T>(streamOptions);\n  let activeCount = streams.length;\n\n  // Start consuming all streams in parallel\n  const consumers = streams.map(async (stream, streamIndex) => {\n    try {\n      for await (const chunk of stream) {\n        if (options.signal?.aborted === true) {\n          break;\n        }\n        controller.push(chunk);\n      }\n    } catch (error) {\n      if (error instanceof StreamCancelledError) {\n        // Propagate cancellation\n        controller.cancel(`Stream ${String(streamIndex)} was cancelled`);\n        return;\n      }\n      controller.error(error instanceof Error ? error : new Error(String(error)));\n      return;\n    } finally {\n      activeCount--;\n      if (activeCount === 0) {\n        controller.complete();\n      }\n    }\n  });\n\n  // Start all consumers without blocking (Issue #541)\n  // Each consumer has try-catch that forwards errors to controller.error(),\n  // so Promise.all should always resolve. Add defensive catch for edge cases.\n  Promise.all(consumers).catch((error: unknown) => {\n    // This should not happen since each consumer catches its own errors,\n    // but handle it defensively to prevent silent failures.\n    controller.error(error instanceof Error ? error : new StreamError(String(error)));\n  });\n\n  yield* merged;\n}\n\n/**\n * Takes chunks from a stream until a predicate returns true.\n * @param stream - The source stream\n * @param predicate - Function that returns true to stop taking\n * @param options - Options including whether to include the matching chunk\n * @returns Stream of chunks up to (and optionally including) the match\n */\nexport async function* takeUntil<T>(\n  stream: AsyncIterable<T>,\n  predicate: (chunk: T, index: number) => boolean | Promise<boolean>,\n  options: { signal?: AbortSignal; inclusive?: boolean } = {}\n): AsyncIterable<T> {\n  let index = 0;\n\n  for await (const chunk of stream) {\n    if (options.signal?.aborted === true) {\n      throw new StreamCancelledError('takeUntil aborted');\n    }\n\n    const shouldStop = await predicate(chunk, index);\n\n    if (shouldStop) {\n      if (options.inclusive === true) {\n        yield chunk;\n      }\n      return;\n    }\n\n    yield chunk;\n    index++;\n  }\n}\n\n/**\n * Filters stream chunks based on a predicate.\n * @param stream - The source stream\n * @param predicate - Function that returns true to keep the chunk\n * @param options - Options including optional AbortSignal\n * @returns Filtered stream\n */\nexport async function* filterStream<T>(\n  stream: AsyncIterable<T>,\n  predicate: (chunk: T, index: number) => boolean | Promise<boolean>,\n  options: { signal?: AbortSignal } = {}\n): AsyncIterable<T> {\n  let index = 0;\n\n  for await (const chunk of stream) {\n    if (options.signal?.aborted === true) {\n      throw new StreamCancelledError('filter aborted');\n    }\n\n    if (await predicate(chunk, index)) {\n      yield chunk;\n    }\n\n    index++;\n  }\n}\n\n/**\n * Adds a timeout to a stream. If no chunk is received within the timeout,\n * the stream throws a TimeoutError.\n * @param stream - The source stream\n * @param timeoutMs - Timeout in milliseconds\n * @param options - Options including optional AbortSignal\n * @returns Stream with timeout applied\n */\nexport async function* withTimeout<T>(\n  stream: AsyncIterable<T>,\n  timeoutMs: number,\n  options: { signal?: AbortSignal } = {}\n): AsyncIterable<T> {\n  const iterator = stream[Symbol.asyncIterator]();\n\n  try {\n    let running = true;\n    while (running) {\n      if (options.signal?.aborted === true) {\n        throw new StreamCancelledError('withTimeout aborted');\n      }\n\n      let timeoutId: ReturnType<typeof setTimeout> | undefined;\n      try {\n        const result = await Promise.race([\n          iterator.next().then((res) => {\n            if (timeoutId !== undefined) {\n              clearTimeout(timeoutId);\n            }\n            return res;\n          }),\n          new Promise<never>((_, reject) => {\n            timeoutId = setTimeout(() => {\n              reject(\n                new TimeoutError(`Stream timed out after ${String(timeoutMs)}ms`, {\n                  context: { timeoutMs },\n                })\n              );\n            }, timeoutMs);\n          }),\n        ]);\n\n        if (result.done === true) {\n          running = false;\n        } else {\n          yield result.value;\n        }\n      } finally {\n        if (timeoutId !== undefined) {\n          clearTimeout(timeoutId);\n        }\n      }\n    }\n  } finally {\n    // Ensure the iterator is properly closed\n    if (iterator.return !== undefined) {\n      await iterator.return();\n    }\n  }\n}\n\n/**\n * Buffers stream chunks into groups of a specified size.\n * @param stream - The source stream\n * @param size - Buffer size\n * @param options - Options including optional AbortSignal\n * @returns Stream of chunk arrays\n */\nexport async function* bufferStream<T>(\n  stream: AsyncIterable<T>,\n  size: number,\n  options: { signal?: AbortSignal } = {}\n): AsyncIterable<T[]> {\n  if (size <= 0) {\n    throw new StreamError('Buffer size must be positive');\n  }\n\n  let buffer: T[] = [];\n\n  for await (const chunk of stream) {\n    if (options.signal?.aborted === true) {\n      throw new StreamCancelledError('buffer aborted');\n    }\n\n    buffer.push(chunk);\n\n    if (buffer.length >= size) {\n      yield buffer;\n      buffer = [];\n    }\n  }\n\n  // Yield remaining chunks\n  if (buffer.length > 0) {\n    yield buffer;\n  }\n}\n","/**\n * nexus-agents/adapters - Streaming Utilities\n *\n * AsyncIterator-based streaming utilities for model responses.\n * Provides stream creation, backpressure handling, cancellation support,\n * and chunk collection helpers.\n *\n * For stream transformation operators (map, filter, merge, etc.),\n * see ./stream-operators.ts\n */\n\nimport { type Result, ok, err } from '../core/index.js';\n\n// Re-export core streaming types and utilities from shared module\nexport {\n  StreamError,\n  StreamCancelledError,\n  StreamController,\n  createStream,\n  type StreamState,\n  type CreateStreamOptions,\n} from './streaming-types.js';\n\n// Import for use in this file\nimport { StreamError, StreamCancelledError } from './streaming-types.js';\n\n/**\n * Default cap on collected chunks — prevents unbounded memory growth when\n * callers forget to pass `maxChunks`. Callers that genuinely need no cap\n * must opt in explicitly with `{ maxChunks: Infinity }`. (#1913 Class F)\n */\nexport const DEFAULT_COLLECT_STREAM_MAX_CHUNKS = 100_000;\n\n/**\n * Collects all chunks from a stream into an array.\n *\n * @param stream - The stream to collect\n * @param options - Options including optional AbortSignal.\n *   `maxChunks` defaults to {@link DEFAULT_COLLECT_STREAM_MAX_CHUNKS} to\n *   prevent unbounded memory growth on forgotten limits. Pass\n *   `Infinity` explicitly for truly unbounded collection.\n * @returns Result containing collected chunks or error\n */\nexport async function collectStream<T>(\n  stream: AsyncIterable<T>,\n  options: { signal?: AbortSignal; maxChunks?: number } = {}\n): Promise<Result<T[], StreamError>> {\n  const chunks: T[] = [];\n  const maxChunks = options.maxChunks ?? DEFAULT_COLLECT_STREAM_MAX_CHUNKS;\n\n  try {\n    for await (const chunk of stream) {\n      if (options.signal?.aborted === true) {\n        return err(new StreamError('Collection aborted'));\n      }\n\n      chunks.push(chunk);\n\n      if (chunks.length >= maxChunks) {\n        break;\n      }\n    }\n\n    return ok(chunks);\n  } catch (error) {\n    if (error instanceof StreamCancelledError) {\n      return err(new StreamError('Stream was cancelled during collection', { cause: error }));\n    }\n    return err(\n      new StreamError('Failed to collect stream', {\n        cause: error instanceof Error ? error : new Error(String(error)),\n      })\n    );\n  }\n}\n\n// Re-export all stream operators for convenience\nexport {\n  transformStream,\n  mergeStreams,\n  takeUntil,\n  take,\n  skip,\n  filterStream,\n  withTimeout,\n  bufferStream,\n  concatStreams,\n  fromArray,\n  tapStream,\n  reduceStream,\n} from './stream-operators.js';\n"],"mappings":"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","names":[]}