fascicle 0.16.5 → 0.17.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (37) hide show
  1. package/CHANGELOG.md +49 -0
  2. package/README.md +3 -2
  3. package/dist/AGENTS.md +69 -18
  4. package/dist/acp.d.ts +1 -1
  5. package/dist/acp.js +6 -1
  6. package/dist/acp.js.map +1 -1
  7. package/dist/agents.d.ts +1 -1
  8. package/dist/{engine-B6rIIM4J.js → engine-BMdRqWL2.js} +988 -218
  9. package/dist/engine-BMdRqWL2.js.map +1 -0
  10. package/dist/index.d.ts +108 -16
  11. package/dist/index.js +225 -16
  12. package/dist/index.js.map +1 -1
  13. package/dist/{invoke-LbzZLZFw.js → invoke-BbJLQcLl.js} +62 -106
  14. package/dist/invoke-BbJLQcLl.js.map +1 -0
  15. package/dist/{leading_system-WhW76tRn.js → leading_system-DmNxhvzL.js} +45 -16
  16. package/dist/leading_system-DmNxhvzL.js.map +1 -0
  17. package/dist/mcp.d.ts +2 -1
  18. package/dist/mcp.js +6 -3
  19. package/dist/mcp.js.map +1 -1
  20. package/dist/otel.js +48 -3
  21. package/dist/otel.js.map +1 -1
  22. package/dist/testing.d.ts +77 -2
  23. package/dist/testing.js +202 -19
  24. package/dist/testing.js.map +1 -1
  25. package/dist/{types-Sw0oHW-_.d.ts → types-BNgAUQP1.d.ts} +170 -17
  26. package/dist/viewer-app/assets/index-9eVv6Mar.css +1 -0
  27. package/dist/viewer-app/assets/index-BkS2ZQu0.js +4 -0
  28. package/dist/viewer-app/index.html +2 -2
  29. package/dist/viewer.d.ts +37 -10
  30. package/dist/viewer.js +101 -46
  31. package/dist/viewer.js.map +1 -1
  32. package/package.json +1 -1
  33. package/dist/engine-B6rIIM4J.js.map +0 -1
  34. package/dist/invoke-LbzZLZFw.js.map +0 -1
  35. package/dist/leading_system-WhW76tRn.js.map +0 -1
  36. package/dist/viewer-app/assets/index-Cev83tcH.css +0 -1
  37. package/dist/viewer-app/assets/index-D8UmFVfR.js +0 -2
@@ -1,6 +1,6 @@
1
1
  import { k as aborted_error } from "./core-BOFcG3tp.js";
2
- import { a as is_own_reasoning, d as load_optional_peer, t as split_leading_system_run, u as default_normalize_usage } from "./leading_system-WhW76tRn.js";
3
- import { NoObjectGeneratedError, Output, generateText, isStepCount, streamText, tool } from "ai";
2
+ import { a as is_own_reasoning, d as default_normalize_usage, f as load_optional_peer, s as network_failure, t as split_leading_system_run } from "./leading_system-DmNxhvzL.js";
3
+ import { Output, isStepCount, streamText, tool } from "ai";
4
4
  //#region src/engine/providers/ai_sdk/telemetry.ts
5
5
  /**
6
6
  * Build the AI SDK's `experimental_telemetry` option from engine settings,
@@ -23,7 +23,8 @@ async function build_ai_sdk_telemetry(settings) {
23
23
  /**
24
24
  * The ai_sdk transport: the engine's only Vercel AI SDK call site.
25
25
  *
26
- * Only this module imports from `ai` or invokes generateText / streamText.
26
+ * Only this module imports from `ai` or invokes streamText, which every
27
+ * turn takes, whether or not a consumer is attached.
27
28
  * generate.ts drives this transport through create_ai_sdk_turn and stays
28
29
  * SDK-agnostic; run_tool_loop sees the same neutral TurnResult a native
29
30
  * adapter produces. Enforced by rules/no-ai-import-outside-ai-sdk-provider.yml.
@@ -145,6 +146,26 @@ function to_provider_reported(metadata) {
145
146
  return reported;
146
147
  }
147
148
  /**
149
+ * Map a tool result to the SDK's tool message. A failed call's result goes as
150
+ * `error-text`, a denial included, since @ai-sdk/anthropic turns `error-text`
151
+ * into `is_error` and drops the flag for `execution-denied`; a success's goes
152
+ * as `text`.
153
+ */
154
+ function to_sdk_tool_message(m) {
155
+ return {
156
+ role: "tool",
157
+ content: [{
158
+ type: "tool-result",
159
+ toolCallId: m.tool_call_id,
160
+ toolName: m.name,
161
+ output: {
162
+ type: m.is_error === true ? "error-text" : "text",
163
+ value: m.content
164
+ }
165
+ }]
166
+ };
167
+ }
168
+ /**
148
169
  * Map Fascicle's Message[] to the AI SDK's ModelMessage[] shape. Each
149
170
  * assistant part's provider_options go back as its providerOptions, which is
150
171
  * where the SDK reads a signature or a thought signature back from, and a
@@ -188,18 +209,7 @@ function to_sdk_messages(messages, metadata_key) {
188
209
  continue;
189
210
  }
190
211
  if (m.role === "tool") {
191
- out.push({
192
- role: "tool",
193
- content: [{
194
- type: "tool-result",
195
- toolCallId: m.tool_call_id,
196
- toolName: m.name,
197
- output: {
198
- type: "text",
199
- value: m.content
200
- }
201
- }]
202
- });
212
+ out.push(to_sdk_tool_message(m));
203
213
  continue;
204
214
  }
205
215
  if (typeof m.content === "string") {
@@ -221,6 +231,7 @@ function to_sdk_messages(messages, metadata_key) {
221
231
  text: p.text
222
232
  }, p.provider_options)];
223
233
  }
234
+ if (p.type === "opaque") return [];
224
235
  return [with_provider_options({
225
236
  type: "tool-call",
226
237
  toolCallId: p.id,
@@ -322,9 +333,11 @@ function to_sdk_tools(tools) {
322
333
  }
323
334
  /**
324
335
  * Map one AI SDK stream part to the engine's StreamChunk shape, or undefined
325
- * for a part kind the engine does not model.
336
+ * for a part kind the engine does not model. A finish-step's usage goes
337
+ * through `normalize_usage` with the step's providerMetadata, the adapter's
338
+ * own mapper on a turn, so the step_finish chunk and the step record agree.
326
339
  */
