@theokit/agents 0.7.0 → 0.9.0

package/dist/index.d.ts

@@ -1,11 +1,96 @@
 export { Agent, Artifact, ArtifactOptions, ArtifactResult, Audit, Budget, Checkpoint, CheckpointOptions, CheckpointState, CheckpointStorage, CheckpointStrategy, CommandPermissions, CompactionStrategy, Conversation, ConversationOptions, ConversationStorage, EditFormat, EditFormatType, FilesystemPermissions, Hook, HookEntry, HookPoint, HumanInTheLoop, HumanInTheLoopOptions, MainLoop, Mixin, Model, Observable, ObservableEntry, Policy, RequiresApproval, RequiresCapability, Sandbox, SandboxOptions, SubAgents, TimeoutAction, Tool, Toolbox, Trace, applyDecorators, getAgentConfig, getArtifactConfig, getCheckpointConfig, getConversationConfig, getHooks, getHooksByPoint, getHumanInTheLoopConfig, getMainLoop, getMixins, getObservableByChannel, getObservables, getSandboxConfig, getSubAgents, getToolConfig, getToolMethods, getToolboxConfig, isCommandAllowed, isPathAllowed } from './decorators.js';
-export { A as AgentOptions, a as ApprovalOptions, B as BudgetOptions, C as ContextCompactionStrategy, b as ContextWindow, c as ContextWindowOptions, G as Gateway, d as GatewayOptions, I as IndexStrategy, M as MCP, e as MainLoopMeta, f as MainLoopOptions, g as McpServerConfig, h as McpServersMap, i as Memory, j as MemoryOptions, k as MemoryProvider, l as MemoryScope, P as PlatformName, m as PolicyHandler, n as ProjectContext, o as ProjectContextOptions, R as RelevanceStrategy, S as SessionStrategy, p as Skills, q as SkillsOptions, T as ToolOptions, r as ToolboxOptions, s as getContextWindowConfig, t as getGatewayConfig, u as getMcpConfig, v as getMemoryConfig, w as getProjectContextConfig, x as getSkillsConfig, y as resolveSessionId } from './skills-DnfvEUSg.js';
-import { L as LoopOutcome, a as LoopStrategy, C as CompiledAgentOptions, D as DelegationResult } from './bridge-entry-CIwzw_3z.js';
-export { A as AgentExecutionContext, b as AgentManifest, c as AgentManifestEntry, d as AgentManifestTool, e as AgentRoute, f as AgentRouteContext, g as AgentRunInfo, h as AgentStreamEvent, i as AgentWalkResult, j as AgentWarningCode, k as AgentsPluginOptions, l as ApprovalRequiredEvent, m as ArtifactChunkEvent, n as ArtifactStartEvent, B as BudgetExceededError, o as CheckpointSavedEvent, p as CompiledContextWindow, q as CompiledTool, r as DEFAULT_MAX_ITERATIONS, s as DelegateOptions, t as DelegationError, u as DoneEvent, E as ErrorEvent, F as FileEditEvent, I as IterationEvent, v as LoopFinishReason, w as LoopStrategyConfig, R as RunStartedEvent, S as SdkMessage, x as StateUpdateEvent, y as StreamEvent, T as TextDeltaEvent, z as ThinkingEvent, G as ToolCallEvent, H as ToolResultEvent, J as ToolWalkResult, K as ToolboxWalkResult, M as agentsPlugin, N as compileAgent, O as compileContextWindow, P as compileProjectContext, Q as compileSkills, U as compileTools, V as createAgentExecutionContext, W as createSdkAgentStream, X as delegate, Y as generateAgentManifest, Z as generateAgentRoutes, _ as isAgentContext, $ as isApprovalRequired, a0 as isDone, a1 as isError, a2 as isTextDelta, a3 as isToolCall, a4 as isToolResult, a5 as loopStrategyConfigSchema, a6 as projectContextMetadataOnlyKnobs, a7 as resolveLoopStrategy, a8 as streamAgentResponse, a9 as translateSdkEvent, aa as validateUniqueRoutes, ab as walkAgentMetadata } from './bridge-entry-CIwzw_3z.js';
+export { A as AgentOptions, a as ApprovalOptions, B as BudgetOptions, C as Compaction, b as CompactionDecoratorConfig, c as ContextCompactionStrategy, d as ContextWindow, e as ContextWindowOptions, G as Gateway, f as GatewayOptions, I as IndexStrategy, M as MCP, g as MainLoopMeta, h as MainLoopOptions, i as McpServerConfig, j as McpServersMap, k as Memory, l as MemoryOptions, m as MemoryProvider, n as MemoryScope, P as PlatformName, o as PolicyHandler, p as ProjectContext, q as ProjectContextOptions, R as RelevanceStrategy, S as SessionStrategy, r as Skills, s as SkillsOptions, T as ToolOptions, t as ToolboxOptions, u as getCompactionConfig, v as getContextWindowConfig, w as getGatewayConfig, x as getMcpConfig, y as getMemoryConfig, z as getProjectContextConfig, D as getSkillsConfig, E as resolveSessionId } from './skills-BHnHPn7p.js';
+import { L as LoopOutcome, a as LoopStrategy, C as CompiledAgentOptions, b as CompiledTool, S as StreamEvent, D as DelegationResult } from './bridge-entry-Dt3Fr6md.js';
+export { A as AgentExecutionContext, c as AgentManifest, d as AgentManifestEntry, e as AgentManifestTool, f as AgentRoute, g as AgentRouteContext, h as AgentRunInfo, i as AgentStreamEvent, j as AgentWalkResult, k as AgentWarningCode, l as AgentsPluginOptions, m as ApprovalRequiredEvent, n as ArtifactChunkEvent, o as ArtifactStartEvent, B as BudgetExceededError, p as CheckpointSavedEvent, q as CompiledContextWindow, r as DEFAULT_MAX_ITERATIONS, s as DelegateOptions, t as DelegationError, u as DoneEvent, E as ErrorEvent, F as FileEditEvent, I as IterationEvent, v as LoopFinishReason, w as LoopStrategyConfig, R as RunStartedEvent, x as SdkMessage, y as StateUpdateEvent, T as TextDeltaEvent, z as ThinkingEvent, G as ToolCallEvent, H as ToolResultEvent, J as ToolWalkResult, K as ToolboxWalkResult, M as agentsPlugin, N as compileAgent, O as compileContextWindow, P as compileProjectContext, Q as compileSkills, U as compileTools, V as createAgentExecutionContext, W as createSdkAgentStream, X as delegate, Y as generateAgentManifest, Z as generateAgentRoutes, _ as isAgentContext, $ as isApprovalRequired, a0 as isDone, a1 as isError, a2 as isTextDelta, a3 as isToolCall, a4 as isToolResult, a5 as loopStrategyConfigSchema, a6 as projectContextMetadataOnlyKnobs, a7 as resolveLoopStrategy, a8 as streamAgentResponse, a9 as translateSdkEvent, aa as validateUniqueRoutes, ab as walkAgentMetadata } from './bridge-entry-Dt3Fr6md.js';
+import { CompressibleMessage } from '@theokit/sdk/compaction';
+export { CompressibleMessage } from '@theokit/sdk/compaction';
 import { z } from 'zod';
 import '@theokit/http';
 import '@theokit/sdk';
 
