@theokit/agents 0.30.1 → 0.31.0

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 export { Agent, Artifact, ArtifactOptions, ArtifactResult, Audit, Budget, CommandPermissions, CompactionStrategy, Conversation, ConversationOptions, ConversationStorage, EditFormat, EditFormatType, FilesystemPermissions, Hook, HookEntry, HookPoint, MainLoop, Mixin, Model, Observable, ObservableEntry, Policy, RequiresApproval, RequiresCapability, Sandbox, SandboxOptions, SubAgents, Tool, Toolbox, Trace, applyDecorators, getAgentConfig, getArtifactConfig, getConversationConfig, getHooks, getHooksByPoint, getMainLoop, getMixins, getObservableByChannel, getObservables, getSandboxConfig, getSubAgents, getToolConfig, getToolMethods, getToolboxConfig, isCommandAllowed, isPathAllowed } from './decorators.js';
 import { R as ReasoningEffort } from './skills-Dx_KJ6Eg.js';
 export { A as AgentOptions, a as ApprovalOptions, B as BudgetOptions, C as Checkpoint, b as CheckpointOptions, c as CheckpointState, d as CheckpointStorage, e as CheckpointStrategy, f as Compaction, g as CompactionDecoratorConfig, h as ContextCompactionStrategy, i as ContextWindow, j as ContextWindowOptions, G as Gateway, k as GatewayOptions, H as HumanInTheLoop, l as HumanInTheLoopOptions, I as IndexStrategy, M as MCP, m as MainLoopMeta, n as MainLoopOptions, o as McpServerConfig, p as McpServersMap, q as Memory, r as MemoryOptions, s as MemoryProvider, t as MemoryScope, P as PlatformName, u as PolicyHandler, v as ProjectContext, w as ProjectContextOptions, x as RelevanceStrategy, S as SessionStrategy, y as Skills, z as SkillsOptions, T as TimeoutAction, D as ToolOptions, E as ToolboxOptions, F as getCheckpointConfig, J as getCompactionConfig, K as getContextWindowConfig, L as getGatewayConfig, N as getHumanInTheLoopConfig, O as getMcpConfig, Q as getMemoryConfig, U as getProjectContextConfig, V as getSkillsConfig, W as resolveSessionId } from './skills-Dx_KJ6Eg.js';
