@ixo/oracle-runtime-workers 0.13.0 → 0.16.0

package/src/core/budgeted-llm.ts

@@ -0,0 +1,223 @@
+/**
+ * The turn's LLM adapter, metered: every model it hands out carries a
+ * callback that reserves the call against the `TurnBudget` before the
+ * provider is contacted and settles the reservation to the provider's
+ * reported usage when the call ends. Helper models (summarizer, attachment
+ * extraction, a plugin's own `ctx.llm.get`) are covered the same way as the
+ * main model, since they all come from this adapter.
+ *
+ * The same handler is also put in the graph's run config (`callbacks`) so a
+ * model the host constructed elsewhere and passed in directly is still
+ * charged; a call reported through both paths is counted once.
+ */
+import { BaseCallbackHandler } from '@langchain/core/callbacks/base';
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import type { LLMResult } from '@langchain/core/outputs';
+import type { ChatOpenAIFields, ModelRole } from '../plugin-api/types';
+import {
+  estimateContentTokens,
+  messageContentTokens,
+  messageToolCallTokens,
+} from './context-budget';
+import type { LlmAdapter } from './runtime-context';
+import type { TurnBudget } from './turn-budget';
+
+export interface BudgetedLlmOptions {
+  budget: TurnBudget;
+  /** Tokens reserved for the reply of each call (the context budget's output reserve). */
+  outputReserveTokens: number;
+  /** The turn's abort signal: a call after the abort is refused before it starts. */
+  signal?: AbortSignal;
+}
+
+export interface BudgetedLlm extends LlmAdapter {
+  /** Put this in the run config's `callbacks` as well. */
+  readonly callback: BaseCallbackHandler;
+}
+
+/**
+ * Key of a request's tool list for the per-turn schema estimate: the tool
+ * names in order. Within one turn a name always carries the same schema (the
+ * tools are bound when the turn's graph is built), so the names identify
+ * the list; anything without a recognisable name is not cached.
+ */
+function toolListKey(tools: unknown): string | undefined {
+  if (!Array.isArray(tools)) return undefined;
+  const names: string[] = [];
+  for (const entry of tools) {
+    const fn: unknown =
+      entry && typeof entry === 'object' && 'function' in entry
+        ? entry.function
+        : entry;
+    const name: unknown =
+      fn && typeof fn === 'object' && 'name' in fn ? fn.name : undefined;
+    if (typeof name !== 'string') return undefined;
+    names.push(name);
+  }
+  return names.join('\n');
+}
+
+/**
+ * What one model call sends, reduced to what costs tokens. Message estimates
+ * are memoised per message (`messageContentTokens`), the tool schemas per
+ * tool list in `toolTokens`, so a long history is not re-serialised on every
+ * step of the turn.
+ */
+function estimateRequestTokens(
+  messages: LLMResultMessages,
+  invocationParams: unknown,
+  toolTokens: Map<string, number>,
+): number {
+  let tokens = 0;
+  for (const batch of messages)
+    for (const message of batch) {
+      tokens += messageContentTokens(message) + 4;
+      if ('tool_calls' in message && Array.isArray(message.tool_calls))
+        tokens += messageToolCallTokens(message, message.tool_calls);
+    }
+  if (
+    invocationParams &&
+    typeof invocationParams === 'object' &&
+    'tools' in invocationParams
+  ) {
+    const { tools } = invocationParams;
+    const key = toolListKey(tools);
+    let schema = key === undefined ? undefined : toolTokens.get(key);
+    if (schema === undefined) {
+      schema = estimateContentTokens(tools);
+      if (key !== undefined) toolTokens.set(key, schema);
+    }
+    tokens += schema;
+  }
+  return tokens;
+}
+
+/** The summarizer tags its model call with this `lc_source` (LangChain's summarization middleware). */
+const SUMMARIZATION_SOURCE = 'summarization';
+
+type LLMResultMessages = Parameters<
+  NonNullable<BaseCallbackHandler['handleChatModelStart']>
+>[1];
+
+function numberField(value: unknown, key: string): number | undefined {
+  if (!value || typeof value !== 'object' || !(key in value)) return undefined;
+  const n = Reflect.get(value, key);
+  return typeof n === 'number' && Number.isFinite(n) ? n : undefined;
+}
+
+/** Provider usage of one call: `llmOutput.tokenUsage` (OpenAI-compatible) or the message's `usage_metadata`. */
+function reportedTotalTokens(output: LLMResult): number | undefined {
+  const usage: unknown = output.llmOutput?.tokenUsage;
+  const total = numberField(usage, 'totalTokens');
+  if (total !== undefined) return total;
+  const prompt = numberField(usage, 'promptTokens');
+  const completion = numberField(usage, 'completionTokens');
+  if (prompt !== undefined && completion !== undefined)
+    return prompt + completion;
+  const generation: unknown = output.generations[0]?.[0];
+  const message =
+    generation && typeof generation === 'object' && 'message' in generation
+      ? generation.message
+      : undefined;
+  const meta =
+    message && typeof message === 'object' && 'usage_metadata' in message
+      ? message.usage_metadata
+      : undefined;
+  return numberField(meta, 'total_tokens');
+}
+
+class TurnBudgetHandler extends BaseCallbackHandler {
+  name = 'TurnBudgetHandler';
+  /** A refused reservation must fail the model call, not be logged and ignored. */
+  raiseError = true;
+  awaitHandlers = true;
+  private readonly reservations = new Map<
+    string,
+    { tokens: number; summary: boolean }
+  >();
+  /** Tool-schema estimate per tool list, for this turn (see `toolListKey`). */
+  private readonly toolTokens = new Map<string, number>();
+
+  constructor(private readonly options: BudgetedLlmOptions) {
+    super();
+  }
+
+  handleChatModelStart(
+    _llm: unknown,
+    messages: LLMResultMessages,
+    runId: string,
+    _parentRunId?: string,
+    extraParams?: Record<string, unknown>,
+    _tags?: string[],
+    metadata?: Record<string, unknown>,
+  ): void {
+    // The handler can reach the same call twice (model-level and run-level
+    // registration); the first registration charges it.
+    if (this.reservations.has(runId)) return;
+    const tokens = this.options.budget.reserveModel(
+      estimateRequestTokens(
+        messages,
+        extraParams?.invocation_params,
+        this.toolTokens,
+      ),
+      this.options.outputReserveTokens,
+      this.options.signal,
+    );
+    this.reservations.set(runId, {
+      tokens,
+      summary: metadata?.lc_source === SUMMARIZATION_SOURCE,
+    });
+  }
+
+  handleLLMEnd(output: LLMResult, runId: string): void {
+    const reservation = this.reservations.get(runId);
+    if (reservation === undefined) return;
+    this.reservations.delete(runId);
+    const reported = reportedTotalTokens(output);
+    if (reported !== undefined)
+      this.options.budget.settleModel(reservation.tokens, reported);
+  }
+
+  handleLLMError(_error: unknown, runId: string): void {
+    const reservation = this.reservations.get(runId);
+    this.reservations.delete(runId);
+    // A failed call keeps its reservation: the provider may have consumed
+    // the input before failing, and a retry reserves again. A failed summary
+    // is the exception: the summarizer swallows the failure, the turn goes on
+    // with its history unchanged and does not try again (summarization.ts),
+    // so its reservation — the whole history it was handed — is given back
+    // instead of starving the rest of the turn.
+    if (reservation?.summary)
+      this.options.budget.releaseModel(reservation.tokens);
+  }
+}
+
+function attach(model: BaseChatModel, handler: BaseCallbackHandler): void {
+  const existing = model.callbacks;
+  if (existing === undefined) {
+    model.callbacks = [handler];
+    return;
+  }
+  if (Array.isArray(existing)) {
+    if (!existing.includes(handler)) model.callbacks = [...existing, handler];
+    return;
+  }
+  const manager = existing.copy();
+  manager.addHandler(handler);
+  model.callbacks = manager;
+}
+
+export function budgetedLlm(
+  adapter: LlmAdapter,
+  options: BudgetedLlmOptions,
+): BudgetedLlm {
+  const callback = new TurnBudgetHandler(options);
+  return {
+    callback,
+    get(role: ModelRole, params?: ChatOpenAIFields): BaseChatModel {
+      const model = adapter.get(role, params);
+      attach(model, callback);
+      return model;
+    },
+  };
+}