+/**
+ * TranscriptCompactionStrategy — a named, callable transcript-compaction authoring layer
+ * (Strategy pattern, V4-F). Mirrors `ReflectionStrategy`/`LoopStrategy`: interface
+ * + zod config schema + a `'token-budget'` default + `resolveCompactionStrategy`.
+ *
+ * The `'token-budget'` strategy DELEGATES to the SDK's `compactTranscript` (ADR D2 /
+ * G2 / sdk-runtime.md — the SDK owns the algorithm; agents owns the named interface;
+ * no reimplementation). Per ADR D1 it is CALLABLE by the app (exposed as
+ * `AgentRunner.compaction`), NOT auto-invoked by the reflective loop — the SDK owns
+ * per-turn context, so the app decides WHEN to compact and supplies the `summarize`
+ * callback (its own LLM). EC-6: consumers whose transcript rows carry roles outside
+ * the SDK's `CompressibleMessage` union (e.g. `'tool'`) cast at the call site, exactly
+ * as the SDK's own type contract requires.
+ *
+ * referencia: knowledge-base/references/mastra compaction (named strategy over a budget).
+ */
+
+/** Token budget mirrored from theocode's proven `DEFAULT_KEEP_TOKENS` (server/lib/compaction.ts). */
+declare const DEFAULT_KEEP_TOKENS = 8000;
+/**
+ * App-supplied summarizer: collapse the older window into one turn (the app's LLM).
+ * Signature matches the SDK `compactTranscript` contract — receives the older window
+ * AND the (optionally overridden) summary template.
+ */
+type Summarize = (older: CompressibleMessage[], template: string) => Promise<CompressibleMessage>;
+/**
+ * Per-call options for {@link TranscriptCompactionStrategy.compact} — a faithful
+ * pass-through of the SDK `CompactTranscriptOptions` knobs the app controls. Defaults
+ * are the SDK's, EXCEPT `failSafe` which defaults `true` here: a thrown `summarize`
+ * returns the ORIGINAL transcript + a structured warn instead of losing it — compaction
+ * is an optimization, never a cause of data loss (error-handling discipline). The app
+ * passes `failSafe: false` to opt into fail-fast propagation.
+ */
+interface CompactionCallOptions {
+    /** Override the strategy's configured `keepTokens` for this call. */
+    readonly keepTokens?: number;
+    /** Summarize the older window; if omitted, the SDK drops it (its documented contract). */
+    readonly summarize?: Summarize;
+    /** Checkpoint marker (SDK default when omitted). */
+    readonly marker?: string;
+    /** Summary template passed to `summarize` (SDK default when omitted). */
+    readonly summaryTemplate?: string;
+    /** When true (DEFAULT here), a thrown `summarize` returns the original transcript + a warn. */
+    readonly failSafe?: boolean;
+}
+/** A named, callable compaction strategy. Pure of I/O except the delegated SDK call. */
+interface TranscriptCompactionStrategy {
+    /** Strategy identifier (e.g. `'token-budget'`). */
+    readonly name: string;
+    /** The configured token budget (from `@Compaction` / `.compaction()` / default). */
+    readonly keepTokens: number;
+    /**
+     * Compact `messages` to the (optionally overridden) token budget via the SDK's
+     * `compactTranscript`. Returns the compacted transcript; never mutates the input.
+     */
+    compact(messages: CompressibleMessage[], options?: CompactionCallOptions): Promise<CompressibleMessage[]>;
+}
+/**
+ * Serializable config for a TranscriptCompactionStrategy (SSoT per type-safety.md / G3).
+ * `keepTokens` is REQUIRED for `'token-budget'` (EC-2 / G10 — no silent degradation
+ * to the SDK's turn-count `keepRecent` default; the strategy is named for token budget).
+ */
+declare const compactionStrategyConfigSchema: z.ZodObject<{
+    name: z.ZodLiteral<"token-budget">;
+    keepTokens: z.ZodNumber;
+}, z.core.$strip>;
+type CompactionStrategyConfig = z.infer<typeof compactionStrategyConfigSchema>;
+/**
+ * Resolve a `@Compaction` / `.compaction()` declaration to a concrete strategy.
+ * Throws (Zod) on an unknown name or a missing/invalid `keepTokens` (EC-2/EC-5 —
+ * fail-fast, mirrors `resolveLoopStrategy`). The returned strategy's `compact`
+ * delegates to `compactTranscript`, defaulting `keepTokens` to the configured value.
+ */
+declare function resolveCompactionStrategy(name: string, config: {
+    keepTokens?: number;
+}): TranscriptCompactionStrategy;
+/**
+ * The default `'token-budget'` strategy (what `@Compaction('token-budget')` without
+ * an explicit budget resolves to). Carries {@link DEFAULT_KEEP_TOKENS}; the app may
+ * override per call via `compact(messages, { keepTokens })`.
+ */
+declare const tokenBudgetCompactionStrategy: TranscriptCompactionStrategy;
+
 /**
  * ReflectionStrategy — composes INTO the loop between rounds (the loop calls
  * `reflect()` then `LoopStrategy.shouldContinue()`).
@@ -26,12 +111,25 @@ interface ReflectionResult {
     /** Hint: should the loop reflect-and-continue? (the ceiling still bounds it) */
     readonly continue: boolean;
 }