-import { S as StreamEvent, L as LoopStrategy, R as ReflectionStrategy, C as CompiledAgentOptions, a as CompiledTool, D as DelegationResult } from './bridge-entry-DVhOQc_f.js';
-export { A as AGENT_BRAND, b as AgentDefinition, c as AgentDefinitionError, d as AgentExecutionContext, e as AgentManifest, f as AgentManifestEntry, g as AgentManifestTool, h as AgentRoute, i as AgentRouteContext, j as AgentRunInfo, k as AgentStreamEvent, l as AgentWalkResult, m as AgentWarningCode, n as AgentsPluginOptions, o as ApprovalRequiredEvent, p as ArtifactChunkEvent, q as ArtifactStartEvent, B as BudgetExceededError, r as CheckpointSavedEvent, s as CompiledContextWindow, t as DEFAULT_MAX_ITERATIONS, u as DefineAgentConfig, v as DelegateOptions, w as DelegationError, x as DoneEvent, E as ErrorEvent, F as FileEditEvent, I as InferAgentInput, y as IterationEvent, z as LoopFinishReason, G as LoopOutcome, H as LoopStrategyConfig, P as PartialToolCallEvent, J as ReflectionContext, K as ReflectionResult, M as ReflectionStrategyConfig, N as RunStartedEvent, O as SdkMessage, Q as Segment, T as StateUpdateEvent, U as TextDeltaEvent, V as ThinkingEvent, W as ToolCallEvent, X as ToolResultEvent, Y as ToolWalkResult, Z as ToolboxWalkResult, _ as agentsPlugin, $ as buildModelSelection, a0 as compileAgent, a1 as compileAgentDefinition, a2 as compileAgentModule, a3 as compileContextWindow, a4 as compileProjectContext, a5 as compileSkills, a6 as compileTools, a7 as createAgentExecutionContext, a8 as createSdkAgentStream, a9 as createThinkTagExtractor, aa as defineAgent, ab as delegate, ac as extractThinkTagStream, ad as generateAgentManifest, ae as generateAgentRoutes, af as isAgentContext, ag as isAgentDefinition, ah as isApprovalRequired, ai as isDone, aj as isError, ak as isPartialToolCall, al as isTextDelta, am as isToolCall, an as isToolResult, ao as ladderReflectionStrategy, ap as loopStrategyConfigSchema, aq as noopReflectionStrategy, ar as projectContextMetadataOnlyKnobs, as as reflectionStrategyConfigSchema, at as resolveLoopStrategy, au as streamAgentResponse, av as streamAgentUIMessages, aw as translateSdkEvent, ax as translateToUIMessageStream, ay as validateUniqueRoutes, az as walkAgentMetadata } from './bridge-entry-DVhOQc_f.js';
+import { G as Guardrail, L as LoopStrategy, R as ReflectionStrategy, C as CompiledAgentOptions, a as CompiledTool, b as RoundStreamFactory, S as StreamEvent, D as DelegationResult, A as AgentManifestEntry } from './bridge-entry-DtDotZGW.js';
+export { c as AGENT_BRAND, d as AfterToolCallContext, e as AgentBuilder, f as AgentDefinition, g as AgentDefinitionError, h as AgentExecutionContext, i as AgentManifest, j as AgentManifestTool, k as AgentRoute, l as AgentRouteContext, m as AgentRunInfo, n as AgentStreamEvent, o as AgentWalkResult, p as AgentWarningCode, q as AgentsPluginOptions, r as ApprovalRequiredEvent, s as ArtifactChunkEvent, t as ArtifactStartEvent, B as BeforeToolCallContext, u as BudgetExceededError, v as CheckpointSavedEvent, w as CompiledContextWindow, x as ContextualTool, y as CostBudgetExceededError, z as DEFAULT_MAX_ITERATIONS, E as DefineAgentConfig, F as DelegateOptions, H as DelegationError, I as DoneEvent, J as ErrorEvent, K as FileEditEvent, M as GuardrailAction, N as GuardrailPhase, O as GuardrailResult, P as GuardrailViolationError, Q as InferAgentInput, T as InferAgentToolNames, U as IterationEvent, V as LLMCallContext, W as LoopFinishReason, X as LoopOutcome, Y as LoopStrategyConfig, Z as PartialToolCallEvent, _ as ReflectionContext, $ as ReflectionResult, a0 as ReflectionStrategyConfig, a1 as RunStartedEvent, a2 as SdkMessage, a3 as Segment, a4 as SkillsRequestContext, a5 as SkillsSelection, a6 as StateUpdateEvent, a7 as TextDeltaEvent, a8 as ThinkingEvent, a9 as ToolCallEvent, aa as ToolCallVeto, ab as ToolHooks, ac as ToolHooksPlugin, ad as ToolResultEvent, ae as ToolWalkResult, af as ToolboxWalkResult, ag as agent, ah as agentsPlugin, ai as buildModelSelection, aj as compileAgent, ak as compileAgentDefinition, al as compileAgentModule, am as compileContextWindow, an as compileProjectContext, ao as compileSkills, ap as compileTools, aq as contextualTool, ar as createAgentExecutionContext, as as createSdkAgentStream, at as createThinkTagExtractor, au as createToolHooksPlugin, av as defineAgent, aw as delegate, ax as extractThinkTagStream, ay as generateAgentManifest, az as generateAgentRoutes, aA as isAgentContext, aB as isAgentDefinition, aC as isApprovalRequired, aD as isDone, aE as isError, aF as isPartialToolCall, aG as isTextDelta, aH as isToolCall, aI as isToolResult, aJ as ladderReflectionStrategy, aK as loopStrategyConfigSchema, aL as noopReflectionStrategy, aM as projectContextMetadataOnlyKnobs, aN as reflectionStrategyConfigSchema, aO as resolveEnabledSkills, aP as resolveLoopStrategy, aQ as streamAgentResponse, aR as streamAgentUIMessages, aS as translateSdkEvent, aT as translateToUIMessageStream, aU as validateUniqueRoutes, aV as walkAgentMetadata } from './bridge-entry-DtDotZGW.js';
 import { PluginsSettings, Plugin, ProviderRoutingSettings, AgentDefinition, BudgetTracker, ConversationStorageAdapter, CustomTool } from '@theokit/sdk';
 import { RetryOptions } from '@theokit/sdk/retry';
 import { CompressibleMessage } from '@theokit/sdk/compaction';