327
- function map_stream_part_to_chunk(part, step_index) {
340
+ function map_stream_part_to_chunk(part, step_index, normalize_usage = default_normalize_usage) {
328
341
  switch (part.type) {
329
342
  case "text-delta": return {
330
343
  kind: "text",
@@ -358,25 +371,19 @@ function map_stream_part_to_chunk(part, step_index) {
358
371
  kind: "step_finish",
359
372
  step_index,
360
373
  finish_reason: map_finish_reason(part.finishReason),
361
- usage: default_usage_from_sdk(part.usage)
374
+ usage: normalize_usage(to_raw_provider_usage(part.usage), part.providerMetadata)
362
375
  };
363
376
  default: return;
364
377
  }
365
378
  }
366
379
  /**
367
- * Normalize a raw AI SDK usage object into UsageTotals for a streamed
368
- * step_finish chunk.
369
- */
370
- function default_usage_from_sdk(usage) {
371
- return default_normalize_usage(to_raw_provider_usage(usage));
372
- }
373
- /**
374
380
  * Fold one stream part's accumulated state into `acc`: text deltas append,
375
381
  * tool-call parts push a RawToolCall, and the finish-step overwrites finish
376
- * reason, usage, and provider_reported. The finish-step's providerMetadata is
377
- * the same value generateText returns on its result, which is what keeps a
378
- * streamed run's provider_reported identical to a plain run's. Parts with no
379
- * accumulated state (error, abort, stream framing) are the caller's to handle.
382
+ * reason, usage, and provider_reported. A finish-step of 'other' with no raw
383
+ * finish reason is what a provider package reports when its stream ended
384
+ * before the provider said why, so it marks the stream as cut off. Parts with
385
+ * no accumulated state (error, abort, stream framing) are the caller's to
386
+ * handle.
380
387
  */
381
388
  function accumulate_stream_part(part, acc) {
382
389
  if (part.type === "text-delta") {
@@ -395,32 +402,40 @@ function accumulate_stream_part(part, acc) {
395
402
  acc.finish_reason = map_finish_reason(part.finishReason);
396
403
  acc.raw_usage = to_raw_provider_usage(part.usage);
397
404
  acc.provider_reported = to_provider_reported(part.providerMetadata);
405
+ acc.cut_off = part.finishReason === "other" && part.rawFinishReason === void 0;
398
406
  }
399
407
  }
400
408
  /**
401
409
  * Run one streamText call, dispatching StreamChunks as parts arrive and
402
- * accumulating them into a TurnResult once the stream completes.
410
+ * accumulating them into a TurnResult once the stream completes. Every turn
411
+ * takes this path, so the dispatcher passes chunks on only when a consumer
412
+ * is attached. A failure reaches the engine through the stream's error part,
413
+ * so `onError` stays quiet rather than writing each one to console.error. A
414
+ * stream cut off before the step finished throws the network shape, which
415
+ * the engine retries when nothing consumed the chunks. Structured output is
416
+ * parsed by the engine's own schema loop, since streamText parses `output`
417
+ * only when it is read, which this never does.
403
418
  */
404
- async function collect_stream(params, step_index, dispatcher, on_first_chunk, internal_controller, adapter) {
405
- const stream_result = streamText(params);
419
+ async function collect_stream(params, step_index, dispatcher, observe_chunk, internal_controller, adapter) {
420
+ const stream_result = streamText({
421
+ ...params,
422
+ onError: () => {}
423
+ });
406
424
  const acc = {
407
425
  text: "",
408
426
  tool_calls: [],
409
427
  finish_reason: "stop",
410
428
  raw_usage: {},
411
- provider_reported: void 0
429
+ provider_reported: void 0,
430
+ cut_off: false
412
431
  };
413
- let first = true;
414
432
  for await (const part of stream_result.stream) {
415
433
  accumulate_stream_part(part, acc);
416
434
  if (part.type === "error") throw part.error;
417
435
  if (part.type === "abort") throw new aborted_error("aborted", { step_index });
418
- const chunk = map_stream_part_to_chunk(part, step_index);
436
+ const chunk = map_stream_part_to_chunk(part, step_index, adapter.normalize_usage);
419
437
  if (chunk === void 0) continue;
420
- if (first) {
421
- first = false;
422
- on_first_chunk();
423
- }
438
+ observe_chunk(chunk);
424
439
  try {
425
440
  await dispatcher.dispatch(chunk);
426
441
  } catch (err) {
@@ -428,79 +443,21 @@ async function collect_stream(params, step_index, dispatcher, on_first_chunk, in
428
443
  throw err;
429
444
  }
430
445
  }
446
+ if (acc.cut_off) throw network_failure(`${adapter.name} stream ended before the step finished; the result would be truncated`);
431
447
  const content = to_turn_content(await stream_result.content);
432
448
  return {
433
449
  text: acc.text,
434
450
  tool_calls: acc.tool_calls,
435
451
  finish_reason: acc.finish_reason,
436
- usage: adapter.normalize_usage(acc.raw_usage),
452
+ usage: adapter.normalize_usage(acc.raw_usage, acc.provider_reported),
437
453
  ...acc.provider_reported !== void 0 ? { provider_reported: acc.provider_reported } : {},
438
454
  ...content !== void 0 ? { content } : {}
439
455
  };
440
456
  }
441
457
  /**
442
- * Run one generateText call and map its result into a TurnResult, recovering
443
- * a schema-validation failure from the SDK via recover_no_object_generated
444
- * instead of letting it throw.
445
- */
446
- async function collect_non_stream(params, adapter) {
447
- let result;
448
- try {
449
- result = await generateText(params);
450
- } catch (err) {
451
- const recovered = recover_no_object_generated(err, adapter);
452
- if (recovered !== void 0) return recovered;
453
- throw err;
454
- }
455
- const tool_calls = [];
456
- for (const tc of result.toolCalls) tool_calls.push({
457
- id: tc.toolCallId,
458
- name: tc.toolName,
459
- input: tc.input
460
- });
461
- const raw_usage = to_raw_provider_usage(result.usage);
462
- const provider_reported = to_provider_reported(result.providerMetadata);
463
- const content = to_turn_content(result.content);
464
- return {
465
- text: result.text,
466
- tool_calls,
467
- finish_reason: map_finish_reason(result.finishReason),
468
- usage: adapter.normalize_usage(raw_usage),
469
- ...provider_reported !== void 0 ? { provider_reported } : {},
470
- ...content !== void 0 ? { content } : {}
471
- };
472
- }
473
- /**
474
- * When `output` (structured output) is in play, `generateText` eagerly parses the
475
- * model's text against the schema and throws `NoObjectGeneratedError` if it
476
- * does not conform. That parse is the SDK's, not Fascicle's: turning it into a
477
- * thrown error would skip the engine's own schema-parse + repair loop (and the
478
- * error is not a retryable transient, so it would surface raw). Instead we
479
- * recover the model's raw text from the error and hand it back as a normal
480
- * turn result, so `parse_with_schema` re-validates it and the repair loop
481
- * engages exactly as it does for the prompt-based path. Returns undefined for
482
- * any other error so the caller rethrows.
483
- *
484
- * The recovered turn carries no provider_reported: the SDK's error exposes
485
- * text, usage, finishReason and response metadata, but not providerMetadata,
486
- * so there is nothing to read. The repair turn that follows reports normally.
487
- */
488
- function recover_no_object_generated(err, adapter) {
489
- if (!NoObjectGeneratedError.isInstance(err)) return void 0;
490
- const text_field = Reflect.get(err, "text");
491
- const finish_field = Reflect.get(err, "finishReason");
492
- const raw_usage = to_raw_provider_usage(Reflect.get(err, "usage"));
493
- return {
494
- text: typeof text_field === "string" ? text_field : "",
495
- tool_calls: [],
496
- finish_reason: map_finish_reason(typeof finish_field === "string" ? finish_field : void 0),
497
- usage: adapter.normalize_usage(raw_usage)
498
- };
499
- }
500
- /**
501
- * Build the single-attempt SDK turn for one generate call: the
502
- * generateText/streamText call body behind the same neutral seam a native
503
- * adapter's invoke_turn implements. The built model is memoized across steps
458
+ * Build the single-attempt SDK turn for one generate call: the streamText
459
+ * call body behind the same neutral seam a native adapter's invoke_turn
460
+ * implements. The built model is memoized across steps
504
461
  * of one generate call. No retry here: generate.ts wraps the returned turn in
505
462
  * the engine-owned retry_turn.
506
463
  */
@@ -550,14 +507,13 @@ function create_ai_sdk_turn(cfg) {
550
507
  if (cfg.reasoning !== void 0) base_params.reasoning = cfg.reasoning;
551
508
  if (telemetry !== void 0) base_params.experimental_telemetry = telemetry;
552
509
  try {
553
- if (args.stream) return await collect_stream(base_params, args.step_index, cfg.dispatcher, args.on_first_chunk, internal_controller, cfg.adapter);
554
- return await collect_non_stream(base_params, cfg.adapter);
510
+ return await collect_stream(base_params, args.step_index, cfg.dispatcher, args.observe_chunk, internal_controller, cfg.adapter);
555
511
  } finally {
556
512
  args.abort.removeEventListener("abort", cancel_on_user_abort);
557
513
  }
558
514
  };
559
515
  }
560
516
  //#endregion
561
- export { create_ai_sdk_turn, default_usage_from_sdk, map_finish_reason, map_stream_part_to_chunk, split_leading_system, to_provider_reported, to_raw_provider_usage, to_sdk_messages, to_sdk_tools, to_turn_content };
517
+ export { create_ai_sdk_turn, map_finish_reason, map_stream_part_to_chunk, split_leading_system, to_provider_reported, to_raw_provider_usage, to_sdk_messages, to_sdk_tools, to_turn_content };
562
518
 
563
- //# sourceMappingURL=invoke-LbzZLZFw.js.map
519
+ //# sourceMappingURL=invoke-BbJLQcLl.js.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"invoke-BbJLQcLl.js","names":["ai_tool"],"sources":["../src/engine/providers/ai_sdk/telemetry.ts","../src/engine/providers/ai_sdk/invoke.ts"],"sourcesContent":["/**\n * AI SDK telemetry wiring, confined to the ai_sdk transport.\n *\n * `@ai-sdk/otel` is adopted strictly below the turn seam: it instruments one\n * turn inside this module, never the loop. The peer is loaded lazily and only\n * when telemetry is explicitly enabled, so the disabled default (every call\n * that does not opt in) pulls in nothing.\n *\n * This is the ONLY place `@ai-sdk/otel` is referenced. generate.ts and\n * create_engine.ts thread a plain `AiSdkTelemetrySettings` value through the\n * seam and stay SDK-agnostic; loop-level, transport-neutral tracing is the\n * separate `fascicle/otel` bridge.\n */\n\nimport type { AiSdkTelemetrySettings } from '../../types.js'\nimport { load_optional_peer } from '../types.js'\n\ntype OpenTelemetryCtor = new (options?: { tracer?: unknown }) => unknown\n\ntype AiSdkOtelModule = {\n readonly OpenTelemetry: OpenTelemetryCtor\n}\n\n/**\n * The subset of the AI SDK's telemetry option shape this module produces, using\n * the SDK's own (camelCase) keys. Cast onto `experimental_telemetry` at the\n * call site.\n */\nexport type AiSdkTelemetryPassthrough = {\n isEnabled: true\n integrations: unknown[]\n functionId?: string\n recordInputs?: boolean\n recordOutputs?: boolean\n metadata?: Readonly<Record<string, string | number | boolean>>\n}\n\n/**\n * Build the AI SDK's `experimental_telemetry` option from engine settings,\n * loading the `@ai-sdk/otel` peer only when telemetry is enabled.\n */\nexport async function build_ai_sdk_telemetry(\n settings: AiSdkTelemetrySettings | undefined,\n): Promise<AiSdkTelemetryPassthrough | undefined> {\n if (!settings?.enabled) return undefined\n const mod = await load_optional_peer<AiSdkOtelModule>('@ai-sdk/otel')\n const integration = new mod.OpenTelemetry(\n settings.tracer !== undefined ? { tracer: settings.tracer } : {},\n )\n const out: AiSdkTelemetryPassthrough = { isEnabled: true, integrations: [integration] }\n if (settings.function_id !== undefined) out.functionId = settings.function_id\n if (settings.record_inputs !== undefined) out.recordInputs = settings.record_inputs\n if (settings.record_outputs !== undefined) out.recordOutputs = settings.record_outputs\n if (settings.metadata !== undefined) out.metadata = settings.metadata\n return out\n}\n","/**\n * The ai_sdk transport: the engine's only Vercel AI SDK call site.\n *\n * Only this module imports from `ai` or invokes streamText, which every\n * turn takes, whether or not a consumer is attached.\n * generate.ts drives this transport through create_ai_sdk_turn and stays\n * SDK-agnostic; run_tool_loop sees the same neutral TurnResult a native\n * adapter produces. Enforced by rules/no-ai-import-outside-ai-sdk-provider.yml.\n *\n * Retry stays out of this module on purpose: generate.ts wraps the turn\n * returned here in the engine-owned retry_turn, exactly as it wraps a native\n * adapter's invoke_turn. This module owns request/response mapping only.\n */\n\nimport {\n Output,\n isStepCount,\n streamText,\n tool as ai_tool,\n type AssistantContent,\n type ContentPart,\n type ImagePart,\n type LanguageModel,\n type ModelMessage,\n type TextPart,\n type TextStreamPart,\n type ToolCallPart,\n type ToolSet,\n} from 'ai'\nimport type { ToolSchema } from '#schema'\nimport type {\n AiSdkTelemetrySettings,\n AssistantContentPart,\n FinishReason,\n Message,\n ProviderOptions,\n StreamChunk,\n Tool,\n TurnResult,\n} from '../../types.js'\nimport { aborted_error } from '../../errors.js'\nimport { split_leading_system_run } from '../../leading_system.js'\nimport type { ChunkDispatcher } from '../../streaming.js'\nimport type { RawToolCall } from '../../tool_loop.js'\nimport {\n default_normalize_usage,\n type AiSdkProviderAdapter,\n type EffortTranslation,\n type RawProviderUsage,\n} from '../types.js'\nimport { is_own_reasoning, network_failure } from '../native_shared.js'\nimport { build_ai_sdk_telemetry, type AiSdkTelemetryPassthrough } from './telemetry.js'\n\n// The SDK exports no name for an assistant reasoning part, so it is read off\n// the assistant content union.\ntype SdkReasoningPart = Extract<Exclude<AssistantContent, string>[number], { type: 'reasoning' }>\n\n/**\n * Attach a Fascicle part's provider_options to an SDK prompt part as its\n * providerOptions, the key the SDK reads a part's provider data back from.\n */\nfunction with_provider_options<part extends { providerOptions?: TextPart['providerOptions'] }>(\n sdk_part: part,\n provider_options: ProviderOptions | undefined,\n): part {\n if (provider_options === undefined) return sdk_part\n // ProviderOptions is the two-level provider map the SDK's shared provider\n // options spell with JSON values; the payloads are the SDK's own metadata.\n // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion\n return { ...sdk_part, providerOptions: provider_options as NonNullable<part['providerOptions']> }\n}\n\n/**\n * Map the AI SDK's finish reason string to the engine's FinishReason.\n */\nexport function map_finish_reason(raw: string | undefined): FinishReason {\n switch (raw) {\n case 'stop':\n return 'stop'\n case 'length':\n return 'length'\n case 'content-filter':\n case 'content_filter':\n return 'content_filter'\n case 'tool-calls':\n case 'tool_calls':\n return 'tool_calls'\n default:\n return 'stop'\n }\n}\n\n/**\n * Read a numeric field off an object by key, or undefined when it is absent or\n * not a number. The single typeof guard behind every usage-field read below.\n */\nfunction read_number(source: object, key: string): number | undefined {\n const value = Reflect.get(source, key)\n return typeof value === 'number' ? value : undefined\n}\n\n/**\n * Read the AI SDK's nested `inputTokenDetails` (cache read/write counts) onto\n * `raw`. Present-but-empty details still seed `input_token_details` so the\n * \"the SDK reported details\" signal survives even when both counts are absent.\n */\nfunction read_input_details(usage: object, raw: RawProviderUsage): void {\n const details = Reflect.get(usage, 'inputTokenDetails')\n if (details === null || typeof details !== 'object') return\n raw.input_token_details = {}\n const cache_read = read_number(details, 'cacheReadTokens')\n if (cache_read !== undefined) raw.input_token_details.cached_tokens = cache_read\n const cache_write = read_number(details, 'cacheWriteTokens')\n if (cache_write !== undefined) raw.input_token_details.cache_creation_input_tokens = cache_write\n}\n\n/**\n * Read the AI SDK's nested `outputTokenDetails` (reasoning-token count) onto\n * `raw`, seeding `output_token_details` whenever the details object is present.\n */\nfunction read_output_details(usage: object, raw: RawProviderUsage): void {\n const details = Reflect.get(usage, 'outputTokenDetails')\n if (details === null || typeof details !== 'object') return\n raw.output_token_details = {}\n const reasoning = read_number(details, 'reasoningTokens')\n if (reasoning !== undefined) raw.output_token_details.reasoning_tokens = reasoning\n}\n\n/**\n * Read the flattened snake_case usage fields some provider mocks return\n * directly. The `input_tokens`/`output_tokens` flats are fallbacks: they fill\n * in only when the camelCase read did not already set the same total.\n */\nfunction read_flat_usage(usage: object, raw: RawProviderUsage): void {\n const cached = read_number(usage, 'cached_input_tokens')\n if (cached !== undefined) raw.cached_input_tokens = cached\n const cache_write = read_number(usage, 'cache_write_tokens')\n if (cache_write !== undefined) raw.cache_write_tokens = cache_write\n const reasoning = read_number(usage, 'reasoning_tokens')\n if (reasoning !== undefined) raw.reasoning_tokens = reasoning\n const input_flat = read_number(usage, 'input_tokens')\n if (raw.input_tokens === undefined && input_flat !== undefined) raw.input_tokens = input_flat\n const output_flat = read_number(usage, 'output_tokens')\n if (raw.output_tokens === undefined && output_flat !== undefined) raw.output_tokens = output_flat\n}\n\n/**\n * Extract the usage fields `default_normalize_usage` understands from an AI\n * SDK usage object, tolerating both the SDK's camelCase shape and the\n * flattened snake_case fields some provider mocks return directly.\n */\nexport function to_raw_provider_usage(usage: unknown): RawProviderUsage {\n if (usage === null || typeof usage !== 'object') return {}\n const raw: RawProviderUsage = {}\n const input_tokens = read_number(usage, 'inputTokens')\n if (input_tokens !== undefined) raw.input_tokens = input_tokens\n const output_tokens = read_number(usage, 'outputTokens')\n if (output_tokens !== undefined) raw.output_tokens = output_tokens\n read_input_details(usage, raw)\n read_output_details(usage, raw)\n read_flat_usage(usage, raw)\n return raw\n}\n\n/**\n * Normalize an AI SDK `providerMetadata` value into the neutral\n * TurnResult.provider_reported shape.\n *\n * The SDK's metadata is already keyed by provider name, which is the shape\n * provider_reported documents, so the keys ride through untranslated and every\n * ai_sdk provider is served by this one seam: bedrock's guardrail `trace`,\n * anthropic's cache detail, openai's own fields. The payloads stay opaque\n * (callers narrow them at the use site), so this copies the top level and\n * inspects nothing below it. An absent or empty map returns undefined, keeping\n * \"the provider reported nothing\" spelled one way.\n */\nexport function to_provider_reported(metadata: unknown): Record<string, unknown> | undefined {\n if (metadata === null || typeof metadata !== 'object') return undefined\n const keys = Object.keys(metadata)\n if (keys.length === 0) return undefined\n const reported: Record<string, unknown> = {}\n for (const key of keys) reported[key] = Reflect.get(metadata, key)\n return reported\n}\n\n/**\n * Map a tool result to the SDK's tool message. A failed call's result goes as\n * `error-text`, a denial included, since @ai-sdk/anthropic turns `error-text`\n * into `is_error` and drops the flag for `execution-denied`; a success's goes\n * as `text`.\n */\nfunction to_sdk_tool_message(m: Extract<Message, { role: 'tool' }>): ModelMessage {\n return {\n role: 'tool',\n content: [\n {\n type: 'tool-result',\n toolCallId: m.tool_call_id,\n toolName: m.name,\n output: { type: m.is_error === true ? 'error-text' : 'text', value: m.content },\n },\n ],\n }\n}\n\n/**\n * Map Fascicle's Message[] to the AI SDK's ModelMessage[] shape. Each\n * assistant part's provider_options go back as its providerOptions, which is\n * where the SDK reads a signature or a thought signature back from, and a\n * reasoning part goes back only when it carries data under `metadata_key`,\n * the key the adapter's package writes, so a turn only ever sends back its\n * own provider's reasoning.\n */\nexport function to_sdk_messages(\n messages: ReadonlyArray<Message>,\n metadata_key: string,\n): ModelMessage[] {\n const out: ModelMessage[] = []\n for (const m of messages) {\n if (m.role === 'system') {\n out.push({ role: 'system', content: m.content })\n continue\n }\n if (m.role === 'user') {\n if (typeof m.content === 'string') {\n out.push({ role: 'user', content: m.content })\n } else {\n const parts: Array<TextPart | ImagePart> = m.content.map((p) => {\n if (p.type === 'text') {\n return with_provider_options<TextPart>({ type: 'text', text: p.text }, p.provider_options)\n }\n const image_part: ImagePart = { type: 'image', image: p.image }\n if (p.media_type !== undefined) image_part.mediaType = p.media_type\n return with_provider_options(image_part, p.provider_options)\n })\n out.push({ role: 'user', content: parts })\n }\n continue\n }\n if (m.role === 'tool') {\n out.push(to_sdk_tool_message(m))\n continue\n }\n // assistant\n if (typeof m.content === 'string') {\n out.push({ role: 'assistant', content: m.content })\n continue\n }\n const parts = m.content.flatMap((p): Array<TextPart | SdkReasoningPart | ToolCallPart> => {\n if (p.type === 'text') {\n return [with_provider_options<TextPart>({ type: 'text', text: p.text }, p.provider_options)]\n }\n if (p.type === 'reasoning') {\n // Another package's reasoning, or reasoning with no data, would draw a\n // warning or a refusal from this one.\n if (!is_own_reasoning(p, metadata_key)) return []\n return [\n with_provider_options<SdkReasoningPart>(\n { type: 'reasoning', text: p.text },\n p.provider_options,\n ),\n ]\n }\n // A block only its provider understands has no SDK part to ride.\n if (p.type === 'opaque') return []\n return [\n with_provider_options<ToolCallPart>(\n { type: 'tool-call', toolCallId: p.id, toolName: p.name, input: p.input },\n p.provider_options,\n ),\n ]\n })\n out.push({ role: 'assistant', content: parts })\n }\n return out\n}\n\n/**\n * Hoist a leading run of system messages out of the SDK message list into the\n * AI SDK's top-level `system` option.\n *\n * Passing a `role: 'system'` entry inside `messages` makes the AI SDK treat it\n * as potentially attacker-controlled: it warns on every call (and newer `ai`\n * versions throw unless `allowSystemInMessages` is set). Fascicle's system\n * content is the developer's own prompt, and the SDK's own recommendation is to\n * deliver it through the top-level `instructions` option (v7's rename of the\n * former `system` option), which removes the warning at its source rather than\n * suppressing it.\n *\n * Only the *leading* run is hoisted (Fascicle's only shape: one or more system\n * messages, then the conversation). A system message that appears after a\n * non-system message keeps its position rather than being silently reordered to\n * the top, and the original list is returned untouched when hoisting would leave\n * `messages` empty, since the SDK rejects an empty messages array.\n */\nexport function split_leading_system(messages: ReadonlyArray<ModelMessage>): {\n system?: string\n messages: ModelMessage[]\n} {\n return split_leading_system_run(messages, (m) => m.content)\n}\n\n/**\n * Read a part's providerMetadata as provider_options, or undefined when it\n * carries none, so a part with nothing to send back stays bare.\n */\nfunction to_part_options(metadata: ProviderOptions | undefined): ProviderOptions | undefined {\n return metadata !== undefined && Object.keys(metadata).length > 0 ? metadata : undefined\n}\n\n/**\n * Map one SDK content part to an assistant part with its providerMetadata as\n * provider_options, or undefined for a kind with nothing to send back\n * (sources, files, tool results).\n */\nfunction to_turn_part(part: ContentPart<ToolSet>): AssistantContentPart | undefined {\n if (part.type === 'text') {\n return with_part_options({ type: 'text', text: part.text }, part.providerMetadata)\n }\n if (part.type === 'reasoning') {\n return with_part_options({ type: 'reasoning', text: part.text }, part.providerMetadata)\n }\n if (part.type === 'tool-call') {\n return with_part_options(\n { type: 'tool_call', id: part.toolCallId, name: part.toolName, input: part.input },\n part.providerMetadata,\n )\n }\n return undefined\n}\n\n/**\n * Give an assistant part the provider_options its metadata carries, leaving\n * the key off when there is none.\n */\nfunction with_part_options<part extends AssistantContentPart>(\n turn_part: part,\n metadata: ProviderOptions | undefined,\n): part {\n const provider_options = to_part_options(metadata)\n return provider_options === undefined ? turn_part : { ...turn_part, provider_options }\n}\n\n/**\n * Map an SDK step's content to TurnResult.content: its text, reasoning, and\n * tool calls in the order the provider sent them, each with its\n * providerMetadata as provider_options. Undefined when no part is reasoning\n * or carries data, so every other turn stays exactly what it was.\n */\nexport function to_turn_content(\n content: ReadonlyArray<ContentPart<ToolSet>>,\n): AssistantContentPart[] | undefined {\n const parts = content.flatMap((part) => to_turn_part(part) ?? [])\n const carries = parts.some(\n (part) => part.type === 'reasoning' || part.provider_options !== undefined,\n )\n return carries ? parts : undefined\n}\n\n/**\n * Map Fascicle's Tool[] to the AI SDK's ToolSet.\n *\n * Returns undefined for an empty tool list so the caller can omit `tools`\n * from the call params entirely instead of passing an empty object.\n */\nexport function to_sdk_tools(tools: ReadonlyArray<Tool>): ToolSet | undefined {\n if (tools.length === 0) return undefined\n const entries: ToolSet = {}\n for (const t of tools) {\n entries[t.name] = ai_tool({\n description: t.description,\n inputSchema: t.input_schema,\n })\n }\n return entries\n}\n\n/**\n * Map one AI SDK stream part to the engine's StreamChunk shape, or undefined\n * for a part kind the engine does not model. A finish-step's usage goes\n * through `normalize_usage` with the step's providerMetadata, the adapter's\n * own mapper on a turn, so the step_finish chunk and the step record agree.\n */\nexport function map_stream_part_to_chunk(\n part: TextStreamPart<ToolSet>,\n step_index: number,\n normalize_usage: AiSdkProviderAdapter['normalize_usage'] = default_normalize_usage,\n): StreamChunk | undefined {\n switch (part.type) {\n case 'text-delta':\n return { kind: 'text', text: part.text, step_index }\n case 'reasoning-delta':\n return { kind: 'reasoning', text: part.text, step_index }\n case 'tool-input-start':\n return {\n kind: 'tool_call_start',\n id: part.id,\n name: part.toolName,\n step_index,\n }\n case 'tool-input-delta':\n return {\n kind: 'tool_call_input_delta',\n id: part.id,\n delta: part.delta,\n step_index,\n }\n case 'tool-call':\n return {\n kind: 'tool_call_end',\n id: part.toolCallId,\n input: part.input,\n step_index,\n }\n case 'finish-step':\n return {\n kind: 'step_finish',\n step_index,\n finish_reason: map_finish_reason(part.finishReason),\n usage: normalize_usage(to_raw_provider_usage(part.usage), part.providerMetadata),\n }\n default:\n // v7 parts with no engine StreamChunk kind (file, reasoning-file,\n // source, block framing) drop here on purpose: the engine models\n // text, reasoning, and tool traffic, not generated files.\n return undefined\n }\n}\n\n/**\n * The running TurnResult fields collect_stream builds as it consumes the SDK\n * stream: text and tool calls accrue across parts, while finish reason, usage,\n * and provider_reported are overwritten by the terminal finish-step.\n */\ntype StreamAccumulator = {\n text: string\n tool_calls: RawToolCall[]\n finish_reason: FinishReason\n raw_usage: RawProviderUsage\n provider_reported: Record<string, unknown> | undefined\n /** True when the step finished as 'other' with no raw reason: a cut-off stream. */\n cut_off: boolean\n}\n\n/**\n * Fold one stream part's accumulated state into `acc`: text deltas append,\n * tool-call parts push a RawToolCall, and the finish-step overwrites finish\n * reason, usage, and provider_reported. A finish-step of 'other' with no raw\n * finish reason is what a provider package reports when its stream ended\n * before the provider said why, so it marks the stream as cut off. Parts with\n * no accumulated state (error, abort, stream framing) are the caller's to\n * handle.\n */\nfunction accumulate_stream_part(part: TextStreamPart<ToolSet>, acc: StreamAccumulator): void {\n if (part.type === 'text-delta') {\n acc.text += part.text\n return\n }\n if (part.type === 'tool-call') {\n acc.tool_calls.push({\n id: part.toolCallId,\n name: part.toolName,\n input: part.input,\n })\n return\n }\n if (part.type === 'finish-step') {\n acc.finish_reason = map_finish_reason(part.finishReason)\n acc.raw_usage = to_raw_provider_usage(part.usage)\n acc.provider_reported = to_provider_reported(part.providerMetadata)\n acc.cut_off = part.finishReason === 'other' && part.rawFinishReason === undefined\n }\n}\n\n/**\n * Run one streamText call, dispatching StreamChunks as parts arrive and\n * accumulating them into a TurnResult once the stream completes. Every turn\n * takes this path, so the dispatcher passes chunks on only when a consumer\n * is attached. A failure reaches the engine through the stream's error part,\n * so `onError` stays quiet rather than writing each one to console.error. A\n * stream cut off before the step finished throws the network shape, which\n * the engine retries when nothing consumed the chunks. Structured output is\n * parsed by the engine's own schema loop, since streamText parses `output`\n * only when it is read, which this never does.\n */\nasync function collect_stream(\n params: Parameters<typeof streamText>[0],\n step_index: number,\n dispatcher: ChunkDispatcher,\n observe_chunk: (chunk: StreamChunk) => void,\n internal_controller: AbortController,\n adapter: AiSdkProviderAdapter,\n): Promise<TurnResult> {\n const stream_result = streamText({ ...params, onError: () => {} })\n const acc: StreamAccumulator = {\n text: '',\n tool_calls: [],\n finish_reason: 'stop',\n raw_usage: {},\n provider_reported: undefined,\n cut_off: false,\n }\n for await (const part of stream_result.stream) {\n accumulate_stream_part(part, acc)\n if (part.type === 'error') {\n throw part.error\n }\n if (part.type === 'abort') {\n throw new aborted_error('aborted', { step_index })\n }\n const chunk = map_stream_part_to_chunk(part, step_index, adapter.normalize_usage)\n if (chunk === undefined) continue\n // The engine stamps the first dispatched chunk, not the first stream part:\n // the SDK opens every stream with `start` and `start-step` framing before\n // the model has produced a token, and a stamp there would leave prefill\n // inside the decode window throughput() measures. This is also the native\n // transport's rule (build_native_invoke observes in dispatch_chunk), so a\n // failure before the first token stays retryable on both.\n observe_chunk(chunk)\n try {\n await dispatcher.dispatch(chunk)\n } catch (err: unknown) {\n internal_controller.abort()\n throw err\n }\n }\n\n if (acc.cut_off) {\n throw network_failure(\n `${adapter.name} stream ended before the step finished; the result would be truncated`,\n )\n }\n // The step's content settles once the stream has drained, so it is read\n // only after the loop and never on a failed stream.\n const content = to_turn_content(await stream_result.content)\n return {\n text: acc.text,\n tool_calls: acc.tool_calls,\n finish_reason: acc.finish_reason,\n // provider_reported is the step's providerMetadata, copied key by key,\n // which is what the step_finish chunk's usage was normalized against.\n usage: adapter.normalize_usage(acc.raw_usage, acc.provider_reported),\n // Stryker disable next-line ConditionalExpression: an always-true spread only adds an explicit `provider_reported: undefined` key, which every reader of TurnResult treats identically to the absent key.\n ...(acc.provider_reported !== undefined ? { provider_reported: acc.provider_reported } : {}),\n ...(content !== undefined ? { content } : {}),\n }\n}\n\ntype AiSdkCallParams = Parameters<typeof streamText>[0]\n\nexport type AiSdkTurnConfig = {\n readonly adapter: AiSdkProviderAdapter\n readonly model_id: string\n readonly dispatcher: ChunkDispatcher\n readonly tools: ReadonlyArray<Tool>\n readonly schema: ToolSchema | undefined\n readonly provider_options: Readonly<Record<string, Readonly<Record<string, unknown>>>> | undefined\n readonly temperature: number | undefined\n readonly max_tokens: number | undefined\n readonly top_p: number | undefined\n readonly reasoning: EffortTranslation['reasoning']\n readonly telemetry: AiSdkTelemetrySettings | undefined\n}\n\nexport type AiSdkTurnArgs = {\n readonly step_index: number\n readonly messages: ReadonlyArray<Message>\n readonly abort: AbortSignal\n /** Sees every chunk the turn dispatches, just before it goes out. */\n readonly observe_chunk: (chunk: StreamChunk) => void\n}\n\nexport type AiSdkTurn = (args: AiSdkTurnArgs) => Promise<TurnResult>\n\n/**\n * Build the single-attempt SDK turn for one generate call: the streamText\n * call body behind the same neutral seam a native adapter's invoke_turn\n * implements. The built model is memoized across steps\n * of one generate call. No retry here: generate.ts wraps the returned turn in\n * the engine-owned retry_turn.\n */\nexport function create_ai_sdk_turn(cfg: AiSdkTurnConfig): AiSdkTurn {\n let model_instance: LanguageModel | undefined\n const get_model = async (): Promise<LanguageModel> => {\n if (model_instance === undefined) {\n const built = await cfg.adapter.build_model(cfg.model_id)\n // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion\n model_instance = built as LanguageModel\n }\n return model_instance\n }\n\n // Telemetry is resolved once per generate call and memoized across its steps,\n // mirroring get_model. build_ai_sdk_telemetry returns undefined immediately\n // (no peer load) unless telemetry is explicitly enabled, so the disabled\n // default costs nothing.\n let telemetry_options: AiSdkTelemetryPassthrough | undefined\n let telemetry_resolved = false\n const get_telemetry = async (): Promise<AiSdkTelemetryPassthrough | undefined> => {\n if (!telemetry_resolved) {\n telemetry_options = await build_ai_sdk_telemetry(cfg.telemetry)\n telemetry_resolved = true\n }\n return telemetry_options\n }\n\n const sdk_tools = to_sdk_tools(cfg.tools)\n\n // Native structured output: when a schema is requested and the provider\n // constrains decoding to it (the 'structured_output' capability), route\n // through the AI SDK's Output.object seam so the schema becomes the\n // provider's responseFormat (for example, Ollama's `format`) instead of a\n // prompt-for-JSON-then-scrape. Gated on no tools: forcing a JSON\n // responseFormat alongside tool calls breaks tool dispatch on most\n // providers, so tool runs keep the prompt-based schema path. The engine's\n // schema parse + repair loop still owns validation either way. This seam\n // is ai_sdk-only: a native adapter that constrains decoding honors\n // TurnRequest.schema inside its own invoke_turn.\n let output_spec: NonNullable<AiSdkCallParams['output']> | undefined\n if (\n cfg.schema !== undefined &&\n cfg.tools.length === 0 &&\n cfg.adapter.supports('structured_output')\n ) {\n // Output.object<T> is not structurally assignable to the SDK's default\n // Output<string, string> param slot, but the runtime shape is exactly\n // what streamText consumes to set responseFormat.\n // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion\n output_spec = Output.object({ schema: cfg.schema }) as NonNullable<\n AiSdkCallParams['output']\n >\n }\n\n // provider_options is Record<string, Record<string, unknown>>; the SDK\n // expects SharedV3ProviderOptions (Record<string, JSONObject>) which is\n // structurally compatible for our usage.\n // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion\n const provider_options = cfg.provider_options as AiSdkCallParams['providerOptions']\n\n return async (args: AiSdkTurnArgs): Promise<TurnResult> => {\n const model = await get_model()\n const telemetry = await get_telemetry()\n const internal_controller = new AbortController()\n const cancel_on_user_abort = (): void => {\n internal_controller.abort(args.abort.reason)\n }\n if (args.abort.aborted) {\n internal_controller.abort(args.abort.reason)\n } else {\n args.abort.addEventListener('abort', cancel_on_user_abort, { once: true })\n }\n const { system: hoisted_system, messages: sdk_messages } = split_leading_system(\n to_sdk_messages(args.messages, cfg.adapter.metadata_key ?? cfg.adapter.name),\n )\n const base_params: AiSdkCallParams = {\n model,\n messages: sdk_messages,\n abortSignal: internal_controller.signal,\n stopWhen: isStepCount(1),\n // The engine owns retry via retry_turn in generate.ts; disable the AI\n // SDK's own retry (default 2) so it does not nest inside each of our\n // attempts and inflate provider round-trips / distort backoff.\n maxRetries: 0,\n }\n if (hoisted_system !== undefined) base_params.instructions = hoisted_system\n if (sdk_tools !== undefined) base_params.tools = sdk_tools\n if (output_spec !== undefined) base_params.output = output_spec\n if (provider_options !== undefined) base_params.providerOptions = provider_options\n if (cfg.temperature !== undefined) base_params.temperature = cfg.temperature\n if (cfg.max_tokens !== undefined) base_params.maxOutputTokens = cfg.max_tokens\n if (cfg.top_p !== undefined) base_params.topP = cfg.top_p\n // The SDK's own effort option; the provider package maps the level per\n // model, and leaving it out is the provider's default.\n if (cfg.reasoning !== undefined) base_params.reasoning = cfg.reasoning\n if (telemetry !== undefined) {\n // AiSdkTelemetryPassthrough uses the SDK's own telemetry keys; the slot's\n // generic (RUNTIME_CONTEXT/TOOLS) is erased for our usage.\n // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion\n base_params.experimental_telemetry = telemetry as NonNullable<\n AiSdkCallParams['experimental_telemetry']\n >\n }\n\n try {\n return await collect_stream(\n base_params,\n args.step_index,\n cfg.dispatcher,\n args.observe_chunk,\n internal_controller,\n cfg.adapter,\n )\n } finally {\n args.abort.removeEventListener('abort', cancel_on_user_abort)\n }\n }\n}\n"],"mappings":"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"}
@@ -28,13 +28,14 @@ var provider_error = class extends Error {
28
28
  };
29
29
  /**
30
30
  * Turn-timeout expiry. Thrown by the engine-owned retry_turn wrapper when a
31
- * single invoke_turn exceeds `turn_timeout_ms` before any chunk streamed.
31
+ * single invoke_turn exceeds `turn_timeout_ms` before any chunk reached a
32
+ * consumer.
32
33
  * Its `kind` is the RetryFailureKind wire value `'timeout'` (not the class
33
34
  * name) on purpose: that is the discriminant classify_retryable /
34
35
  * classify_provider_error already key on, so the shared classifier treats an
35
- * expiry as retryable without any timeout-specific branch. A mid-stream
36
- * expiry never reaches here; retry_turn converts it to a non-retryable
37
- * stream interruption first.
36
+ * expiry as retryable without any timeout-specific branch. An expiry after a
37
+ * chunk has reached an on_chunk consumer never reaches here; retry_turn
38
+ * converts it to a non-retryable stream interruption first.
38
39
  */
39
40
  var turn_timeout_error = class extends Error {
40
41
  kind = "timeout";
@@ -271,6 +272,7 @@ function normalize_local_usage(raw) {
271
272
  const base = default_normalize_usage(raw);
272
273
  delete base.cached_input_tokens;
273
274
  delete base.cache_write_tokens;
275
+ delete base.cache_write_1h_tokens;
274
276
  delete base.reasoning_tokens;
275
277
  return base;
276
278
  }
@@ -357,15 +359,29 @@ async function response_error(response, provider) {
357
359
  });
358
360
  }
359
361
  /**
362
+ * A transport failure in the `kind: 'network'` shape that the shared
363
+ * classify_provider_error marks retryable. A stream that ends before its
364
+ * closing event throws it too, since a cut-off stream is a dropped
365
+ * connection, so the engine retries it whenever nothing consumed its chunks.
366
+ */
367
+ function network_failure(message) {
368
+ return Object.assign(new Error(message), { kind: "network" });
369
+ }
370
+ /**
360
371
  * A user abort surfaces as the fetch/reader AbortError; retry_turn converts
361
372
  * it via its own signal check, so it is rethrown untouched. Everything else
362
- * is a transport failure wrapped in the `kind: 'network'` shape the shared
363
- * classify_provider_error marks retryable.
373
+ * is a transport failure wrapped as a network_failure.
364
374
  */
365
375
  function rethrow_network_failure(err, abort, provider) {
366
376
  if (abort.aborted) throw err;
367
- const detail = err instanceof Error ? err.message : String(err);
368
- throw Object.assign(/* @__PURE__ */ new Error(`${provider} native: network failure: ${detail}`), { kind: "network" });
377
+ throw network_failure(`${provider} native: network failure: ${err instanceof Error ? err.message : String(err)}`);
378
+ }
379
+ /**
380
+ * The response's media type, lowercased and without its parameters, or ''
381
+ * when it names none.
382
+ */
383
+ function media_type(response) {
384
+ return ((response.headers.get("content-type") ?? "").split(";")[0] ?? "").trim().toLowerCase();
369
385
  }
370
386
  /**
371
387
  * Read a non-stream response body and parse it as JSON. A read that fails
@@ -389,13 +405,24 @@ async function read_json_body(response, abort, provider) {
389
405
  /**
390
406
  * Run one native turn over HTTP: POST the dialect's body, map a non-2xx to
391
407
  * the retry stack's shapes, and hand the response to the dialect's stream or
392
- * JSON consumer. `build_body` runs before the network try/catch, so a mapper
408
+ * JSON consumer. A streamed request whose reply doesn't arrive as the
409
+ * dialect's stream media type (`text/event-stream`, or NDJSON for Ollama) is
410
+ * read as a whole JSON body, so a server that answers with JSON still works,
411
+ * and a page that isn't JSON fails with the `base_url` hint rather than as a
412
+ * cut-off stream. `build_body` runs before the network try/catch, so a mapper
393
413
  * that rejects the request (e.g., a provider_capability_error for a part the
394
414
  * wire cannot carry) propagates unchanged instead of being retried as a
395
- * network failure.
415
+ * network failure. `req.on_wire`, when the call captures the wire, sees the
416
+ * URL and the body object just before the body is serialized, and never a
417
+ * header.
396
418
  */
397
419
  async function invoke_http_turn(req, provider, request, consume) {
398
- const body = JSON.stringify(request.build_body());
420
+ const built = request.build_body();
421
+ req.on_wire?.({
422
+ url: request.url,
423
+ body: built
424
+ });
425
+ const body = JSON.stringify(built);
399
426
  let response;
400
427
  try {
401
428
  response = await fetch(request.url, {
@@ -408,7 +435,7 @@ async function invoke_http_turn(req, provider, request, consume) {
408
435
  rethrow_network_failure(err, req.abort, provider);
409
436
  }
410
437
  if (!response.ok) throw await response_error(response, provider);
411
- if (req.stream) return consume.stream(response);
438
+ if (req.stream && media_type(response) === consume.stream_media_type) return consume.stream(response);
412
439
  return consume.parse(await read_json_body(response, req.abort, provider));
413
440
  }
414
441
  /**
@@ -530,7 +557,9 @@ function is_own_reasoning(part, key) {
530
557
  /**
531
558
  * Partition assistant content parts into the text runs, tool calls, and
532
559
  * reasoning the wire mappers serialize separately. `reasoning` holds only
533
- * the parts `provider` may send back, in order (see is_own_reasoning).
560
+ * the parts `provider` may send back, in order (see is_own_reasoning). An
561
+ * opaque part belongs to the provider that sent it, and these formats carry
562
+ * no such block, so it is skipped.
534
563
  */
535
564
  function split_assistant_parts(parts, provider) {
536
565
  const texts = [];
@@ -538,7 +567,7 @@ function split_assistant_parts(parts, provider) {
538
567
  const reasoning = [];
539
568
  for (const part of parts) if (part.type === "text") texts.push(part.text);
540
569
  else if (part.type === "tool_call") tool_parts.push(part);
541
- else if (is_own_reasoning(part, provider)) reasoning.push(part);
570
+ else if (part.type === "reasoning" && is_own_reasoning(part, provider)) reasoning.push(part);
542
571
  return {
543
572
  texts,
544
573
  tool_parts,
@@ -599,6 +628,6 @@ function is_leading_system(m) {
599
628
  return m?.role === "system";
600
629
  }
601
630
  //#endregion
602
- export { tool_error as A, provider_capability_error as C, rate_limit_error as D, provider_required_error as E, schema_validation_error as O, provider_auth_error as S, provider_not_configured_error as T, engine_config_error as _, is_own_reasoning as a, model_required_error as b, read_dialect_init as c, load_optional_peer as d, missing_peer_error as f, claude_cli_error as g, translate_effort_to_sdk_reasoning as h, invoke_http_turn as i, turn_timeout_error as j, tool_approval_denied_error as k, split_assistant_parts as l, resolve_transport as m, consume_framed_stream as n, map_messages_by_role as o, normalize_local_usage as p, create_line_splitter as r, parse_tool_call_arguments as s, split_leading_system_run as t, default_normalize_usage as u, engine_disposed_error as v, provider_error as w, on_chunk_error as x, incomplete_generation_error as y };
631
+ export { tool_approval_denied_error as A, provider_auth_error as C, provider_required_error as D, provider_not_configured_error as E, turn_timeout_error as M, rate_limit_error as O, on_chunk_error as S, provider_error as T, claude_cli_error as _, is_own_reasoning as a, incomplete_generation_error as b, parse_tool_call_arguments as c, default_normalize_usage as d, load_optional_peer as f, translate_effort_to_sdk_reasoning as g, resolve_transport as h, invoke_http_turn as i, tool_error as j, schema_validation_error as k, read_dialect_init as l, normalize_local_usage as m, consume_framed_stream as n, map_messages_by_role as o, missing_peer_error as p, create_line_splitter as r, network_failure as s, split_leading_system_run as t, split_assistant_parts as u, engine_config_error as v, provider_capability_error as w, model_required_error as x, engine_disposed_error as y };
603
632
 
604
- //# sourceMappingURL=leading_system-WhW76tRn.js.map
633
+ //# sourceMappingURL=leading_system-DmNxhvzL.js.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"leading_system-DmNxhvzL.js","names":[],"sources":["../src/engine/errors.ts","../src/engine/providers/types.ts","../src/engine/providers/native_shared.ts","../src/engine/leading_system.ts"],"sourcesContent":["/**\n * Typed errors for the AI engine layer.\n *\n * This is the only source file in the engine module permitted to use the\n * `class` keyword. `Error` is a built-in and `instanceof` branching is how\n * the retry helper and composition-layer composers distinguish failure modes.\n * Every other engine file stays class-free.\n *\n * `aborted_error` is defined in the core module and re-exported here so that\n * `instanceof aborted_error` is true regardless of which layer surfaced it.\n * This is the one value-level import from core permitted in engine source;\n * see the ignores in `rules/no-core-value-import-in-engine.yml`.\n *\n * Every class declares an optional `path`: the chain of step ids the error\n * crossed while bubbling through the core runner's dispatch. The runner\n * attaches it via Reflect.set (`prepend_path` in core's runner.ts), so the\n * `declare` modifier types what arrives without emitting a field;\n * construction never sets it.\n */\n\nimport type { SchemaIssue } from '#schema'\nimport type { FinishReason } from './types.js'\n\nexport { aborted_error } from '#core'\n\nexport class rate_limit_error extends Error {\n readonly kind = 'rate_limit_error' as const;\n declare readonly path?: ReadonlyArray<string>;\n readonly retry_after_ms: number | undefined;\n readonly attempts: number;\n readonly status: number | undefined;\n constructor(\n message: string,\n metadata: { retry_after_ms?: number; attempts?: number; status?: number } = {},\n ) {\n super(message)\n this.name = 'rate_limit_error'\n this.retry_after_ms = metadata.retry_after_ms\n this.attempts = metadata.attempts ?? 0\n this.status = metadata.status\n }\n}\n\nexport class provider_error extends Error {\n readonly kind = 'provider_error' as const;\n declare readonly path?: ReadonlyArray<string>;\n readonly status: number | undefined;\n readonly body: string | undefined;\n readonly cause_kind: 'provider_5xx' | 'network' | 'unknown' | undefined;\n constructor(\n message: string,\n metadata: {\n status?: number\n body?: string\n cause_kind?: 'provider_5xx' | 'network' | 'unknown'\n } = {},\n ) {\n super(message)\n this.name = 'provider_error'\n this.status = metadata.status\n this.body = metadata.body\n this.cause_kind = metadata.cause_kind\n }\n}\n\n/**\n * Turn-timeout expiry. Thrown by the engine-owned retry_turn wrapper when a\n * single invoke_turn exceeds `turn_timeout_ms` before any chunk reached a\n * consumer.\n * Its `kind` is the RetryFailureKind wire value `'timeout'` (not the class\n * name) on purpose: that is the discriminant classify_retryable /\n * classify_provider_error already key on, so the shared classifier treats an\n * expiry as retryable without any timeout-specific branch. An expiry after a\n * chunk has reached an on_chunk consumer never reaches here; retry_turn\n * converts it to a non-retryable stream interruption first.\n */\nexport class turn_timeout_error extends Error {\n readonly kind = 'timeout' as const;\n declare readonly path?: ReadonlyArray<string>;\n readonly timeout_ms: number;\n readonly step_index: number | undefined;\n constructor(timeout_ms: number, step_index?: number) {\n super(`turn exceeded turn_timeout_ms budget of ${timeout_ms}ms`)\n this.name = 'turn_timeout_error'\n this.timeout_ms = timeout_ms\n this.step_index = step_index\n }\n}\n\nexport class schema_validation_error extends Error {\n readonly kind = 'schema_validation_error' as const;\n declare readonly path?: ReadonlyArray<string>;\n readonly schema_issues: ReadonlyArray<SchemaIssue>;\n readonly raw_text: string;\n constructor(message: string, schema_issues: ReadonlyArray<SchemaIssue>, raw_text: string) {\n super(message)\n this.name = 'schema_validation_error'\n this.schema_issues = schema_issues\n this.raw_text = raw_text\n }\n}\n\nexport class tool_error extends Error {\n readonly kind = 'tool_error' as const;\n declare readonly path?: ReadonlyArray<string>;\n readonly tool_name: string;\n readonly tool_call_id: string;\n override readonly cause: unknown;\n constructor(\n message: string,\n metadata: { tool_name: string; tool_call_id: string; cause: unknown },\n ) {\n super(message)\n this.name = 'tool_error'\n this.tool_name = metadata.tool_name\n this.tool_call_id = metadata.tool_call_id\n this.cause = metadata.cause\n }\n}\n\nexport class tool_approval_denied_error extends Error {\n readonly kind = 'tool_approval_denied_error' as const;\n declare readonly path?: ReadonlyArray<string>;\n readonly tool_name: string;\n readonly step_index: number;\n readonly tool_call_id: string;\n constructor(\n message: string,\n metadata: { tool_name: string; step_index: number; tool_call_id: string },\n ) {\n super(message)\n this.name = 'tool_approval_denied_error'\n this.tool_name = metadata.tool_name\n this.step_index = metadata.step_index\n this.tool_call_id = metadata.tool_call_id\n }\n}\n\nexport class model_required_error extends Error {\n readonly kind = 'model_required_error' as const;\n declare readonly path?: ReadonlyArray<string>;\n constructor(\n message = 'no model specified: pass `model` to generate() or set `defaults.model` on the engine',\n ) {\n super(message)\n this.name = 'model_required_error'\n }\n}\n\n/**\n * A generate call named a provider the engine has no adapter for. Carries the\n * configured names, and the message repeats them, so a typo is visible from\n * the message alone rather than needing the engine config alongside it.\n */\nexport class provider_not_configured_error extends Error {\n readonly kind = 'provider_not_configured_error' as const;\n declare readonly path?: ReadonlyArray<string>;\n readonly provider: string;\n readonly configured: ReadonlyArray<string>;\n constructor(provider: string, configured: ReadonlyArray<string> = []) {\n const state = configured.length > 0 ? configured.join(', ') : 'none'\n super(\n `provider '${provider}' is not configured on this engine: pass it to create_engine({ providers }) (configured: ${state})`,\n )\n this.name = 'provider_not_configured_error'\n this.provider = provider\n this.configured = configured\n }\n}\n\n/**\n * No provider could be resolved for a generate call: several providers are\n * configured, the call named none, and no `defaults.provider` is set. Carries\n * the configured provider names so the message tells the caller exactly what\n * the engine can route to.\n */\nexport class provider_required_error extends Error {\n readonly kind = 'provider_required_error' as const;\n declare readonly path?: ReadonlyArray<string>;\n readonly configured: ReadonlyArray<string>;\n constructor(configured: ReadonlyArray<string>) {\n super(\n `no provider specified: pass \\`provider\\` to generate() or set \\`defaults.provider\\` (configured: ${configured.join(', ')})`,\n )\n this.name = 'provider_required_error'\n this.configured = configured\n }\n}\n\nexport class engine_config_error extends Error {\n readonly kind = 'engine_config_error' as const;\n declare readonly path?: ReadonlyArray<string>;\n readonly provider: string | undefined;\n constructor(message: string, provider?: string) {\n super(message)\n this.name = 'engine_config_error'\n this.provider = provider\n }\n}\n\nexport class on_chunk_error extends Error {\n readonly kind = 'on_chunk_error' as const;\n declare readonly path?: ReadonlyArray<string>;\n override readonly cause: unknown;\n constructor(message: string, cause: unknown) {\n super(message)\n this.name = 'on_chunk_error'\n this.cause = cause\n }\n}\n\nexport class provider_capability_error extends Error {\n readonly kind = 'provider_capability_error' as const;\n declare readonly path?: ReadonlyArray<string>;\n readonly provider: string;\n readonly capability: string;\n constructor(provider: string, capability: string, detail?: string) {\n const suffix = detail !== undefined ? `: ${detail}` : ''\n super(`provider '${provider}' does not support '${capability}'${suffix}`)\n this.name = 'provider_capability_error'\n this.provider = provider\n this.capability = capability\n }\n}\n\nexport class engine_disposed_error extends Error {\n readonly kind = 'engine_disposed_error' as const;\n declare readonly path?: ReadonlyArray<string>;\n constructor(message = 'engine has been disposed: build a new one with create_engine()') {\n super(message)\n this.name = 'engine_disposed_error'\n }\n}\n\nexport type ClaudeCliErrorReason =\n | 'binary_not_found'\n | 'startup_timeout'\n | 'stall_timeout'\n | 'no_result_event'\n | 'result_error'\n | 'subprocess_exit'\n | 'sandbox_unavailable'\n\nexport class claude_cli_error extends Error {\n readonly kind = 'claude_cli_error' as const;\n declare readonly path?: ReadonlyArray<string>;\n readonly reason: ClaudeCliErrorReason;\n readonly status: number | undefined;\n readonly stderr_snippet: string | undefined;\n constructor(\n reason: ClaudeCliErrorReason,\n message: string,\n metadata: { status?: number; stderr_snippet?: string } = {},\n ) {\n super(message)\n this.name = 'claude_cli_error'\n this.reason = reason\n this.status = metadata.status\n this.stderr_snippet = metadata.stderr_snippet\n }\n}\n\nexport class provider_auth_error extends Error {\n readonly kind = 'provider_auth_error' as const;\n declare readonly path?: ReadonlyArray<string>;\n readonly provider: string;\n readonly refresh_command: string | undefined;\n constructor(\n provider: string,\n message: string,\n metadata: { refresh_command?: string } = {},\n ) {\n super(message)\n this.name = 'provider_auth_error'\n this.provider = provider\n this.refresh_command = metadata.refresh_command\n }\n}\n\n/**\n * A generate call that set a schema finished for a reason other than 'stop'\n * (content_filter, length, max_steps, tool_calls), so no schema-validated\n * value exists and validation was never attempted. Carries the raw model text\n * and the last provider-reported payload, so a guardrail trace or other\n * block detail stays reachable from the catch. Distinct from\n * schema_validation_error, which covers a response that completed normally\n * and then failed validation after its repair attempts ran out.\n */\nexport class incomplete_generation_error extends Error {\n readonly kind = 'incomplete_generation_error' as const;\n declare readonly path?: ReadonlyArray<string>;\n readonly finish_reason: FinishReason;\n readonly raw_text: string;\n readonly provider_reported: Record<string, unknown> | undefined;\n constructor(\n finish_reason: FinishReason,\n raw_text: string,\n provider_reported?: Record<string, unknown>,\n ) {\n super(\n `generation finished with '${finish_reason}' before a schema-validated response was produced`,\n )\n this.name = 'incomplete_generation_error'\n this.finish_reason = finish_reason\n this.raw_text = raw_text\n this.provider_reported = provider_reported\n }\n}\n","/**\n * Shared provider-adapter shape.\n *\n * Each file under src/engine/providers/ exports a factory that accepts a\n * ProviderInit shape and returns a ProviderAdapter. Factories are\n * synchronous; build_model is async so SDK loading is deferred until a model\n * is actually needed. A missing peer dependency surfaces on the first\n * build_model call as a plain Error naming the peer and its install command\n * (see missing_peer_error).\n *\n * Only the ai_sdk transport module (providers/ai_sdk/invoke.ts) may import\n * from `ai` or invoke generateText/streamText. ai_sdk adapters build the\n * provider model and translate parameters; they do not orchestrate the call.\n */\n\nimport type {\n CacheSetting,\n ResolvedModel,\n EffortLevel,\n GenerateOptions,\n GenerateResult,\n ProviderInit,\n TurnRequest,\n TurnResult,\n UsageTotals,\n} from '../types.js'\nimport { engine_config_error } from '../errors.js'\n\n/**\n * Which backend a provider factory returns: 'ai_sdk' wraps the Vercel AI SDK\n * provider package, 'native' talks to the provider's HTTP API directly. The\n * provider name stays the same across transports so pricing keys and usage\n * fields carry over; only the wire implementation changes.\n */\nexport type ProviderTransport = 'ai_sdk' | 'native'\n\n/**\n * Read the `transport` selector off a provider init. Defaults to 'ai_sdk';\n * anything but the two known backends throws at construction so a typo\n * fails loud instead of silently running the default.\n */\nexport function resolve_transport(\n init: ProviderInit,\n provider: string,\n): ProviderTransport {\n const raw = init['transport']\n if (raw === undefined || raw === 'ai_sdk') return 'ai_sdk'\n if (raw === 'native') return 'native'\n throw new engine_config_error(\n `${provider} provider: transport must be 'ai_sdk' or 'native', got ${JSON.stringify(raw)}`,\n provider,\n )\n}\n\nexport type EffortTranslation = {\n // Outer keys are provider names, inner records hold per-provider settings,\n // matching the two-level shape merge_provider_options expects.\n provider_options: Record<string, Record<string, unknown>>\n effort_ignored: boolean\n // A level for the AI SDK's own `reasoning` call option, which the provider\n // package maps per model. Left out, the SDK uses the provider's default.\n reasoning?: Exclude<EffortLevel, 'none'>\n}\n\n/**\n * Hand effort to the AI SDK's `reasoning` option and build no provider\n * options of its own, so the provider package maps each level per model from\n * the capability table it keeps (adaptive thinking or a budget for Claude,\n * `thinkingLevel` or a budget for Gemini, `reasoningEffort` for OpenAI).\n * `none` sends neither, which is the SDK's provider default. The anthropic,\n * bedrock, google, and openai ai_sdk adapters all translate this way.\n */\nexport function translate_effort_to_sdk_reasoning(effort: EffortLevel): EffortTranslation {\n if (effort === 'none') return { provider_options: {}, effort_ignored: false }\n return { provider_options: {}, effort_ignored: false, reasoning: effort }\n}\n\nexport type ProviderCapability =\n | 'text'\n | 'tools'\n | 'schema'\n | 'streaming'\n | 'image_input'\n | 'reasoning'\n // Provider performs native constrained decoding (the AI SDK responseFormat /\n // Output.object path), as opposed to the prompt-for-JSON-then-extract path.\n // Distinct from 'schema': every provider can satisfy a schema via repair, but\n // only some constrain the decode to it.\n | 'structured_output'\n\n/**\n * How an adapter caches prompts, which decides what a call's `cache` setting\n * does on it. `'with_tools'` caches for five minutes by default on a call\n * with tools, `'opt_in'` caches only when the call or the engine asks, and\n * `'automatic'` marks a provider that caches on its own, so an explicit\n * setting is ignored. An adapter that declares nothing requests no caching.\n */\ntype PromptCacheDeclaration = 'with_tools' | 'opt_in' | 'automatic'\n\nexport type RawProviderUsage = {\n input_tokens?: number\n output_tokens?: number\n reasoning_tokens?: number\n cached_input_tokens?: number\n cache_write_tokens?: number\n // The Vercel AI SDK also surfaces details via *Details containers; adapters\n // accept the flattened shape above for testability.\n input_token_details?: {\n cached_tokens?: number\n cache_creation_input_tokens?: number\n }\n output_token_details?: {\n reasoning_tokens?: number\n }\n [k: string]: unknown\n}\n\nexport type AiSdkProviderAdapter = {\n readonly kind: 'ai_sdk'\n readonly name: string\n // The key the adapter's package writes providerMetadata under, which is\n // the only key a reasoning part may carry to be sent back. Defaults\n // to `name`; a custom adapter over a built-in package (@ai-sdk/anthropic on\n // Vertex, say) can't take the built-in name, so it sets the package's key.\n readonly metadata_key?: string\n readonly build_model: (model_id: string) => Promise<unknown>\n readonly translate_effort: (effort: EffortLevel) => EffortTranslation\n /**\n * Map the SDK's usage to UsageTotals. The engine also hands it the step's\n * `providerMetadata`, for a split that the SDK's usage object leaves out.\n */\n readonly normalize_usage: (raw: RawProviderUsage | undefined, provider_metadata?: unknown) => UsageTotals\n readonly supports: (capability: ProviderCapability) => boolean\n readonly prompt_cache?: PromptCacheDeclaration\n /**\n * Turn the call's resolved cache setting into call-level provider options,\n * given the caller's own (engine defaults merged with the call's). The\n * engine merges the result beneath the caller's options, where effort's\n * translation goes. An adapter that declares `'with_tools'` or `'opt_in'`\n * without this hook asks for no cache, as one that declares nothing.\n */\n readonly translate_cache?: (\n cache: CacheSetting,\n provider_options: Readonly<Record<string, unknown>> | undefined,\n ) => Record<string, Record<string, unknown>>\n}\n\n/**\n * Raw-HTTP transport: implements a single turn against a provider's own\n * API with zero `ai` / `@ai-sdk/*` in its module graph. generate.ts wraps\n * invoke_turn in retry + classification + abort, so a native adapter owns only\n * request/response mapping (and streaming via TurnRequest.dispatch_chunk); it\n * MUST NOT implement its own retry. classify_error optionally overrides the\n * shared classifier; dispose is optional (keep-alive agents, connection pools).\n */\nexport type NativeProviderAdapter = {\n readonly kind: 'native'\n readonly name: string\n readonly invoke_turn: (req: TurnRequest) => Promise<TurnResult>\n readonly supports: (capability: ProviderCapability) => boolean\n readonly prompt_cache?: PromptCacheDeclaration\n readonly dispose?: () => Promise<void>\n readonly classify_error?: (err: unknown) => unknown\n}\n\nexport type ExternalAgentAdapter = {\n readonly kind: 'external'\n readonly name: string\n readonly generate: <t>(\n opts: GenerateOptions<t>,\n resolved: ResolvedModel,\n ) => Promise<GenerateResult<t>>\n readonly dispose: () => Promise<void>\n readonly supports: (capability: ProviderCapability) => boolean\n}\n\nexport type ProviderAdapter =\n | AiSdkProviderAdapter\n | NativeProviderAdapter\n | ExternalAgentAdapter\n\nexport type ProviderFactory = (init: ProviderInit) => ProviderAdapter\n\n/**\n * Map raw provider usage to UsageTotals, the mapper most adapters share.\n *\n * Missing usage zeroes the totals. Optional fields (reasoning and cache\n * tokens) are set only when the raw payload carries them, reading the\n * flattened field first and the AI SDK's *_details container second.\n */\nexport function default_normalize_usage(\n raw: RawProviderUsage | undefined,\n): UsageTotals {\n if (raw === undefined) return { input_tokens: 0, output_tokens: 0 }\n const input_tokens = typeof raw.input_tokens === 'number' ? raw.input_tokens : 0\n const output_tokens = typeof raw.output_tokens === 'number' ? raw.output_tokens : 0\n const totals: UsageTotals = { input_tokens, output_tokens }\n if (typeof raw.reasoning_tokens === 'number') totals.reasoning_tokens = raw.reasoning_tokens\n else if (typeof raw.output_token_details?.reasoning_tokens === 'number') {\n totals.reasoning_tokens = raw.output_token_details.reasoning_tokens\n }\n if (typeof raw.cached_input_tokens === 'number') totals.cached_input_tokens = raw.cached_input_tokens\n else if (typeof raw.input_token_details?.cached_tokens === 'number') {\n totals.cached_input_tokens = raw.input_token_details.cached_tokens\n }\n if (typeof raw.cache_write_tokens === 'number') totals.cache_write_tokens = raw.cache_write_tokens\n else if (typeof raw.input_token_details?.cache_creation_input_tokens === 'number') {\n totals.cache_write_tokens = raw.input_token_details.cache_creation_input_tokens\n }\n return totals\n}\n\n/**\n * Usage mapper for local backends (Ollama, LM Studio) whose servers never\n * report cache or reasoning tokens: default-normalize, then strip those\n * fields so a stray *_details container cannot invent them.\n */\nexport function normalize_local_usage(raw: RawProviderUsage | undefined): UsageTotals {\n const base = default_normalize_usage(raw)\n delete base.cached_input_tokens\n delete base.cache_write_tokens\n delete base.cache_write_1h_tokens\n delete base.reasoning_tokens\n return base\n}\n\n/**\n * Build the standard missing-peer error: names the package and the install\n * command so a missing peer is diagnosable from the message alone. Shared so\n * every optional-peer failure reads identically, whether the failing\n * `import()` names the peer directly (load_optional_peer below) or a local\n * module that reaches the peer through its own static import (the ai_sdk\n * turn seam in generate.ts, whose dynamic import must stay written in\n * generate.ts for its relative specifier to resolve correctly).\n */\nexport function missing_peer_error(peer_name: string, cause: unknown): Error {\n const detail = cause instanceof Error ? cause.message : JSON.stringify(cause)\n const message =\n `missing peer dependency '${peer_name}'. Install it with your package manager, e.g., \\`pnpm add ${peer_name}\\` or \\`npm install ${peer_name}\\`. Cause: ${detail}`\n return new Error(message, { cause })\n}\n\n/**\n * Dynamically import an optional peer dependency, rethrowing an import\n * failure via missing_peer_error so a missing peer is diagnosable from the\n * message alone.\n */\nexport async function load_optional_peer<t>(\n specifier: string,\n): Promise<t> {\n let mod: unknown\n try {\n mod = await import(specifier)\n } catch (err: unknown) {\n throw missing_peer_error(specifier, err)\n }\n // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion\n return mod as t\n}\n","/**\n * Shared plumbing for the native (raw-HTTP) provider adapters.\n *\n * Everything here is wire-neutral: how a turn travels HTTP (POST, non-2xx\n * mapping, stream-vs-JSON dispatch), how streamed bytes become framed\n * payloads, and the engine-message folds the 1:1 wires share. Each adapter\n * keeps what is genuinely its own dialect (request bodies, response parsers,\n * stream aggregators) and delegates the rest here, so the three adapters\n * cannot drift apart on retry classification or stream draining. This module\n * imports nothing from `ai` or `@ai-sdk/*` and nothing from the adapters, so\n * every adapter can import it cycle-free.\n */\n\nimport type {\n AssistantContentPart,\n Message,\n ProviderInit,\n StreamChunk,\n TurnRequest,\n TurnResult,\n UserContentPart,\n} from '../types.js'\nimport { provider_auth_error, provider_error } from '../errors.js'\n\n/**\n * The message under a JSON error envelope's `error` key, or undefined when\n * the shape carries none worth surfacing.\n */\nfunction error_field_message(parsed: unknown): string | undefined {\n // Stryker disable next-line ConditionalExpression,LogicalOperator: the\n // caller's try/catch already funnels every non-object parse to the raw\n // snippet, so this guard only narrows unknown -> object for Reflect.get;\n // forcing it either way throws-and-catches to the same fallback (equivalent).\n if (parsed === null || typeof parsed !== 'object') return undefined\n const error: unknown = Reflect.get(parsed, 'error')\n if (typeof error === 'string' && error.length > 0) return error\n // Stryker disable next-line ConditionalExpression,LogicalOperator: same as\n // above -- a non-object error still reaches the raw-snippet fallback via the\n // catch or the message-not-a-string check, so both boundaries are equivalent.\n if (error === null || typeof error !== 'object') return undefined\n const message: unknown = Reflect.get(error, 'message')\n return typeof message === 'string' && message.length > 0 ? message : undefined\n}\n\n/**\n * Pull a human-readable message out of a non-2xx body. The native wires share\n * one envelope family: Anthropic sends `{ type: 'error', error: { message } }`,\n * OpenAI-style wires send `{ error: { message } }`, and Ollama sends\n * `{ error: \"message\" }` (with the nested shape appearing behind proxies), so\n * one parser accepts a string or a `{ message }` object under `error` and\n * falls back to the raw body, truncated to 300 chars.\n */\nfunction extract_error_message(body: string): string {\n if (body.length === 0) return '(empty body)'\n let message: string | undefined\n try {\n message = error_field_message(JSON.parse(body))\n } catch {\n // Not JSON; fall through to the raw snippet.\n }\n if (message !== undefined) return message\n return body.length > 300 ? `${body.slice(0, 300)}...` : body\n}\n\n/**\n * Map a non-2xx response to what the engine's retry stack expects: 401\n * becomes a typed provider_auth_error, 429/5xx keep `status` +\n * `responseHeaders` so classify_provider_error marks them retryable\n * (rate_limit honoring retry-after, provider_5xx), and any other 4xx is a\n * permanent provider_error that surfaces as-is.\n */\nasync function response_error(response: Response, provider: string): Promise<Error> {\n let body = ''\n try {\n body = await response.text()\n } catch {\n // Body is best-effort detail; classification needs only the status.\n }\n const detail = extract_error_message(body)\n const status = response.status\n if (status === 401) {\n return new provider_auth_error(\n provider,\n `${provider} authentication failed (401): ${detail}`,\n )\n }\n if (status === 429 || status >= 500) {\n const retry_after = response.headers.get('retry-after')\n return Object.assign(\n new Error(`${provider} API error ${status}: ${detail}`),\n { status },\n retry_after !== null ? { responseHeaders: { 'retry-after': retry_after } } : {},\n )\n }\n return new provider_error(`${provider} API error ${status}: ${detail}`, { status, body })\n}\n\n/**\n * A transport failure in the `kind: 'network'` shape that the shared\n * classify_provider_error marks retryable. A stream that ends before its\n * closing event throws it too, since a cut-off stream is a dropped\n * connection, so the engine retries it whenever nothing consumed its chunks.\n */\nexport function network_failure(message: string): Error {\n return Object.assign(new Error(message), { kind: 'network' })\n}\n\n/**\n * A user abort surfaces as the fetch/reader AbortError; retry_turn converts\n * it via its own signal check, so it is rethrown untouched. Everything else\n * is a transport failure wrapped as a network_failure.\n */\nfunction rethrow_network_failure(err: unknown, abort: AbortSignal, provider: string): never {\n if (abort.aborted) throw err\n const detail = err instanceof Error ? err.message : String(err)\n throw network_failure(`${provider} native: network failure: ${detail}`)\n}\n\n/**\n * The response's media type, lowercased and without its parameters, or ''\n * when it names none.\n */\nfunction media_type(response: Response): string {\n const header = response.headers.get('content-type') ?? ''\n return (header.split(';')[0] ?? '').trim().toLowerCase()\n}\n\n/**\n * Read a non-stream response body and parse it as JSON. A read that fails\n * partway is a transport failure, wrapped as network the way a failed stream\n * read is; a body that arrives whole but does not parse is a permanent\n * provider_error naming what came back.\n */\nasync function read_json_body(\n response: Response,\n abort: AbortSignal,\n provider: string,\n): Promise<unknown> {\n let text: string\n try {\n text = await response.text()\n } catch (err: unknown) {\n rethrow_network_failure(err, abort, provider)\n }\n try {\n return JSON.parse(text)\n } catch {\n throw new provider_error(\n `${provider} native: response body is not valid JSON: check that base_url points at the ${provider} API (body: ${extract_error_message(text)})`,\n )\n }\n}\n\n/**\n * Run one native turn over HTTP: POST the dialect's body, map a non-2xx to\n * the retry stack's shapes, and hand the response to the dialect's stream or\n * JSON consumer. A streamed request whose reply doesn't arrive as the\n * dialect's stream media type (`text/event-stream`, or NDJSON for Ollama) is\n * read as a whole JSON body, so a server that answers with JSON still works,\n * and a page that isn't JSON fails with the `base_url` hint rather than as a\n * cut-off stream. `build_body` runs before the network try/catch, so a mapper\n * that rejects the request (e.g., a provider_capability_error for a part the\n * wire cannot carry) propagates unchanged instead of being retried as a\n * network failure. `req.on_wire`, when the call captures the wire, sees the\n * URL and the body object just before the body is serialized, and never a\n * header.\n */\nexport async function invoke_http_turn(\n req: TurnRequest,\n provider: string,\n request: {\n url: string\n headers: Record<string, string>\n build_body: () => Record<string, unknown>\n },\n consume: {\n stream: (response: Response) => Promise<TurnResult>\n parse: (payload: unknown) => TurnResult\n /** The media type that a streamed reply arrives as. */\n stream_media_type: string\n },\n): Promise<TurnResult> {\n const built = request.build_body()\n req.on_wire?.({ url: request.url, body: built })\n const body = JSON.stringify(built)\n let response: Response\n try {\n response = await fetch(request.url, {\n method: 'POST',\n headers: request.headers,\n body,\n signal: req.abort,\n })\n } catch (err: unknown) {\n rethrow_network_failure(err, req.abort, provider)\n }\n if (!response.ok) throw await response_error(response, provider)\n if (req.stream && media_type(response) === consume.stream_media_type) {\n return consume.stream(response)\n }\n return consume.parse(await read_json_body(response, req.abort, provider))\n}\n\n/**\n * Drain a streaming response: decode bytes, reassemble framed payloads (SSE\n * events or NDJSON lines), and feed them to the dialect's aggregator, which\n * dispatches chunks through req.dispatch_chunk as they arrive. Transport\n * failures mid-read wrap as network errors; aggregator throws (malformed\n * frames, mid-stream error events, a rejecting on_chunk) pass through\n * untouched, with the reader cancelled so the connection is released.\n */\nexport async function consume_framed_stream(\n response: Response,\n req: TurnRequest,\n provider: string,\n framing: { push: (text: string) => string[]; flush: () => string[] },\n create_aggregator: (dispatch: (chunk: StreamChunk) => Promise<void>) => {\n handle: (data: string) => Promise<void>\n complete: () => TurnResult\n },\n): Promise<TurnResult> {\n const body = response.body\n if (body === null) {\n throw new provider_error(`${provider} native: streaming response has no body`)\n }\n const aggregator = create_aggregator(req.dispatch_chunk ?? (async (): Promise<void> => {}))\n const reader = body.getReader()\n const text_decoder = new TextDecoder()\n\n const next_bytes = async (): Promise<Uint8Array | undefined> => {\n let step: Awaited<ReturnType<typeof reader.read>>\n try {\n step = await reader.read()\n } catch (err: unknown) {\n rethrow_network_failure(err, req.abort, provider)\n }\n return step.done ? undefined : step.value\n }\n\n // Sequential awaits are the contract here: chunk order is an engine\n // invariant and each frame mutates aggregator state, so no parallelism.\n try {\n while (true) {\n const bytes = await next_bytes()\n if (bytes === undefined) break\n for (const data of framing.push(text_decoder.decode(bytes, { stream: true }))) {\n await aggregator.handle(data)\n }\n }\n } finally {\n // Frees the connection when an error exits the loop early; a no-op on a\n // fully drained stream.\n void reader.cancel().catch(() => {})\n }\n const tail = [...framing.push(text_decoder.decode()), ...framing.flush()]\n for (const data of tail) {\n await aggregator.handle(data)\n }\n return aggregator.complete()\n}\n\n/**\n * Incremental newline framing shared by the SSE and NDJSON decoders: buffer\n * decoded text across arbitrary chunk boundaries, hand each completed line\n * (CR trimmed) to `handle_line`, and on flush hand over an unterminated tail\n * line, then `on_flush` for state a decoder holds across lines (an SSE event\n * never closed by a blank line).\n */\nexport function create_line_splitter(\n handle_line: (line: string, out: string[]) => void,\n on_flush?: (out: string[]) => void,\n): { push: (text: string) => string[]; flush: () => string[] } {\n let buffer = ''\n\n const take_line = (raw: string, out: string[]): void => {\n handle_line(raw.endsWith('\\r') ? raw.slice(0, -1) : raw, out)\n }\n\n return {\n push(text: string): string[] {\n buffer += text\n const out: string[] = []\n let newline = buffer.indexOf('\\n')\n while (newline >= 0) {\n take_line(buffer.slice(0, newline), out)\n buffer = buffer.slice(newline + 1)\n newline = buffer.indexOf('\\n')\n }\n return out\n },\n flush(): string[] {\n const out: string[] = []\n if (buffer.length > 0) take_line(buffer, out)\n buffer = ''\n on_flush?.(out)\n return out\n },\n }\n}\n\n/**\n * Decode a tool call's wire `arguments` string into the engine's input value:\n * non-empty JSON parses (bad JSON is a provider_error naming the tool), and\n * an absent or empty value means `{}`, the shape some servers send for\n * no-argument calls. The Ollama wire's structured-object arguments are its\n * caller's business before this runs.\n */\nexport function parse_tool_call_arguments(\n raw_args: unknown,\n provider: string,\n tool_name: string,\n): unknown {\n if (typeof raw_args === 'string' && raw_args.length > 0) {\n try {\n return JSON.parse(raw_args)\n } catch {\n throw new provider_error(\n `${provider} native: tool_calls arguments for ${tool_name} is not valid JSON`,\n )\n }\n }\n return {}\n}\n\n/**\n * Fold engine messages into a wire's message array by role. Serves the wires\n * whose messages map 1:1 in place (chat/completions, Ollama's /api/chat); the\n * Messages API's system-hoisting and role-merging rules live in its own\n * mapper instead.\n */\nexport function map_messages_by_role<m>(\n messages: ReadonlyArray<Message>,\n wire: {\n system: (content: string) => m\n user: (content: string | UserContentPart[]) => m\n assistant: (content: string | AssistantContentPart[]) => m\n tool: (message: Extract<Message, { role: 'tool' }>) => m\n },\n): m[] {\n const out: m[] = []\n for (const message of messages) {\n switch (message.role) {\n case 'system':\n out.push(wire.system(message.content))\n break\n case 'user':\n out.push(wire.user(message.content))\n break\n case 'assistant':\n out.push(wire.assistant(message.content))\n break\n case 'tool':\n out.push(wire.tool(message))\n break\n }\n }\n return out\n}\n\ntype ReasoningPart = Extract<AssistantContentPart, { type: 'reasoning' }>\n\n/**\n * Whether a reasoning part is one this provider may send back: only a part\n * carrying data under the provider's own key goes. A part keyed for another\n * vendor stays behind, so a `fallback` never hands one vendor's signature to\n * another, and so does a part with no data, whose text alone is what a\n * signing wire refuses.\n */\nexport function is_own_reasoning(part: ReasoningPart, key: string): boolean {\n return part.provider_options?.[key] !== undefined\n}\n\n/**\n * Partition assistant content parts into the text runs, tool calls, and\n * reasoning the wire mappers serialize separately. `reasoning` holds only\n * the parts `provider` may send back, in order (see is_own_reasoning). An\n * opaque part belongs to the provider that sent it, and these formats carry\n * no such block, so it is skipped.\n */\nexport function split_assistant_parts(\n parts: ReadonlyArray<AssistantContentPart>,\n provider: string,\n): {\n texts: string[]\n tool_parts: Array<Extract<AssistantContentPart, { type: 'tool_call' }>>\n reasoning: ReasoningPart[]\n} {\n const texts: string[] = []\n const tool_parts: Array<Extract<AssistantContentPart, { type: 'tool_call' }>> = []\n const reasoning: ReasoningPart[] = []\n for (const part of parts) {\n if (part.type === 'text') texts.push(part.text)\n else if (part.type === 'tool_call') tool_parts.push(part)\n else if (part.type === 'reasoning' && is_own_reasoning(part, provider)) reasoning.push(part)\n }\n return { texts, tool_parts, reasoning }\n}\n\n/**\n * Read the api_key and base_url every OpenAI-compatible dialect starts from:\n * a missing or non-string api_key becomes '' (the core's empty-key guard owns\n * the throw), and an absent base_url falls back to the dialect's default.\n */\nexport function read_dialect_init(\n init: ProviderInit,\n default_base_url: string,\n): { api_key: string; base_url: string } {\n return {\n api_key: typeof init.api_key === 'string' ? init.api_key : '',\n base_url:\n typeof init.base_url === 'string' && init.base_url.length > 0\n ? init.base_url\n : default_base_url,\n }\n}\n","/**\n * Collapse a leading run of system messages into a single joined string,\n * returning the remaining messages.\n *\n * Both message paths hoist a leading system run out of their list the same way:\n * the engine-Message side (generate.ts split_leading_system_messages) hands the\n * run to a native adapter's TurnRequest.system, and the AI SDK side\n * (providers/ai_sdk/invoke.ts split_leading_system) hands it to the SDK's\n * top-level `instructions` option. Same guard, same '\\n\\n' join, and the same\n * \"return the list untouched when hoisting would leave `messages` empty\" rule,\n * since provider APIs reject an empty messages array. They differ only in the\n * element type and how a system message's text is read, so each caller supplies\n * `system_text`; the traversal and its guards live here once.\n */\nexport function split_leading_system_run<T extends { readonly role: string }>(\n messages: ReadonlyArray<T>,\n system_text: (message: Extract<T, { role: 'system' }>) => string,\n): { system?: string; messages: T[] } {\n let run_end = 0\n const system_parts: string[] = []\n while (run_end < messages.length) {\n const m = messages[run_end]\n if (!is_leading_system(m)) break\n system_parts.push(system_text(m))\n run_end += 1\n }\n const rest = messages.slice(run_end)\n if (system_parts.length === 0 || rest.length === 0) {\n return { messages: [...messages] }\n }\n return { system: system_parts.join('\\n\\n'), messages: rest }\n}\n\n/**\n * Narrow a possibly undefined message to the system member of its union.\n *\n * A cast-free type guard so `split_leading_system_run` can hand the narrowed\n * message straight to `system_text` without a `T`-eroding assertion; the\n * optional chain covers the out-of-bounds `undefined` the index access yields.\n */\nfunction is_leading_system<T extends { readonly role: string }>(\n m: T | undefined,\n): m is Extract<T, { role: 'system' }> {\n // Stryker disable next-line OptionalChaining: within the loop guard run_end < messages.length, m is always an in-bounds (defined) message, so m.role and m?.role read identically.\n return m?.role === 'system'\n}\n"],"mappings":"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"}
package/dist/mcp.d.ts CHANGED
@@ -1,6 +1,6 @@
1
1
  import { c as Step, h as TrajectoryLogger } from "./types-CPqLZOEr.js";
2
2
  import { r as ToolSchema } from "./types-BK0UW28o.js";
3
- import { k as Tool } from "./types-Sw0oHW-_.js";
3
+ import { M as Tool } from "./types-BNgAUQP1.js";
4
4
  import { Client } from "@modelcontextprotocol/sdk/client/index.js";
5
5
  import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
6
6
  import { z } from "zod";
@@ -43,6 +43,7 @@ type McpClientOptions = {
43
43
  };
44
44
  include?: ReadonlyArray<string>;
45
45
  default_description?: (tool_name: string) => string;
46
+ name_prefix?: string;
46
47
  };
47
48
  type McpClientHandle = {
48
49
  readonly tools: ReadonlyArray<Tool>;