@theokit/agents 2.0.0 → 4.0.0

package/dist/index.d.ts

@@ -1,6 +1,5 @@
-import { G as Guardrail, L as LoopStrategy, R as ReflectionStrategy, C as CompiledAgentOptions, M as MainLoopMeta, a as CompiledTool, b as ReasoningEffort, c as RoundStreamFactory, S as StreamEvent, D as DelegationResult, d as ContextWindowOptions, H as HumanInTheLoopOptions, e as McpServersMap, f as MemoryOptions, P as ProjectContextOptions, g as SkillsOptions, h as SkillsSelection, T as ToolOptions, A as ApprovalOptions, i as AgentManifestEntry } from './bridge-entry-F9kHGaIn.js';
-export { j as AGENT_BRAND, k as AfterToolCallContext, l as AgentBuilder, m as AgentDefinition, n as AgentDefinitionError, o as AgentExecutionContext, p as AgentManifest, q as AgentManifestSource, r as AgentManifestTool, s as AgentOptions, t as AgentRoute, u as AgentRouteContext, v as AgentRunInfo, w as AgentStreamEvent, x as AgentTurnMetadata, y as AgentsPluginOptions, z as ApiErrorContext, B as ApiErrorDecision, E as ApiErrorPolicy, F as ApprovalRequiredEvent, I as ArtifactChunkEvent, J as ArtifactStartEvent, K as BackgroundDelegation, N as BeforeToolCallContext, O as BudgetExceededError, Q as BudgetOptions, U as CheckpointSavedEvent, V as CompiledContextWindow, W as ContextualTool, X as CostBudgetExceededError, Y as DEFAULT_MAX_ITERATIONS, Z as DefineAgentConfig, _ as DelegateFn, $ as DelegateOptions, a0 as DelegationError, a1 as DoneEvent, a2 as ErrorEvent, a3 as FileEditEvent, a4 as GuardrailAction, a5 as GuardrailPhase, a6 as GuardrailResult, a7 as GuardrailViolationError, a8 as HitlDecision, a9 as InferAgentInput, aa as InferAgentToolNames, ab as IterationEvent, ac as LLMCallContext, ad as LoopFinishReason, ae as LoopOutcome, af as LoopStrategyConfig, ag as MainLoopOptions, ah as McpApprovalSpec, ai as McpRegistryConfig, aj as McpRequestContext, ak as McpSelection, al as PartialToolCallEvent, am as PolicyHandler, an as ProcessInputContext, ao as ReflectionContext, ap as ReflectionResult, aq as ReflectionStrategyConfig, ar as RunStartedEvent, as as ScoreVerdict, at as ScoredDelegation, au as Scorer, av as SdkAgentHandle, aw as SdkMessage, ax as Segment, ay as SkillsRequestContext, az as StateUpdateEvent, aA as TextDeltaEvent, aB as ThinkingEvent, aC as TimeoutAction, aD as ToolCallEvent, aE as ToolCallVeto, aF as ToolHooks, aG as ToolHooksPlugin, aH as ToolResultEvent, aI as ToolWalkResult, aJ as ToolboxOptions, aK as ToolboxWalkResult, aL as agent, aM as agentsPlugin, aN as buildModelSelection, aO as compileAgentDefinition, aP as compileAgentModule, aQ as compileContextWindow, aR as compileProjectContext, aS as compileSkills, aT as compileTools, aU as contextualTool, aV as createAgentExecutionContext, aW as createApiErrorHandler, aX as createSdkAgentStream, aY as createThinkTagExtractor, aZ as createToolHooksPlugin, a_ as delegate, a$ as delegateBackground, b0 as delegateWithScoring, b1 as extractThinkTagStream, b2 as generateAgentManifest, b3 as generateAgentRoutes, b4 as isAgentContext, b5 as isAgentDefinition, b6 as isApprovalRequired, b7 as isDone, b8 as isError, b9 as isPartialToolCall, ba as isTextDelta, bb as isToolCall, bc as isToolResult, bd as ladderReflectionStrategy, be as loopStrategyConfigSchema, bf as mcpRegistry, bg as mcpToolApprovals, bh as noopReflectionStrategy, bi as presentUIMessageStream, bj as projectContextMetadataOnlyKnobs, bk as reflectionStrategyConfigSchema, bl as resolveEnabledSkills, bm as resolveLoopStrategy, bn as resolveMcpServers, bo as runWithApiErrorHandling, bp as streamAgentResponse, bq as streamAgentUIMessages, br as toAgentFactory, bs as translateSdkEvent } from './bridge-entry-F9kHGaIn.js';
-import * as _theokit_sdk from '@theokit/sdk';
+import { G as Guardrail, L as LoopStrategy, R as ReflectionStrategy, C as CompiledAgentOptions, M as MainLoopMeta, a as CompiledTool, b as ReasoningEffort, c as RoundStreamFactory, S as StreamEvent, D as DelegationResult, d as ContextWindowOptions, e as SkillsOptions, T as ToolOptions, A as ApprovalOptions, H as HumanInTheLoopOptions, f as AgentManifestEntry } from './bridge-entry-Ddu3Ug_3.js';
+export { g as AGENT_BRAND, h as AfterToolCallContext, i as AgentBuilder, j as AgentDefinition, k as AgentDefinitionError, l as AgentExecutionContext, m as AgentManifest, n as AgentManifestSource, o as AgentManifestTool, p as AgentOptions, q as AgentRoute, r as AgentRouteContext, s as AgentRunInfo, t as AgentStreamEvent, u as AgentTurnMetadata, v as AgentsPluginOptions, w as ApiErrorContext, x as ApiErrorDecision, y as ApiErrorPolicy, z as ApprovalRequiredEvent, B as ArtifactChunkEvent, E as ArtifactStartEvent, F as BackgroundDelegation, I as BeforeToolCallContext, J as BudgetExceededError, K as BudgetOptions, N as CheckpointSavedEvent, O as CompiledContextWindow, P as ContextualTool, Q as CostBudgetExceededError, U as DEFAULT_MAX_ITERATIONS, V as DefineAgentConfig, W as DelegateFn, X as DelegateOptions, Y as DelegationError, Z as DoneEvent, _ as ErrorEvent, $ as FileEditEvent, a0 as GuardrailAction, a1 as GuardrailPhase, a2 as GuardrailResult, a3 as GuardrailViolationError, a4 as HitlDecision, a5 as InferAgentInput, a6 as InferAgentToolNames, a7 as IterationEvent, a8 as LLMCallContext, a9 as LoopFinishReason, aa as LoopOutcome, ab as LoopStrategyConfig, ac as MainLoopOptions, ad as McpApprovalSpec, ae as McpRegistryConfig, af as McpRequestContext, ag as McpSelection, ah as PartialToolCallEvent, ai as PolicyHandler, aj as ProcessInputContext, ak as ReflectionContext, al as ReflectionResult, am as ReflectionStrategyConfig, an as RunStartedEvent, ao as ScoreVerdict, ap as ScoredDelegation, aq as Scorer, ar as SdkAgentHandle, as as SdkMessage, at as Segment, au as SkillsRequestContext, av as SkillsSelection, aw as StateUpdateEvent, ax as TextDeltaEvent, ay as ThinkingEvent, az as TimeoutAction, aA as ToolCallEvent, aB as ToolCallVeto, aC as ToolHooks, aD as ToolHooksPlugin, aE as ToolResultEvent, aF as ToolWalkResult, aG as ToolboxOptions, aH as ToolboxWalkResult, aI as agentsPlugin, aJ as buildModelSelection, aK as compileAgentDefinition, aL as compileAgentModule, aM as compileContextWindow, aN as compileProjectContext, aO as compileSkills, aP as compileTools, aQ as createAgentExecutionContext, aR as createApiErrorHandler, aS as createSdkAgentStream, aT as createThinkTagExtractor, aU as createToolHooksPlugin, aV as delegate, aW as delegateBackground, aX as delegateWithScoring, aY as extractThinkTagStream, aZ as generateAgentManifest, a_ as generateAgentRoutes, a$ as isAgentContext, b0 as isAgentDefinition, b1 as isApprovalRequired, b2 as isDone, b3 as isError, b4 as isPartialToolCall, b5 as isTextDelta, b6 as isToolCall, b7 as isToolResult, b8 as ladderReflectionStrategy, b9 as loopStrategyConfigSchema, ba as mcpRegistry, bb as mcpToolApprovals, bc as noopReflectionStrategy, bd as presentUIMessageStream, be as projectContextMetadataOnlyKnobs, bf as reflectionStrategyConfigSchema, bg as resolveEnabledSkills, bh as resolveLoopStrategy, bi as resolveMcpServers, bj as runWithApiErrorHandling, bk as streamAgentResponse, bl as streamAgentUIMessages, bm as toAgentFactory, bn as translateSdkEvent } from './bridge-entry-Ddu3Ug_3.js';
 import { PluginsSettings, Plugin, ProviderRoutingSettings, AgentDefinition, BudgetTracker, CustomTool, InlineSkill } from '@theokit/sdk';
 import { RetryOptions } from '@theokit/sdk/retry';
 import { CompressibleMessage } from '@theokit/sdk/compaction';