package/src/core/capability-router.ts

@@ -0,0 +1,273 @@
+import {
+  AmbiguousDecisionProviderError,
+  CAPABILITY_ROUTER_MODES,
+  CAPABILITY_ROUTE_DECISION_NAME,
+  DecisionProviderUnavailableError,
+  capabilityRouteDecision,
+  decideCapabilityRoute,
+  toRoutableCapabilities,
+  type CapabilityRouterMode,
+  type DecisionEvaluator,
+  type DecisionTraceOptions,
+  type RoutableCapability,
+} from '@ixo/common/ai/decisions';
+import type { Logger } from '../plugin-api/types';
+import { unmetRequirements } from './manifest';
+import type { RegisteredManifest } from './registries';
+
+/**
+ * Predicts, before the first model call of a turn, which on-demand plugin the
+ * user's message needs and preloads that plugin's tools for the turn, so the
+ * model does not spend a round trip on `load_capability`.
+ *
+ * The preload is one-turn state only: it is admitted by the capability gate
+ * and visible as loaded to tool handlers, but never written to the graph's
+ * `loadedPlugins` channel. The router fails open — any evaluation failure
+ * preloads nothing and the turn proceeds exactly as without a router.
+ */
+export interface CapabilityRouterOptions {
+  evaluator: DecisionEvaluator;
+  logger: Logger;
+  /**
+   * Keeps a shadow evaluation alive after the turn has moved on
+   * (`ctx.waitUntil` on Workers). Without it the promise is merely detached.
+   */
+  background?: (work: Promise<unknown>) => void;
+  now?: () => number;
+}
+
+export interface CapabilityRouteTurn {
+  mode: CapabilityRouterMode;
+  /** Every registered manifest; the router picks the routable candidates. */
+  manifests: readonly RegisteredManifest[];
+  /** Plugins the thread has already loaded (the checkpointed channel). */
+  loaded: ReadonlySet<string>;
+  /**
+   * Plugins the user's delegation leaves with nothing to use (all of their
+   * tools admin-plane and not granted): never offered to the router. A
+   * function is called only when the router actually evaluates (not when
+   * it is off, or the message is empty), so the host does not compute the
+   * set for nothing.
+   */
+  hidden?: ReadonlySet<string> | (() => Promise<ReadonlySet<string>>);
+  /**
+   * The user's delegation, as `ctx.ucan.hasCapability`: a plugin whose
+   * `manifest.requires` it does not grant is never offered (the gate would
+   * refuse every one of its tools). Omitted, `requires` is not checked.
+   */
+  hasCapability?: (resource: string, action: string) => boolean;
+  /** The user's message text for this turn. */
+  text: string;
+  requestId: string;
+  /** The turn's abort signal; only an awaited (`on`) evaluation is bound to it. */
+  signal?: AbortSignal;
+  /**
+   * The turn's tracer and trace metadata. The router runs before the graph,
+   * outside any LangChain run, so without these its Decision is not traced.
+   */
+  trace?: DecisionTraceOptions;
+  /**
+   * Shadow mode only: receives what the router would have preloaded once its
+   * evaluation completes, so the host can compare it with what the turn
+   * actually loaded.
+   */
+  onShadowVerdict?: (wouldPreload: readonly string[]) => void;
+}
+
+export type CapabilityRouter = (
+  turn: CapabilityRouteTurn,
+) => Promise<ReadonlySet<string>>;
+
+const NOTHING: ReadonlySet<string> = new Set<string>();
+
+/** Narrows an env value to a router mode; anything else is `off`. */
+export function capabilityRouterMode(value: unknown): CapabilityRouterMode {
+  return CAPABILITY_ROUTER_MODES.find((mode) => mode === value) ?? 'off';
+}
+
+/**
+ * The manifests the router may choose from: effectively on-demand plugins the
+ * thread has not loaded yet. `always` plugins are already bound and `silent`
+ * ones are never surfaced, so predicting them is pointless; a `hidden` one
+ * (no tool the user's delegation reaches), or one whose `requires` the
+ * delegation (`hasCapability`) does not grant, is not even named to the
+ * router.
+ */
+export function routableCandidates(
+  manifests: readonly RegisteredManifest[],
+  loaded: ReadonlySet<string>,
+  hidden: ReadonlySet<string> = NOTHING,
+  hasCapability?: (resource: string, action: string) => boolean,
+): RoutableCapability[] {
+  return toRoutableCapabilities(
+    manifests
+      .filter(
+        ({ pluginName, manifest }) =>
+          (manifest.visibility ?? 'on-demand') === 'on-demand' &&
+          !loaded.has(pluginName) &&
+          !hidden.has(pluginName) &&
+          (hasCapability === undefined ||
+            unmetRequirements(manifest, hasCapability).length === 0),
+      )
+      .map(({ pluginName, manifest }) => ({
+        name: pluginName,
+        title: manifest.title,
+        summary: manifest.summary,
+      })),
+  );
+}
+
+/**
+ * After-turn comparison for shadow mode: which plugins the turn loaded on its
+ * own, and whether that matches what the router would have preloaded.
+ */
+export function shadowAgreement(args: {
+  priorLoaded: ReadonlySet<string>;
+  loadedAfter: ReadonlySet<string>;
+  wouldPreload: readonly string[];
+}): { loadedDuringTurn: string[]; agree: boolean } {
+  const loadedDuringTurn = Array.from(args.loadedAfter).filter(
+    (name) => !args.priorLoaded.has(name),
+  );
+  const predicted = new Set(args.wouldPreload);
+  const agree =
+    predicted.size === loadedDuringTurn.length &&
+    loadedDuringTurn.every((name) => predicted.has(name));
+  return { loadedDuringTurn, agree };
+}
+
+function errorName(error: unknown): string {
+  return error instanceof Error ? error.name : typeof error;
+}
+
+function list(names: readonly string[]): string {
+  return `[${names.join(', ')}]`;
+}
+
+export function createCapabilityRouter(
+  options: CapabilityRouterOptions,
+): CapabilityRouter {
+  const { evaluator, logger } = options;
+  const now = options.now ?? (() => Date.now());
+  const background =
+    options.background ??
+    ((work: Promise<unknown>) => {
+      void work;
+    });
+  // A missing Decision provider is a deployment fact, not a per-turn event:
+  // said once per object, then the router stays quiet.
+  let unavailableWarned = false;
+
+  // An ambiguous multi-provider configuration is a subclass: equally a
+  // deployment fact, but fixed by routing rather than by adding a provider.
+  const unavailable = (
+    error: unknown,
+  ): error is DecisionProviderUnavailableError =>
+    error instanceof DecisionProviderUnavailableError;
+
+  const warnUnavailable = (
+    requestId: string,
+    mode: CapabilityRouterMode,
+    error: DecisionProviderUnavailableError,
+  ) => {
+    if (unavailableWarned) return;
+    unavailableWarned = true;
+    const hint =
+      error instanceof AmbiguousDecisionProviderError
+        ? `route ${CAPABILITY_ROUTE_DECISION_NAME} or set decisionProviderPolicy.defaultProviderId`
+        : 'set DECISION_PROVIDER or CAPABILITY_ROUTER=off';
+    logger.warn(
+      `[capability-router] request=${requestId} mode=${mode} status=fallback reason=${error.name} (${hint})`,
+    );
+  };
+
+  return async (turn) => {
+    if (turn.mode === 'off') return NOTHING;
+    const text = turn.text.trim();
+    if (!text) return NOTHING;
+    let hidden: ReadonlySet<string> | undefined;
+    try {
+      hidden =
+        typeof turn.hidden === 'function' ? await turn.hidden() : turn.hidden;
+    } catch (error) {
+      // Fail open like any other router failure: no preload this turn.
+      logger.warn(
+        `[capability-router] request=${turn.requestId} mode=${turn.mode} status=fallback reason=${errorName(error)} (hidden plugins unavailable)`,
+      );
+      return NOTHING;
+    }
+    const capabilities = routableCandidates(
+      turn.manifests,
+      turn.loaded,
+      hidden,
+      turn.hasCapability,
+    );
+    if (capabilities.length === 0) return NOTHING;
+
+    // The turn is prepared from a checkpoint read without its messages, so
+    // the router sees the current message only; `recentTurns` stays empty.
+    const input = { text, recentTurns: [], capabilities };
+    const { requestId } = turn;
+
+    if (turn.mode === 'shadow') {
+      const started = now();
+      background(
+        evaluator
+          .evaluate(capabilityRouteDecision, input, turn.trace)
+          .then((evaluation) => {
+            const verdict = decideCapabilityRoute(evaluation, capabilities);
+            logger.log(
+              `[capability-router-shadow] request=${requestId} status=ok ` +
+                `needsCapability=${verdict.needsCapability.toFixed(2)} ` +
+                `capability=${verdict.capability ?? '-'} ` +
+                `capabilityConfidence=${verdict.capabilityConfidence?.toFixed(2) ?? '-'} ` +
+                `wouldPreload=${list(verdict.preload)} reason=${verdict.reason} ` +
+                `latencyMs=${now() - started} provider=${evaluation.provider} model=${evaluation.model}`,
+            );
+            turn.onShadowVerdict?.(verdict.preload);
+          })
+          .catch((error: unknown) => {
+            if (unavailable(error)) {
+              warnUnavailable(requestId, 'shadow', error);
+              return;
+            }
+            logger.log(
+              `[capability-router-shadow] request=${requestId} status=failed errorType=${errorName(error)} latencyMs=${now() - started}`,
+            );
+          }),
+      );
+      return NOTHING;
+    }
+
+    try {
+      const evaluation = await evaluator.evaluate(
+        capabilityRouteDecision,
+        input,
+        {
+          ...turn.trace,
+          ...(turn.signal && { signal: turn.signal }),
+        },
+      );
+      const verdict = decideCapabilityRoute(evaluation, capabilities);
+      if (verdict.preload.length === 0) {
+        logger.debug?.(
+          `[capability-router] request=${requestId} mode=on status=none reason=${verdict.reason} candidates=${capabilities.length}`,
+        );
+        return NOTHING;
+      }
+      logger.log(
+        `[capability-router] request=${requestId} preloaded=${list(verdict.preload)} candidates=${capabilities.length}`,
+      );
+      return new Set(verdict.preload);
+    } catch (error) {
+      if (unavailable(error)) {
+        warnUnavailable(requestId, 'on', error);
+      } else {
+        logger.warn(
+          `[capability-router] request=${requestId} mode=on status=fallback reason=${errorName(error)}`,
+        );
+      }
+      return NOTHING;
+    }
+  };
+}