@@ -11,6 +11,80 @@ import { z } from 'zod';
 import '@theokit/http';
 import 'ai';
 
+/**
+ * M9 (theokit-ai-first) — built-in guardrail detectors.
+ *
+ * Each factory returns a {@link Guardrail}. None call an LLM (G2 / sdk-runtime.md):
+ * `outputModeration` takes an INJECTED predicate so the provider call (if any) lives in the
+ * consumer's code, never in `packages/`.
+ */
+
+/** Rough token estimate — ~4 chars/token (documented heuristic; exact counting is provider-specific). */
+declare function estimateTokens(text: string): number;
+interface PromptInjectionOptions {
+    /** Additional project-specific trigger phrases (compared lowercased, substring). */
+    extra?: readonly string[];
+}
+/** Blocks input containing a known injection trigger phrase. */
+declare function promptInjectionDetector(options?: PromptInjectionOptions): Guardrail;
+interface PiiOptions {
+    /** When true (default), matched PII is replaced with `[REDACTED]`. */
+    redact?: boolean;
+    /** Placeholder token. Default `[REDACTED]`. */
+    placeholder?: string;
+}
+/** Redacts CPF, email and phone numbers from input. */
+declare function piiDetector(options?: PiiOptions): Guardrail;
+/** NFKC-normalizes and strips zero-width / RTL-override characters. */
+declare function unicodeNormalizer(): Guardrail;
+interface CostGuardOptions {
+    /** Cumulative input-token budget per guard instance (per session — one guard per run). */
+    maxTokens: number;
+}
+/**
+ * Enforces a cumulative input-token budget. Stateful: one instance accumulates across the calls
+ * it sees within a run. Throws {@link CostBudgetExceededError} fail-fast when exceeded.
+ */
+declare function costGuard(options: CostGuardOptions): Guardrail;
+interface OutputModerationOptions {
+    /**
+     * Injected predicate — returns `true` when the text is prohibited. The provider call (OpenAI
+     * moderation API, a classifier, etc.) lives HERE, in consumer code — never inside `packages/`
+     * (G2). Keeps the module runtime-free.
+     */
+    moderate: (text: string) => boolean | Promise<boolean>;
+}
+/** Blocks model output the injected predicate flags as prohibited. */
+declare function outputModeration(options: OutputModerationOptions): Guardrail;
+
+/**
+ * M9 (theokit-ai-first) — the guardrail pipeline: apply guards in order at a boundary phase.
+ *
+ * Fail-fast (error-handling.md): a `block` throws {@link GuardrailViolationError} immediately.
+ * A `redact` threads the transformed text into the next guard. Independent of the SDK runtime —
+ * this runs at the framework boundary, before/after the SDK does its work.
+ */
+
+/**
+ * Run every guard's `checkInput` in order against `text`. Returns the (possibly redacted) text.
+ * Throws {@link GuardrailViolationError} on the first `block`. Guards without `checkInput` are skipped.
+ */
+declare function runInputGuards(text: string, guards: readonly Guardrail[]): Promise<string>;
+/**
+ * Run every guard's `checkOutput` in order against `text`. Returns the (possibly redacted) text.
+ * Throws {@link GuardrailViolationError} on the first `block`. Guards without `checkOutput` are skipped.
+ */
+declare function runOutputGuards(text: string, guards: readonly Guardrail[]): Promise<string>;
+
+/**
+ * Wrap `inner`, moderating its accumulated text output.
+ *
+ * @param inner       the source stream (yields events, returns a result).
+ * @param guards      the guardrails; only those with `checkOutput` participate.
+ * @param extractText pulls the human-visible text out of an event (return `undefined` for non-text).
+ */
+declare function moderateOutputStream<E, R>(inner: AsyncGenerator<E, R>, guards: readonly Guardrail[], extractText: (event: E) => string | undefined): AsyncGenerator<E, R>;
+
 /**
  * TranscriptCompactionStrategy — a named, callable transcript-compaction authoring layer
  * (Strategy pattern, V4-F). Mirrors `ReflectionStrategy`/`LoopStrategy`: interface
@@ -94,34 +168,6 @@ declare function resolveCompactionStrategy(name: string, config: {
  */
 declare const tokenBudgetCompactionStrategy: TranscriptCompactionStrategy;
 