@@ -294,6 +293,13 @@ interface AgentRunnerState {
     readonly agentName: string;
     /** The resolved terminal-decision strategy (parity with `delegate()`). */
     readonly loopStrategy: LoopStrategy;
+    /**
+     * M54 — true when `loopStrategy` came from `.loopStrategy(custom)` rather than a built-in name.
+     * A custom must NOT be re-resolved by name (its name is outside the `z.enum`); a per-run
+     * `maxIterations` override applies to it as a runner ceiling instead (see `stream`). Optional and
+     * defaults to `false`: a state built directly (tests, `delegate()`) is a by-name built-in.
+     */
+    readonly loopStrategyIsCustom?: boolean;
     /** The resolved between-round reflection (default or `.reflection(custom)` override). */
     readonly reflectionStrategy: ReflectionStrategy;
     /** Recorded streaming preference (see {@link AgentRunner.streamEnabled}). */
@@ -306,6 +312,8 @@ declare class AgentRunner {
     private readonly agentName;
     /** The resolved terminal-decision strategy (parity with `delegate()`). */
     readonly loopStrategy: LoopStrategy;
+    /** M54 — whether {@link loopStrategy} is a caller-injected custom (see {@link AgentRunnerState}). */
+    private readonly loopStrategyIsCustom;
     /** The resolved between-round reflection (default or `.reflection(custom)` override). */
     readonly reflectionStrategy: ReflectionStrategy;
     /**
@@ -336,6 +344,14 @@ declare class AgentRunner {
     /** The core stream path, after input guardrails have run (M9). */
     private streamUnguarded;
     /** Run the agent to a terminal result via the shared reflective loop (collect mode). */
+    /**
+     * Apply a per-call `maxIterations` override (M54 D4). A custom strategy must NOT be re-resolved by
+     * name — its name is outside the `z.enum`, which would throw — and its `shouldContinue` closure
+     * must survive; since the runner enforces the ceiling via `round < loop.maxIterations` (T1.1),
+     * overriding just that field bounds a custom without touching its logic. A built-in keeps the
+     * by-name re-resolution (zod fail-loud on `< 1`) — unchanged, zero-behavior.
+     */
+    private resolvePerRunLoop;
     run(message: string, opts: AgentRunnerRunOptions): Promise<DelegationResult>;
 }
 /**
@@ -364,9 +380,29 @@ declare class AgentRunnerBuilder {
     private reflectionOverride?;
     private streamEnabled;
     private compactionOverride?;
+    private loopStrategyOverride?;
     constructor(spec: AgentRunnerSpec);
     /** Override the default reflection strategy (OCP — plan Drawback #2). No arg ⇒ keep default. */
     reflection(strategy?: ReflectionStrategy): this;
+    /**
+     * M54 — inject a custom terminal-decision strategy (the fourth OCP axis, alongside
+     * `.reflection()`/`.compaction()`/`streamFactory`). WINS over the strategy the spec's name would
+     * resolve to, exactly as `.compaction()` outranks the spec. The runner caps ANY strategy at
+     * `custom.maxIterations` (T1.1), so a `shouldContinue: () => true` still terminates — never an
+     * infinite loop.
+     *
+     * @example
+     * ```ts
+     * // Stop as soon as the confidence in the last round crosses 0.9, else run to the ceiling.
+     * const stopWhenConfident: LoopStrategy = {
+     *   name: 'confident',
+     *   maxIterations: 8,
+     *   shouldContinue: (o) => !o.responseText.includes('confidence: high'),
+     * }
+     * AgentRunner.fromSpec(spec).loopStrategy(stopWhenConfident).build()
+     * ```
+     */
+    loopStrategy(custom: LoopStrategy): this;
     /** Record the streaming preference (see {@link AgentRunner.streamEnabled}). */
     stream(enabled?: boolean): this;
     /**
@@ -461,10 +497,16 @@ declare class ToolsCapability implements Capability {
     apply(draft: CompiledAgentOptionsDraft): void;
 }
 /**
- * Enables skills by name. FUNCTION, not class: it carries no behavior beyond assignment — a class here
- * would be ceremony (the honest counter-example to "everything must be a class").
+ * Enables skills by name (or inline). M57: a CLASS now (was a factory function). Validation moves to
+ * the constructor — fail-fast at authoring, the same place `ModelCapability`/`AgentConfigCapability`
+ * validate. The `apply` body (delegate + merge) is unchanged, so the compiled output is identical.
  */
-declare const skills: (entries: readonly (string | InlineSkill)[]) => Capability;
+declare class SkillsCapability implements Capability {
+    #private;
+    readonly name = "skills";
+    constructor(entries: readonly (string | InlineSkill)[]);
+    apply(draft: CompiledAgentOptionsDraft): void;
+}
 
 /**
  * M52 — resolution + composition. The registry is what unlocks FILE-BASED authoring (a config lists
@@ -494,51 +536,122 @@ declare class CapabilityPreset implements Capability {
     apply(draft: CompiledAgentOptionsDraft): void;
 }
 
+/**
+ * M53 — the capabilities that replace the waist-bound agent decorators, one per field the decorator
+ * pipeline produces today (`docs/agents/decorator-to-capability.md` § A).
+ *
+ * M57 reverses ADR 0001 § 4 (which kept the pure-assignment ones as a factory function to avoid
+ * "13 near-identical classes"): the authoring surface is now 100% classes, aligned with the SDK's
+ * `X.create()`/class shape. The `FieldCapability` base keeps the assignment ones DRY (one line each);
+ * the behaviour-carrying ones are written out. Rationale in ADR 0005.
+ */
+/**
+ * Base for a capability whose only job is to assign one waist field — no validation, no merge, no
+ * precedence. M57: this replaces the `fieldCapability(name, field)` factory function with a class, so
+ * the authoring surface is 100% classes (aligned with the SDK's `X.create()` and the existing
+ * `ModelCapability`). The subclasses below are one line each; the shared `apply` lives here (DRY).
+ * NOT the Template-Method the ADR-0001 refused — that was inheritance of variable *behaviour*
+ * (`shouldContinue`); here the base carries *data* (name/field) and `apply` is identical for all.
+ */
+declare abstract class FieldCapability<K extends keyof CompiledAgentOptionsDraft> implements Capability {
+    private readonly value;
+    abstract readonly name: string;
+    protected abstract readonly field: K;
+    constructor(value: NonNullable<CompiledAgentOptionsDraft[K]>);
+    apply(draft: CompiledAgentOptionsDraft): void;
+}
 /** `@Memory` → `memory`. */
-declare const memory: (value: NonNullable<MemoryOptions | _theokit_sdk.MemorySettings | undefined>) => Capability;
+declare class MemoryCapability extends FieldCapability<'memory'> {
+    readonly name = "memory";
+    protected readonly field: "memory";
+}
 /**
  * `@ContextWindow` → `context`. DELEGATES to `compileContextWindow`, which is the canonical
  * `ContextWindowOptions → ContextSettings` conversion (it also reports the metadata-only knobs).
  * Taking a pre-converted value here would duplicate that knowledge — the exact divergence the M52
  * zero-behavior proof caught in `skills`.
  */
-declare const contextWindow: (options: ContextWindowOptions) => Capability;
+declare class ContextWindowCapability implements Capability {
+    private readonly options;
+    readonly name = "context-window";
+    constructor(options: ContextWindowOptions);
+    apply(draft: CompiledAgentOptionsDraft): void;
+}
 /** `@ProjectContext` → `projectContext`. */
-declare const projectContext: (value: ProjectContextOptions) => Capability;
+declare class ProjectContextCapability extends FieldCapability<'projectContext'> {
+    readonly name = "project-context";
+    protected readonly field: "projectContext";
+}
 /** `@MCP` → `mcpServers`. */
-declare const mcpServers: (value: McpServersMap) => Capability;
+declare class McpServersCapability extends FieldCapability<'mcpServers'> {
+    readonly name = "mcp";
+    protected readonly field: "mcpServers";
+}
 /** `@Guardrails` → `guardrails`. */
-declare const guardrails: (value: readonly Guardrail[]) => Capability;
+declare class GuardrailsCapability extends FieldCapability<'guardrails'> {
+    readonly name = "guardrails";
+    protected readonly field: "guardrails";
+}
 /**
  * `@Checkpoint` → `checkpoint`. Carries the non-durable WARNING the metadata walk used to emit: only
  * `'filesystem'` selects the SDK's durable store, so any other storage cannot resume across
  * requests. The warning moves WITH the feature — a declared checkpoint that silently cannot resume
  * is exactly the kind of no-op this project refuses to ship.
  */
-declare const checkpoint: (options: CompiledAgentOptions["checkpoint"]) => Capability;
+declare class CheckpointCapability implements Capability {
+    private readonly options;
+    readonly name = "checkpoint";
+    constructor(options: CompiledAgentOptions['checkpoint']);
+    apply(draft: CompiledAgentOptionsDraft): void;
+}
 /**
  * `@HumanInTheLoop` → `hitl`, keyed `"<namespace>_<tool>"` — the same key `compileHitlGates` mints
  * via `toolRuntimeName`. The separator is `_`, not `.`: the dot is outside the charset the SDK
  * accepts, and a gate keyed with a dot silently failed to match its tool (theokit#145).
  */
-declare const humanInTheLoop: (value: Map<string, HumanInTheLoopOptions>) => Capability;
+declare class HumanInTheLoopCapability extends FieldCapability<'hitl'> {
+    readonly name = "human-in-the-loop";
+    protected readonly field: "hitl";
+}
 /**
  * `@SubAgents` → `agents`. MERGES instead of `setOnce`: `agents` is a pre-seeded collection on the
  * draft (`createDraft` gives it `{}`), so a `setOnce` would conflict against the seed itself — the
  * same trap the pre-seeded `stream` sprang in M52. Merging also lets a preset declare a baseline
  * child set that a call site extends.
  */
-declare const subAgents: (children: CompiledAgentOptions["agents"]) => Capability;
+declare class SubAgentsCapability implements Capability {
+    private readonly children;
+    readonly name = "sub-agents";
+    constructor(children: CompiledAgentOptions['agents']);
+    apply(draft: CompiledAgentOptionsDraft): void;
+}
 /**
  * `@Skills({ include, autoDiscover })` → `skills`. Delegates to `compileSkills` (same reason as
  * `contextWindow`). Distinct from the M52 `skills([...])`, which takes the plain name/inline list.
  */
-declare const skillsOptions: (options: SkillsOptions) => Capability;
+declare class SkillsOptionsCapability implements Capability {
+    private readonly options;
+    readonly name = "skills";
+    constructor(options: SkillsOptions);
+    apply(draft: CompiledAgentOptionsDraft): void;
+}
 /** Functional-path fields that had no decorator source — closing the gap list, not adding surface. */
-declare const settingSources: (value: readonly _theokit_sdk.SettingSource[]) => Capability;
-declare const plugins: (value: readonly unknown[]) => Capability;
-declare const runContext: (value: Record<string, unknown>) => Capability;
-declare const skillsResolver: (value: NonNullable<SkillsSelection | undefined>) => Capability;
+declare class SettingSourcesCapability extends FieldCapability<'settingSources'> {
+    readonly name = "setting-sources";
+    protected readonly field: "settingSources";
+}
+declare class PluginsCapability extends FieldCapability<'plugins'> {
+    readonly name = "plugins";
+    protected readonly field: "plugins";
+}
+declare class RunContextCapability extends FieldCapability<'runContext'> {
+    readonly name = "run-context";
+    protected readonly field: "runContext";
+}
+declare class SkillsResolverCapability extends FieldCapability<'skillsResolver'> {
+    readonly name = "skills-resolver";
+    protected readonly field: "skillsResolver";
+}
 /** The scalar agent config (name/route are HTTP concerns, never agent config). */
 interface AgentConfig {
     readonly systemPrompt?: CompiledAgentOptions['systemPrompt'];
@@ -835,4 +948,4 @@ declare class AcpClient {
     private handleServerRequest;
 }
 
-export { type A2AAuth, type A2ACapabilities, type A2ASkill, type A2AToolConfig, AcpClient, AcpMessageDecoder, type AcpTransport, type AgentCard, type AgentConfig, AgentConfigCapability, AgentManifestEntry, AgentRunner, AgentRunnerBuilder, type AgentRunnerRunOptions, ApprovalOptions, type BuildAgentCardOptions, type Capability, CapabilityConflictError, CapabilityPreset, CapabilityRegistry, type CompactionCallOptions, type CompactionStrategyConfig, CompiledAgentOptions, type CompiledAgentOptionsDraft, CompiledTool, ConfigurationError, type CostGuardOptions, DEFAULT_KEEP_TOKENS, DelegationResult, type FinalizedDraft, Guardrail, HumanInTheLoopOptions, LoopStrategy, MCP_PROTOCOL_VERSION, MainLoopCapability, MainLoopMeta, type McpJsonSchema, type McpServerInfo, type McpToolDescriptor, ModelCapability, type OutputModerationOptions, type PiiOptions, type PromptInjectionOptions, type ProvenanceEntry, ReasoningEffort, ReflectionStrategy, RoundStreamFactory, SkillsSelection, StreamEvent, type Summarize, type ToolDeclaration, ToolOptions, ToolboxCapability, type ToolboxSource, ToolsCapability, type TranscriptCompactionStrategy, UnknownCapabilityError, applyCapabilities, buildAgentCard, buildMcpToolDescriptors, checkpoint, compactionStrategyConfigSchema, contextWindow, costGuard, createA2ATool, createDraft, deriveConversationId, encodeAcpMessage, estimateTokens, guardrails, humanInTheLoop, mcpServerInfo, mcpServers, memory, moderateOutputStream, outputModeration, parseConversationId, piiDetector, plugins, projectContext, promptInjectionDetector, resolveCompactionStrategy, runContext, runInputGuards, runOutputGuards, setOnce, settingSources, skills, skillsOptions, skillsResolver, subAgents, tokenBudgetCompactionStrategy, unicodeNormalizer, wellKnownCardPath };
+export { type A2AAuth, type A2ACapabilities, type A2ASkill, type A2AToolConfig, AcpClient, AcpMessageDecoder, type AcpTransport, type AgentCard, type AgentConfig, AgentConfigCapability, AgentManifestEntry, AgentRunner, AgentRunnerBuilder, type AgentRunnerRunOptions, ApprovalOptions, type BuildAgentCardOptions, type Capability, CapabilityConflictError, CapabilityPreset, CapabilityRegistry, CheckpointCapability, type CompactionCallOptions, type CompactionStrategyConfig, CompiledAgentOptions, type CompiledAgentOptionsDraft, CompiledTool, ConfigurationError, ContextWindowCapability, type CostGuardOptions, DEFAULT_KEEP_TOKENS, DelegationResult, FieldCapability, type FinalizedDraft, Guardrail, GuardrailsCapability, HumanInTheLoopCapability, HumanInTheLoopOptions, LoopStrategy, MCP_PROTOCOL_VERSION, MainLoopCapability, MainLoopMeta, type McpJsonSchema, type McpServerInfo, McpServersCapability, type McpToolDescriptor, MemoryCapability, ModelCapability, type OutputModerationOptions, type PiiOptions, PluginsCapability, ProjectContextCapability, type PromptInjectionOptions, type ProvenanceEntry, ReasoningEffort, ReflectionStrategy, RoundStreamFactory, RunContextCapability, SettingSourcesCapability, SkillsCapability, SkillsOptionsCapability, SkillsResolverCapability, StreamEvent, SubAgentsCapability, type Summarize, type ToolDeclaration, ToolOptions, ToolboxCapability, type ToolboxSource, ToolsCapability, type TranscriptCompactionStrategy, UnknownCapabilityError, applyCapabilities, buildAgentCard, buildMcpToolDescriptors, compactionStrategyConfigSchema, costGuard, createA2ATool, createDraft, deriveConversationId, encodeAcpMessage, estimateTokens, mcpServerInfo, moderateOutputStream, outputModeration, parseConversationId, piiDetector, promptInjectionDetector, resolveCompactionStrategy, runInputGuards, runOutputGuards, setOnce, tokenBudgetCompactionStrategy, unicodeNormalizer, wellKnownCardPath };