package/src/core/context-budget.ts

@@ -3,7 +3,8 @@
  * (`context-window.ts`) so that they scale with the model:
  *
  *   - `summarizeAtTokens`  — the history is condensed once it is this large
- *                            (default half the window; Hermes fires at 50%);
+ *                            (default half the window; Hermes fires at 50%),
+ *                            never above what the summarizer may read;
  *   - `pruneAtTokens`      — above this, old tool results are demoted to
  *                            one-liners in the request (no model call, no
  *                            state change) before the model sees them;
@@ -64,8 +65,14 @@ export interface ContextBudget {
   resultCapChars: number;
   requestCapTokens: number;
   outputReserveTokens: number;
-  /** The summarizer's own input limit (what it may read to write the summary). */
+  /**
+   * The summarizer's own input limit (what it may read to write the summary):
+   * the smaller of what the main model's request cap and the summarizing
+   * model's own request cap leave, less a margin for the summary prompt.
+   */
   summaryInputTokens: number;
+  /** The summarizing model's window, when the host resolved it. */
+  summaryWindowTokens?: number;
   summarizeTriggerMessages?: number;
   keepMessages: number;
 }
@@ -142,12 +149,14 @@ export function contextKnobs(
   };
 }
 
-/** The budget for a turn on `resolution.model`. */
-export function contextBudgetFor(
-  resolution: ContextWindowResolution,
-  knobs: ContextKnobs = DEFAULT_CONTEXT_KNOBS,
-): ContextBudget {
-  const window = resolution.tokens;
+/** Tokens the summary prompt and its framing need on top of the history it reads. */
+const SUMMARY_PROMPT_MARGIN_TOKENS = 4_000;
+
+/** What a request to a model with `window` may hold, the reply reserve left out. */
+function requestCapFor(
+  window: number,
+  knobs: ContextKnobs,
+): { requestCapTokens: number; outputReserveTokens: number } {
   // The reply reserve can never eat a small window: cap it at a quarter.
   const outputReserveTokens = Math.min(
     knobs.outputReserveTokens,
@@ -157,9 +166,42 @@ export function contextBudgetFor(
     1_000,
     Math.floor(window * knobs.requestFraction) - outputReserveTokens,
   );
+  return { requestCapTokens, outputReserveTokens };
+}
+
+/**
+ * The budget for a turn on `resolution.model`. `summarizer` is the window of
+ * the model that writes the summary (the `routing` role), resolved the same
+ * way: the history it is handed is bounded by its own window too, not only
+ * by the main model's. Omitted, the main model's window alone bounds it.
+ */
+export function contextBudgetFor(
+  resolution: ContextWindowResolution,
+  knobs: ContextKnobs = DEFAULT_CONTEXT_KNOBS,
+  summarizer?: ContextWindowResolution,
+): ContextBudget {
+  const window = resolution.tokens;
+  const { requestCapTokens, outputReserveTokens } = requestCapFor(
+    window,
+    knobs,
+  );
+  const summaryRequestCap = summarizer
+    ? Math.min(
+        requestCapTokens,
+        requestCapFor(summarizer.tokens, knobs).requestCapTokens,
+      )
+    : requestCapTokens;
+  const summaryInputTokens = Math.max(
+    1_000,
+    summaryRequestCap - SUMMARY_PROMPT_MARGIN_TOKENS,
+  );
+  // The summarizer keeps only the newest `summaryInputTokens` of what it is
+  // asked to condense and drops the rest unread — the earlier summary first.
+  // Summarizing starts no later than that, so nothing is lost unsummarized.
   const summarizeAtTokens = Math.min(
     Math.floor(window * knobs.summarizeFraction),
     requestCapTokens,
+    summaryInputTokens,
   );
   const pruneAtTokens = Math.min(
     Math.floor(window * knobs.pruneFraction),
@@ -177,7 +219,8 @@ export function contextBudgetFor(
     ),
     requestCapTokens,
     outputReserveTokens,
-    summaryInputTokens: Math.max(1_000, requestCapTokens - 4_000),
+    summaryInputTokens,
+    ...(summarizer ? { summaryWindowTokens: summarizer.tokens } : {}),
     ...(knobs.summarizeTriggerMessages !== undefined
       ? { summarizeTriggerMessages: knobs.summarizeTriggerMessages }
       : {}),
@@ -196,6 +239,50 @@ export function estimateContentTokens(content: unknown): number {
   }
 }
 
+/**
+ * Per-message memo of the chars/4 estimates: every model step of a turn
+ * re-estimates the whole history (the context guard, the turn budget, the
+ * summarizer's trigger), and the history is the same message objects from
+ * step to step. An entry is reused only while the message still holds the
+ * same `content` / `tool_calls` values it was computed from.
+ */
+interface MessageEstimate {
+  content: unknown;
+  contentTokens: number;
+  toolCalls?: { value: unknown; tokens: number };
+}
+
+const messageEstimates = new WeakMap<object, MessageEstimate>();
+
+function estimateOf(message: { content: unknown }): MessageEstimate {
+  const cached = messageEstimates.get(message);
+  if (cached && cached.content === message.content) return cached;
+  const fresh: MessageEstimate = {
+    content: message.content,
+    contentTokens: estimateContentTokens(message.content),
+  };
+  messageEstimates.set(message, fresh);
+  return fresh;
+}
+
+/** `estimateContentTokens(message.content)`, memoised per message. */
+export function messageContentTokens(message: { content: unknown }): number {
+  return estimateOf(message).contentTokens;
+}
+
+/** `estimateContentTokens(toolCalls)` for `message`'s tool calls, memoised per message. */
+export function messageToolCallTokens(
+  message: { content: unknown },
+  toolCalls: unknown,
+): number {
+  const entry = estimateOf(message);
+  if (entry.toolCalls && entry.toolCalls.value === toolCalls)
+    return entry.toolCalls.tokens;
+  const tokens = estimateContentTokens(toolCalls);
+  entry.toolCalls = { value: toolCalls, tokens };
+  return tokens;
+}
+
 export function describeBudget(b: ContextBudget): string {
-  return `model=${b.model} window=${b.windowTokens} (${b.origin}) summarizeAt=${b.summarizeAtTokens} pruneAt=${b.pruneAtTokens} resultCap=${b.resultCapChars}c requestCap=${b.requestCapTokens} reserve=${b.outputReserveTokens}`;
+  return `model=${b.model} window=${b.windowTokens} (${b.origin}) summarizeAt=${b.summarizeAtTokens} pruneAt=${b.pruneAtTokens} resultCap=${b.resultCapChars}c requestCap=${b.requestCapTokens} reserve=${b.outputReserveTokens} summaryInput=${b.summaryInputTokens}${b.summaryWindowTokens !== undefined ? ` (summarizer window ${b.summaryWindowTokens})` : ''}`;
 }