-/**
- * runReflectiveLoop — the multi-round reflective driver that gives `@MainLoop`
- * its runtime (closes the metadata-only gap, V4-A / plan ADR D2).
- *
- * Per round it consumes ONE SDK stream turn (the model call stays in the SDK —
- * the factory is `createSdkAgentStream(...)`, injected for testability), derives
- * a {@link LoopOutcome}, asks the {@link ReflectionStrategy} for feedback, then
- * the {@link LoopStrategy} whether to continue. Bounded by `maxIterations`
- * (forced terminal at the ceiling — never an infinite loop). The bridge owns the
- * loop; the SDK owns the model call (sdk-runtime.md / ADR 0031 — no second runtime).
- *
- * `runReflectiveLoop` is INTERNAL (not re-exported from the package barrel,
- * Drawback #4) — consumed by `delegate()` (T2.2) and `AgentRunner` (T3.1).
- *
- * referencia: knowledge-base/references/mastra agent.ts (re-enter the loop with feedback).
- */
-
-/** One SDK stream turn: `createSdkAgentStream(...)` returns this shape. */
-/**
- * Opens one round's SDK stream. `opts.disableTools` (step-cap force-close) asks the factory to
- * gate tools OFF for THIS round (the SDK adapter maps it to `tool_choice:"none"` at send-time, so a
- * cached agent — whose tools can't be un-registered — is still forced to a text summary). Optional +
- * ignored by injected test factories ⇒ backward-compatible.
- */
-type RoundStreamFactory = (message: string, sessionId: string, opts?: {
-    disableTools?: boolean;
-}) => AsyncIterable<StreamEvent>;
-
 /**
  * AgentRunner — the imperative twin of `@MainLoop` (plan ADR D4, V4-B).
  *
@@ -291,6 +337,8 @@ declare class AgentRunner {
      * builder set `.stream(false)`, callers should use {@link run} instead.
      */
     stream(message: string, opts: AgentRunnerRunOptions): AsyncGenerator<StreamEvent, DelegationResult>;
+    /** 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). */
     run(message: string, opts: AgentRunnerRunOptions): Promise<DelegationResult>;
 }
@@ -317,4 +365,195 @@ declare class AgentRunnerBuilder {
     build(): AgentRunner;
 }
 
