@theokit/agents 0.6.0 → 0.8.0

package/dist/index.d.ts

@@ -1,74 +1,95 @@
 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';
-import { M as MainLoopMeta } from './skills-DmN1HGUb.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, e as MCP, 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-DmN1HGUb.js';
-import { CompiledAgentOptions, DelegationResult } from './bridge.js';
-export { AgentExecutionContext, AgentManifest, AgentManifestEntry, AgentManifestTool, AgentRoute, AgentRouteContext, AgentRunInfo, AgentStreamEvent, AgentWalkResult, AgentWarningCode, AgentsPluginOptions, ApprovalRequiredEvent, ArtifactChunkEvent, ArtifactStartEvent, BudgetExceededError, CheckpointSavedEvent, CompiledContextWindow, CompiledTool, DelegateOptions, DelegationError, DoneEvent, ErrorEvent, FileEditEvent, IterationEvent, RunStartedEvent, SdkMessage, StateUpdateEvent, StreamEvent, TextDeltaEvent, ThinkingEvent, ToolCallEvent, ToolResultEvent, ToolWalkResult, ToolboxWalkResult, agentsPlugin, compileAgent, compileContextWindow, compileProjectContext, compileSkills, compileTools, createAgentExecutionContext, createSdkAgentStream, delegate, generateAgentManifest, generateAgentRoutes, isAgentContext, isApprovalRequired, isDone, isError, isTextDelta, isToolCall, isToolResult, projectContextMetadataOnlyKnobs, streamAgentResponse, translateSdkEvent, validateUniqueRoutes, walkAgentMetadata } from './bridge.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, S as StreamEvent, D as DelegationResult } from './bridge-entry-CAI1139f.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, 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-CAI1139f.js';
+import { CompressibleMessage } from '@theokit/sdk/compaction';
+export { CompressibleMessage } from '@theokit/sdk/compaction';
 import { z } from 'zod';
 import '@theokit/http';
 import '@theokit/sdk';
 
 /**
- * LoopStrategy — the per-round terminal-decision contract that gives runtime to
- * `@MainLoop({ strategy })`.
+ * TranscriptCompactionStrategy — a named, callable transcript-compaction authoring layer
+ * (Strategy pattern, V4-F). Mirrors `ReflectionStrategy`/`LoopStrategy`: interface
+ * + zod config schema + a `'token-budget'` default + `resolveCompactionStrategy`.
  *
- * V4-A proved `@MainLoop`'s `strategy` field was metadata-only (declared +
- * compiled, never executed). This module is the foundation Phase 2's
- * `runReflectiveLoop` branches on. Modeled on Mastra's `agentic-loop`/`stopWhen`
- * (inverted) + `maxSteps` ceiling — NOT Spring's per-call Advisor (plan ADR D1).
- * Config is Zod-validated so an invalid `maxIterations` fails fast at resolve
- * time, never as a silent infinite loop at runtime (plan ADR D3).
+ * 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 agentic-loop/index.ts (stopWhen + maxSteps).
+ * referencia: knowledge-base/references/mastra compaction (named strategy over a budget).
  */
 
-/** Why a single round ended. Derived in the bridge from the SDK stream events. */
-type LoopFinishReason = 'tool-calls' | 'stop' | 'length' | 'error';
-/** Value object describing one round's result. */
-interface LoopOutcome {
-    /** Why the round ended (the continuation signal). */
-    readonly finishReason: LoopFinishReason;
-    /** 1-indexed round number that just completed. */
-    readonly round: number;
-    /** Tool calls executed during the round. */
-    readonly toolCalls: readonly {
-        name: string;
-        input: unknown;
-        output: string;
-    }[];
-    /** Accumulated assistant text for the round. */
-    readonly responseText: string;
+/** 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;
 }
-/** The terminal-decision contract. `shouldContinue` is the inverted `stopWhen`. */
-interface LoopStrategy {
-    /** The originating `@MainLoop` strategy name. */
-    readonly name: MainLoopMeta['strategy'];
-    /** Hard ceiling on rounds — guarantees termination. */
-    readonly maxIterations: number;
-    /** True ⇒ re-enter for another round; false ⇒ terminate. Never true forever. */
-    shouldContinue(outcome: LoopOutcome): 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[]>;
 }
-/** Default round ceiling when `@MainLoop` declares no `maxIterations` (EC-3: finite, never Infinity). */
-declare const DEFAULT_MAX_ITERATIONS = 8;
-/** Serializable config for a LoopStrategy. SSoT per type-safety.md (ADR D3). */
-declare const loopStrategyConfigSchema: z.ZodObject<{
-    name: z.ZodEnum<{
-        react: "react";
-        "simple-chat": "simple-chat";
-        "plan-act-reflect": "plan-act-reflect";
-    }>;
-    maxIterations: z.ZodNumber;
+/**
+ * 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 LoopStrategyConfig = z.infer<typeof loopStrategyConfigSchema>;
+type CompactionStrategyConfig = z.infer<typeof compactionStrategyConfigSchema>;
 /**
- * Map a `@MainLoop` strategy + ceiling to a concrete {@link LoopStrategy}.
- *
- * - `simple-chat` ⇒ exactly one round (`shouldContinue` always false).
- * - `plan-act-reflect` / `react` ⇒ continue while the round ended on `tool-calls`
- *   AND the ceiling has not been reached (`round < maxIterations`).
- *
- * Throws (Zod) when `maxIterations < 1` — fail fast, never a silent infinite loop.
+ * 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 function resolveLoopStrategy(strategy: MainLoopMeta['strategy'], maxIterations?: number): LoopStrategy;
+declare const tokenBudgetCompactionStrategy: TranscriptCompactionStrategy;
 
 /**
  * ReflectionStrategy — composes INTO the loop between rounds (the loop calls
@@ -131,8 +152,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).
  */
@@ -152,6 +174,19 @@ interface AgentRunnerRunOptions {
  * 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;
@@ -160,27 +195,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. */
@@ -188,13 +227,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, DEFAULT_MAX_ITERATIONS, DelegationResult, type LoopFinishReason, type LoopOutcome, type LoopStrategy, type LoopStrategyConfig, MainLoopMeta, type ReflectionResult, type ReflectionStrategy, type ReflectionStrategyConfig, ladderReflectionStrategy, loopStrategyConfigSchema, noopReflectionStrategy, reflectionStrategyConfigSchema, resolveLoopStrategy };
+export { AgentRunner, AgentRunnerBuilder, type AgentRunnerRunOptions, type CompactionCallOptions, type CompactionStrategyConfig, CompiledAgentOptions, DEFAULT_KEEP_TOKENS, DelegationResult, LoopOutcome, LoopStrategy, 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-KTYBQ7HY.js";
+} from "./chunk-BCSRKDP6.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-DmN1HGUb.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, type MainLoopMeta 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, MCP 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.6.0",
+  "version": "0.8.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",