+/**
+ * V4-K: a per-run mutable scratch bag threaded to every `reflect()` call within one
+ * `runReflectiveLoopStream` run, so a STATEFUL strategy can accumulate cumulative state
+ * (counters, one-shot flags) across rounds. The framework owns the lifecycle (creates
+ * one per run, passes the SAME ref each round) but writes NOTHING into it — the strategy
+ * owns the contents. Generic by design: the framework cannot know app semantics (e.g.
+ * what an "edit" is). A consumer narrows it locally (`ctx as MyState`).
+ */
+type ReflectionContext = Record<string, unknown>;
 /** Pluggable between-round reflection. Pure — never performs I/O. */
 interface ReflectionStrategy {
     /** Strategy identifier (e.g. `'ladder'`). */
     readonly name: string;
-    /** Inspect the round outcome; return feedback + continue hint. */
-    reflect(outcome: LoopOutcome): ReflectionResult;
+    /**
+     * Inspect the round outcome; return feedback + continue hint. `ctx` (V4-K) is the
+     * per-run mutable scratch — optional for backward compatibility (shipped strategies
+     * ignore it; stateful custom strategies accumulate in it across rounds).
+     */
+    reflect(outcome: LoopOutcome, ctx?: ReflectionContext): ReflectionResult;
 }
 /** Serializable config for a ReflectionStrategy. SSoT per type-safety.md (ADR D3). */
 declare const reflectionStrategyConfigSchema: z.ZodObject<{
@@ -67,8 +165,9 @@ declare const noopReflectionStrategy: ReflectionStrategy;
  * compiles the agent and resolves the SAME `{ compiled, loopStrategy }` that
  * `delegate()` resolves for the decorator path (two on-ramps, one runtime).
  * `build()` is the compile boundary (no I/O, no IoC — standalone, mirrors
- * Spring's `ChatClient.builder(...).build()`); `run()` does the I/O via
- * `runReflectiveLoop` (the SAME loop `delegate()` uses — DRY, ADR 0031).
+ * Spring's `ChatClient.builder(...).build()`); `stream()`/`run()` do the I/O via
+ * `runReflectiveLoopStream` (the SAME loop `delegate()` drains — DRY, ADR 0031).
+ * V4-D-stream: `stream()` yields events live (SSE-first); `run()` drains it to a result.
  *
  * referencia: knowledge-base/references/spring-ai DefaultChatClientBuilder.java (build() returns standalone).
  */
@@ -83,11 +182,30 @@ interface AgentRunnerRunOptions {
     readonly budget?: number;
     /** Cancellation — aborts stop the reflective loop from re-entering. */
     readonly signal?: AbortSignal;
+    /**
+     * V4-J: per-run tool override. When provided, REPLACES the build-time
+     * `compiled.tools` for this call only (e.g. a consumer that selects tools by
+     * request mode/permission). Absent ⇒ the agent's compiled tools (unchanged).
+     */
+    readonly tools?: readonly CompiledTool[];
 }
 /**
  * A built, runnable agent. Construct via {@link AgentRunner.builder} — the
  * constructor takes already-resolved state and is an internal detail.
  */
+/** Already-resolved state handed to the {@link AgentRunner} constructor (internal). */
+interface AgentRunnerState {
+    readonly compiled: CompiledAgentOptions;
+    readonly agentName: string;
+    /** The resolved terminal-decision strategy (parity with `delegate()`). */
+    readonly loopStrategy: LoopStrategy;
+    /** The resolved between-round reflection (default or `.reflection(custom)` override). */
+    readonly reflectionStrategy: ReflectionStrategy;
+    /** Recorded streaming preference (see {@link AgentRunner.streamEnabled}). */
+    readonly streamEnabled: boolean;
+    /** The resolved compaction strategy, or `undefined` when none is declared (EC-4). */
+    readonly compaction?: TranscriptCompactionStrategy;
+}
 declare class AgentRunner {
     private readonly compiled;
     private readonly agentName;
@@ -96,27 +214,31 @@ declare class AgentRunner {
     /** The resolved between-round reflection (default or `.reflection(custom)` override). */
     readonly reflectionStrategy: ReflectionStrategy;
     /**
-     * Recorded streaming preference. The reflective loop currently always
-     * streams via the SDK `Run.stream()`; a non-streaming collect mode is future
-     * work — the flag is captured + exposed here, not yet branched on (honest
-     * per G10: documented, not a silent no-op).
+     * Recorded streaming preference. The reflective loop currently always streams via
+     * the SDK `Run.stream()`; a non-streaming collect mode is future work — the flag is
+     * captured + exposed here, not yet branched on (honest per G10: documented, not a
+     * silent no-op).
      */
     readonly streamEnabled: boolean;
-    constructor(compiled: CompiledAgentOptions, agentName: string, 
-    /** The resolved terminal-decision strategy (parity with `delegate()`). */
-    loopStrategy: LoopStrategy, 
-    /** The resolved between-round reflection (default or `.reflection(custom)` override). */
-    reflectionStrategy: ReflectionStrategy, 
     /**
-     * Recorded streaming preference. The reflective loop currently always
-     * streams via the SDK `Run.stream()`; a non-streaming collect mode is future
-     * work — the flag is captured + exposed here, not yet branched on (honest
-     * per G10: documented, not a silent no-op).
+     * V4-F: the resolved compaction strategy (from `@Compaction` or `.compaction()`),
+     * or `undefined` when neither is declared — compaction is opt-in (EC-4). CALLABLE
+     * by the app (ADR D1: `runner.compaction?.compact(messages, { summarize })`); the
+     * reflective loop does NOT auto-invoke it (the SDK owns per-turn context).
      */
-    streamEnabled: boolean);
+    readonly compaction?: TranscriptCompactionStrategy;
+    constructor(state: AgentRunnerState);
     /** Start a fluent builder for `AgentClass`. */
     static builder(AgentClass: Function): AgentRunnerBuilder;
-    /** Run the agent to a terminal result via the shared reflective loop. */
+    /**
+     * V4-D-stream: stream the agent's events LIVE across the reflective loop, returning
+     * the aggregated {@link DelegationResult} as the generator's return value. This is the
+     * on-ramp for streaming-first apps (SSE) — `runReflectiveLoopStream` yields every
+     * round's events before the loop terminates. `streamEnabled` is honored: when the
+     * builder set `.stream(false)`, callers should use {@link run} instead.
+     */
+    stream(message: string, opts: AgentRunnerRunOptions): AsyncGenerator<StreamEvent, DelegationResult>;
+    /** Run the agent to a terminal result via the shared reflective loop (collect mode). */
     run(message: string, opts: AgentRunnerRunOptions): Promise<DelegationResult>;
 }
 /** Fluent builder — accumulates config; `build()` is the compile boundary. */
@@ -124,13 +246,22 @@ declare class AgentRunnerBuilder {
     private readonly AgentClass;
     private reflectionOverride?;
     private streamEnabled;
+    private compactionOverride?;
     constructor(AgentClass: Function);
     /** Override the default reflection strategy (OCP — plan Drawback #2). No arg ⇒ keep default. */
     reflection(strategy?: ReflectionStrategy): this;
     /** Record the streaming preference (see {@link AgentRunner.streamEnabled}). */
     stream(enabled?: boolean): this;
+    /**
+     * V4-F: declare the compaction strategy (e.g. `.compaction('token-budget', { keepTokens: 8000 })`).
+     * Resolved + validated at {@link build} (EC-5 — fail-fast there, not here). This builder
+     * call WINS over a `@Compaction` decorator on the same agent (EC-1 — explicit override).
+     */
+    compaction(name: string, options?: {
+        keepTokens?: number;
+    }): this;
     /** Walk + compile + resolve strategies — the compile→execute boundary (no I/O). */
     build(): AgentRunner;
 }
 
-export { AgentRunner, AgentRunnerBuilder, type AgentRunnerRunOptions, CompiledAgentOptions, DelegationResult, LoopOutcome, LoopStrategy, type ReflectionResult, type ReflectionStrategy, type ReflectionStrategyConfig, ladderReflectionStrategy, noopReflectionStrategy, reflectionStrategyConfigSchema };
+export { AgentRunner, AgentRunnerBuilder, type AgentRunnerRunOptions, type CompactionCallOptions, type CompactionStrategyConfig, CompiledAgentOptions, CompiledTool, DEFAULT_KEEP_TOKENS, DelegationResult, LoopOutcome, LoopStrategy, type ReflectionContext, type ReflectionResult, type ReflectionStrategy, type ReflectionStrategyConfig, StreamEvent, type Summarize, type TranscriptCompactionStrategy, compactionStrategyConfigSchema, ladderReflectionStrategy, noopReflectionStrategy, reflectionStrategyConfigSchema, resolveCompactionStrategy, tokenBudgetCompactionStrategy };

package/dist/index.js

@@ -27,15 +27,17 @@ import {
   getToolboxConfig,
   isCommandAllowed,
   isPathAllowed
-} from "./chunk-XWVZS2PQ.js";
+} from "./chunk-SKTJS4QQ.js";
 import {
   AgentRunner,
   AgentRunnerBuilder,
   AgentWarningCode,
   BudgetExceededError,
+  DEFAULT_KEEP_TOKENS,
   DEFAULT_MAX_ITERATIONS,
   DelegationError,
   agentsPlugin,
+  compactionStrategyConfigSchema,
   compileAgent,
   compileContextWindow,
   compileProjectContext,
@@ -58,16 +60,19 @@ import {
   noopReflectionStrategy,
   projectContextMetadataOnlyKnobs,
   reflectionStrategyConfigSchema,
+  resolveCompactionStrategy,
   resolveLoopStrategy,
   streamAgentResponse,
+  tokenBudgetCompactionStrategy,
   translateSdkEvent,
   validateUniqueRoutes,
   walkAgentMetadata
-} from "./chunk-2MYIZ4OT.js";
+} from "./chunk-5FZVMZPG.js";
 import {
   Agent,
   Audit,
   Budget,
+  Compaction,
   ContextWindow,
   Gateway,
   MCP,
@@ -81,6 +86,7 @@ import {
   SubAgents,
   Trace,
   getAgentConfig,
+  getCompactionConfig,
   getContextWindowConfig,
   getGatewayConfig,
   getMcpConfig,
@@ -90,7 +96,7 @@ import {
   getSkillsConfig,
   getSubAgents,
   resolveSessionId
-} from "./chunk-MVEY7HEY.js";
+} from "./chunk-GVPUUKKE.js";
 import "./chunk-7QVYU63E.js";
 export {
   Agent,
@@ -102,8 +108,10 @@ export {
   Budget,
   BudgetExceededError,
   Checkpoint,
+  Compaction,
   ContextWindow,
   Conversation,
+  DEFAULT_KEEP_TOKENS,
   DEFAULT_MAX_ITERATIONS,
   DelegationError,
   EditFormat,
@@ -128,6 +136,7 @@ export {
   Trace,
   agentsPlugin,
   applyDecorators,
+  compactionStrategyConfigSchema,
   compileAgent,
   compileContextWindow,
   compileProjectContext,
@@ -141,6 +150,7 @@ export {
   getAgentConfig,
   getArtifactConfig,
   getCheckpointConfig,
+  getCompactionConfig,
   getContextWindowConfig,
   getConversationConfig,
   getGatewayConfig,
@@ -174,9 +184,11 @@ export {
   noopReflectionStrategy,
   projectContextMetadataOnlyKnobs,
   reflectionStrategyConfigSchema,
+  resolveCompactionStrategy,
   resolveLoopStrategy,
   resolveSessionId,
   streamAgentResponse,
+  tokenBudgetCompactionStrategy,
   translateSdkEvent,
   validateUniqueRoutes,
   walkAgentMetadata

package/dist/{skills-DnfvEUSg.d.ts → skills-BHnHPn7p.d.ts}

@@ -66,6 +66,18 @@ type PolicyHandler = (user: {
     roles: string[];
 }) => boolean;
 
+/** Stored `@Compaction` declaration (resolved + validated at `AgentRunner.build()`). */
+interface CompactionDecoratorConfig {
+    /** Strategy name (e.g. `'token-budget'`). Validated at resolve time. */
+    name: string;
+    /** Token budget for `'token-budget'`. Required at resolve time (EC-2). */
+    keepTokens?: number;
+}
+declare function Compaction(name: string, options?: {
+    keepTokens?: number;
+}): ClassDecorator;
+declare function getCompactionConfig(target: Function): CompactionDecoratorConfig | undefined;
+
 type ContextCompactionStrategy = 'truncate-oldest' | 'summarize-oldest' | 'sliding-window' | 'priority-based';
 interface ContextWindowOptions {
     /** Maximum tokens before compaction triggers. */
@@ -167,4 +179,4 @@ interface SkillsOptions {
 declare function Skills(namesOrOptions: string[] | SkillsOptions): ClassDecorator;
 declare function getSkillsConfig(target: Function): SkillsOptions | undefined;
 
-export { type AgentOptions as A, type BudgetOptions as B, type ContextCompactionStrategy as C, Gateway as G, type IndexStrategy as I, MCP as M, type PlatformName as P, type RelevanceStrategy as R, type SessionStrategy as S, type ToolOptions as T, type ApprovalOptions as a, ContextWindow as b, type ContextWindowOptions as c, type GatewayOptions as d, type MainLoopMeta as e, type MainLoopOptions as f, type McpServerConfig as g, type McpServersMap as h, Memory as i, type MemoryOptions as j, type MemoryProvider as k, type MemoryScope as l, type PolicyHandler as m, ProjectContext as n, type ProjectContextOptions as o, Skills as p, type SkillsOptions as q, type ToolboxOptions as r, getContextWindowConfig as s, getGatewayConfig as t, getMcpConfig as u, getMemoryConfig as v, getProjectContextConfig as w, getSkillsConfig as x, resolveSessionId as y };
+export { type AgentOptions as A, type BudgetOptions as B, Compaction as C, getSkillsConfig as D, resolveSessionId as E, Gateway as G, type IndexStrategy as I, MCP as M, type PlatformName as P, type RelevanceStrategy as R, type SessionStrategy as S, type ToolOptions as T, type ApprovalOptions as a, type CompactionDecoratorConfig as b, type ContextCompactionStrategy as c, ContextWindow as d, type ContextWindowOptions as e, type GatewayOptions as f, type MainLoopMeta as g, type MainLoopOptions as h, type McpServerConfig as i, type McpServersMap as j, Memory as k, type MemoryOptions as l, type MemoryProvider as m, type MemoryScope as n, type PolicyHandler as o, ProjectContext as p, type ProjectContextOptions as q, Skills as r, type SkillsOptions as s, type ToolboxOptions as t, getCompactionConfig as u, getContextWindowConfig as v, getGatewayConfig as w, getMcpConfig as x, getMemoryConfig as y, getProjectContextConfig as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theokit/agents",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "Unified decorator runtime — AI agents as first-class citizens of the TheoKit pipeline. @Agent() compiles to SDK Agent.create(), @Tool() compiles to defineTool().",
   "type": "module",
   "sideEffects": false,
@@ -36,7 +36,7 @@
   },
   "peerDependencies": {
     "@theokit/http": ">=0.1.0-alpha.0",
-    "@theokit/sdk": ">=2.5.0",
+    "@theokit/sdk": ">=2.9.0",
     "@theokit/sdk-tools": ">=0.2.0",
     "reflect-metadata": ">=0.2.0",
     "zod": "^4.0.0"
@@ -48,7 +48,7 @@
   },
   "devDependencies": {
     "@theokit/http": "workspace:*",
-    "@theokit/sdk": "^2.5.0",
+    "@theokit/sdk": "^2.9.0",
     "@theokit/sdk-tools": "^0.2.0",
     "reflect-metadata": "^0.2.2",
     "tsup": "^8.5.1",