-export { AgentRunner, AgentRunnerBuilder, type AgentRunnerRunOptions, type CompactionCallOptions, type CompactionStrategyConfig, CompiledAgentOptions, CompiledTool, DEFAULT_KEEP_TOKENS, DelegationResult, LoopStrategy, ReasoningEffort, ReflectionStrategy, type RoundStreamFactory, StreamEvent, type Summarize, type TranscriptCompactionStrategy, compactionStrategyConfigSchema, resolveCompactionStrategy, tokenBudgetCompactionStrategy };
+/**
+ * M15 (theokit-ai-first) — A2A agent card generation (ADR-0040 § D2, home/discovery concern).
+ *
+ * Produces an [A2A](https://github.com/google/A2A)-spec Agent Card from the framework's
+ * `AgentManifestEntry`, so other systems can discover a TheoKit agent's capabilities over HTTP at
+ * `/.well-known/<name>/agent-card.json`. Pure data transform — no LLM, no runtime (G2).
+ */
+
+/** A single capability exposed by an A2A agent (maps from a TheoKit tool). */
+interface A2ASkill {
+    id: string;
+    name: string;
+    description: string;
+}
+/** A2A agent-card capabilities block. */
+interface A2ACapabilities {
+    streaming: boolean;
+    pushNotifications: boolean;
+    stateTransitionHistory: boolean;
+}
+/** An A2A-spec Agent Card (the subset TheoKit advertises). */
+interface AgentCard {
+    name: string;
+    description: string;
+    url: string;
+    version: string;
+    capabilities: A2ACapabilities;
+    defaultInputModes: string[];
+    defaultOutputModes: string[];
+    skills: A2ASkill[];
+}
+interface BuildAgentCardOptions {
+    /** Absolute base URL of the deployment (e.g. `https://app.example.com`). A trailing slash is trimmed. */
+    baseUrl: string;
+    /** Human description of the agent. Defaults to a generated sentence when omitted (spec requires non-empty). */
+    description?: string;
+}
+/** Build an A2A agent card from a manifest entry. */
+declare function buildAgentCard(entry: AgentManifestEntry, options: BuildAgentCardOptions): AgentCard;
+/** The A2A discovery path for an agent: `/.well-known/<name>/agent-card.json`. */
+declare function wellKnownCardPath(agentName: string): string;
+
+/**
+ * M16 (theokit-ai-first) — MCP server manifest generation (ADR-0040 § D2, home concern).
+ *
+ * Exposes a TheoKit agent's tools to external MCP clients as `tools/list` descriptors, so the app
+ * can advertise its agents over its OWN HTTP routes. Pure data transform — no LLM, no runtime, and
+ * NO stdio transport (that stays SDK-side per sdk-runtime.md). Serving these over `GET /mcp` and the
+ * JSON-RPC envelope are follow-ups (mount path).
+ */
+
+/** The MCP protocol revision these descriptors target. */
+declare const MCP_PROTOCOL_VERSION = "2024-11-05";
+/** A JSON-schema object (the shape MCP expects for a tool's `inputSchema`). */
+interface McpJsonSchema {
+    type: 'object';
+    properties: Record<string, unknown>;
+    required?: string[];
+}
+/** An MCP `tools/list` tool descriptor. */
+interface McpToolDescriptor {
+    name: string;
+    description: string;
+    inputSchema: McpJsonSchema;
+}
+/** MCP `initialize` server info. */
+interface McpServerInfo {
+    name: string;
+    version: string;
+    protocolVersion: string;
+}
+/**
+ * Map an agent's tools to MCP tool descriptors. The manifest tool carries name + description; the
+ * per-tool JSON schema is not retained in the manifest, so a permissive empty-object schema is
+ * emitted (MCP clients accept it and pass through arbitrary args). Wiring the real per-tool schema
+ * is a follow-up once the manifest carries it.
+ */
+declare function buildMcpToolDescriptors(entry: AgentManifestEntry): McpToolDescriptor[];
+/** Build the MCP `initialize` server-info block for an agent. */
+declare function mcpServerInfo(entry: AgentManifestEntry): McpServerInfo;
+
+/**
+ * M15 (theokit-ai-first) — A2A client: call a remote A2A agent as a tool (ADR-0040 § D2).
+ *
+ * `createA2ATool` returns a `CustomTool` whose handler POSTs the input message to a remote agent's
+ * HTTP endpoint and returns its text response — cross-network delegation. Uses `fetch` (Web
+ * Standards, G8). The target is a remote AGENT endpoint, not an LLM provider, so the G2 grep guard
+ * (`openrouter.ai|api.openai.com|api.anthropic.com`) is unaffected. `fetchImpl` is injectable for tests.
+ */
+
+/** How to authenticate to the remote agent. */
+interface A2AAuth {
+    /** Bearer token → `Authorization: Bearer <token>`. */
+    bearer?: string;
+    /** API-key header pair → `<name>: <value>` (e.g. `x-api-key`). */
+    apiKey?: {
+        header: string;
+        value: string;
+    };
+}
+interface A2AToolConfig {
+    /** Remote agent endpoint URL (POST target). */
+    url: string;
+    /** Tool name the model calls. */
+    name: string;
+    /** Tool description surfaced to the model. */
+    description: string;
+    /** Static headers merged into every request. */
+    headers?: Record<string, string>;
+    /** Auth applied to every request. */
+    auth?: A2AAuth;
+    /** Injected fetch (defaults to the global). Narrowed to the call shape this client uses. */
+    fetchImpl?: (url: string, init: RequestInit) => Promise<Response>;
+}
+/**
+ * Create a tool that delegates to a remote A2A agent. The remote is expected to answer a
+ * `{ message }` POST with a JSON body carrying a `response` (or `text`) string.
+ */
+declare function createA2ATool(config: A2AToolConfig): CustomTool;
+
+/**
+ * M11 (theokit-ai-first) — {resource, thread} conversation scoping (ADR-0040 § D2, home concern).
+ *
+ * Maps a request's (resource, thread) pair to a deterministic, collision-safe conversation id so
+ * multi-tenant apps isolate history without hand-building `user-${id}-thread-${id}` strings. This
+ * is the app's request→conversation mapping — NOT the SDK's storage engine (which the derived id is
+ * simply handed to). Background compression of long histories stays SDK-side.
+ *
+ * Encoding: each component is `encodeURIComponent`-escaped and joined with `/`. Since
+ * `encodeURIComponent` escapes a raw `/` to `%2F`, the separator is unambiguous — `('a/b','c')` and
+ * `('a','b/c')` derive DIFFERENT ids (collision-safe). Reversible via {@link parseConversationId}.
+ */
+/** Derive a deterministic conversation id from a (resource, thread) pair. Fails fast on empty input. */
+declare function deriveConversationId(resource: string, thread: string): string;
+/**
+ * Reverse a derived conversation id back to its (resource, thread). Returns `null` for a value that
+ * is not a derived scope id (no separator, or an empty component) — callers treat that as "opaque id,
+ * not scoped".
+ */
+declare function parseConversationId(id: string): {
+    resource: string;
+    thread: string;
+} | null;
+
+/**
+ * M17 (theokit-ai-first) — ACP (Agent Client Protocol) stdio framing.
+ *
+ * ACP talks to a coding agent (Claude Code, Amp, Codex) over stdio as newline-delimited JSON. This
+ * is the transport-agnostic CORE: encode a message to a line, and decode a byte/char stream that may
+ * split a message across chunks. Pure — no subprocess, no Node API. The subprocess spawn lives in the
+ * adapter layer (G8) / SDK; `createACPTool` (wrapping this codec + an injected transport) is a
+ * follow-up once the adapter ships.
+ */
+/** Serialize a message to a single newline-terminated JSON line. */
+declare function encodeAcpMessage(message: unknown): string;
+/**
+ * Incremental decoder for newline-delimited JSON. Feed it chunks with {@link push}; it buffers a
+ * partial trailing line across calls and returns every WHOLE message parsed so far. Blank lines are
+ * skipped. A completed non-JSON line fails fast with a typed error (error-handling.md) — a corrupt
+ * frame must never be silently dropped.
+ */
+declare class AcpMessageDecoder {
+    private buffer;
+    /** Feed a chunk; returns the messages completed by this chunk (possibly empty). */
+    push(chunk: string): unknown[];
+}
+
+/** The stdio channel to the coding-agent subprocess (abstracted for testability + G8). */
+interface AcpTransport {
+    /** Write one already-encoded (newline-terminated) line to the agent's stdin. */
+    send(line: string): void;
+    /** Subscribe to raw lines/chunks from the agent's stdout. */
+    subscribe(onData: (chunk: string) => void): void;
+}
+/** Return a value or a Promise — `unknown` already includes `Promise<unknown>`; `await` handles both. */
+type ServerRequestHandler = (params: unknown) => unknown;
+declare class AcpClient {
+    private readonly transport;
+    private nextId;
+    private readonly pending;
+    private readonly handlers;
+    private readonly decoder;
+    constructor(transport: AcpTransport);
+    /** Send a JSON-RPC request and resolve with its `result` (or reject on `error`). */
+    request(method: string, params: unknown): Promise<unknown>;
+    /** Register a handler for a server→client request method (e.g. `session/request_permission`). */
+    onRequest(method: string, handler: ServerRequestHandler): void;
+    private dispatch;
+    private handleServerRequest;
+}
+
+export { type A2AAuth, type A2ACapabilities, type A2ASkill, type A2AToolConfig, AcpClient, AcpMessageDecoder, type AcpTransport, type AgentCard, AgentManifestEntry, AgentRunner, AgentRunnerBuilder, type AgentRunnerRunOptions, type BuildAgentCardOptions, type CompactionCallOptions, type CompactionStrategyConfig, CompiledAgentOptions, CompiledTool, type CostGuardOptions, DEFAULT_KEEP_TOKENS, DelegationResult, Guardrail, LoopStrategy, MCP_PROTOCOL_VERSION, type McpJsonSchema, type McpServerInfo, type McpToolDescriptor, type OutputModerationOptions, type PiiOptions, type PromptInjectionOptions, ReasoningEffort, ReflectionStrategy, RoundStreamFactory, StreamEvent, type Summarize, type TranscriptCompactionStrategy, buildAgentCard, buildMcpToolDescriptors, compactionStrategyConfigSchema, costGuard, createA2ATool, deriveConversationId, encodeAcpMessage, estimateTokens, mcpServerInfo, moderateOutputStream, outputModeration, parseConversationId, piiDetector, promptInjectionDetector, resolveCompactionStrategy, runInputGuards, runOutputGuards, tokenBudgetCompactionStrategy, unicodeNormalizer, wellKnownCardPath };