@theokit/agents 0.3.0 → 0.5.0

package/dist/chunk-XWVZS2PQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/decorators/main-loop.ts","../src/decorators/tool.ts","../src/decorators/hook.ts","../src/decorators/conversation.ts","../src/decorators/human-in-the-loop.ts","../src/decorators/model.ts","../src/decorators/artifact.ts","../src/decorators/checkpoint.ts","../src/decorators/observable.ts","../src/decorators/sandbox.ts","../src/decorators/edit-format.ts","../src/decorators/apply-decorators.ts"],"sourcesContent":["/**\n * @MainLoop() — marks the execution entry point of an agent.\n *\n * Only one @MainLoop per agent class. Second application overwrites (last-wins, with warning).\n */\nimport { setMeta, getMeta, AGENT_MAIN_LOOP } from '../metadata/index.js'\nimport type { MainLoopOptions, MainLoopMeta } from '../types.js'\n\nexport function MainLoop(options: MainLoopOptions = {}): MethodDecorator {\n  return (target: object, propertyKey: string | symbol) => {\n    const actualTarget = target.constructor\n    const existing = getMeta<MainLoopMeta>(AGENT_MAIN_LOOP, actualTarget)\n    if (existing) {\n      console.warn(\n        `[@theokit/agents] ${actualTarget.name}: @MainLoop() already declared on '${String(existing.propertyKey)}'. Overwriting with '${String(propertyKey)}'.`,\n      )\n    }\n    const meta: MainLoopMeta = {\n      propertyKey,\n      strategy: options.strategy ?? 'simple-chat',\n      maxIterations: options.maxIterations,\n      timeoutMs: options.timeoutMs,\n    }\n    setMeta(AGENT_MAIN_LOOP, actualTarget, meta)\n  }\n}\n\nexport function getMainLoop(target: Function): MainLoopMeta | undefined {\n  return getMeta<MainLoopMeta>(AGENT_MAIN_LOOP, target)\n}\n","/**\n * @Toolbox() + @Tool() — group and define agent tools.\n *\n * @Toolbox({ namespace }) is a class decorator that groups related tools.\n * @Tool({ name, description, input, risk }) is a method decorator compiled to defineTool().\n *\n * @UseGuards on @Toolbox applies to ALL tools (per ADR D7).\n */\nimport { setMeta, getMeta, TOOLBOX_CONFIG, TOOL_CONFIG, TOOL_METHODS } from '../metadata/index.js'\nimport type { ToolboxOptions, ToolOptions } from '../types.js'\n\n/**\n * Convention: TaskTools → namespace: 'tasks', ProjectTools → namespace: 'projects'\n * Strips \"Tools\" suffix, converts to kebab-case.\n */\nfunction inferNamespace(className: string): string {\n  const stripped = className.replace(/Tools$/, '')\n  return stripped\n    .replace(/([a-z0-9])([A-Z])/g, '$1-$2')\n    .replace(/([A-Z])([A-Z][a-z])/g, '$1-$2')\n    .toLowerCase()\n}\n\nexport function Toolbox(options: ToolboxOptions = {}): ClassDecorator {\n  return (target: Function) => {\n    const ns = options.namespace ?? inferNamespace(target.name)\n    setMeta(TOOLBOX_CONFIG, target, { ...options, namespace: ns })\n  }\n}\n\nexport function Tool(options: ToolOptions): MethodDecorator {\n  return (target: object, propertyKey: string | symbol) => {\n    const actualTarget = target.constructor\n    setMeta(TOOL_CONFIG, actualTarget, options, propertyKey)\n    // Accumulate tool methods list\n    const existing = getMeta<(string | symbol)[]>(TOOL_METHODS, actualTarget) ?? []\n    setMeta(TOOL_METHODS, actualTarget, [...existing, propertyKey])\n  }\n}\n\nexport function getToolboxConfig(target: Function): ToolboxOptions | undefined {\n  return getMeta<ToolboxOptions>(TOOLBOX_CONFIG, target)\n}\n\nexport function getToolMethods(target: Function): (string | symbol)[] {\n  return getMeta<(string | symbol)[]>(TOOL_METHODS, target) ?? []\n}\n\nexport function getToolConfig(\n  target: Function,\n  propertyKey: string | symbol,\n): ToolOptions | undefined {\n  return getMeta<ToolOptions>(TOOL_CONFIG, target, propertyKey)\n}\n","/**\n * @Hook() — lifecycle hooks WITHIN the agent loop.\n *\n * Unlike HTTP interceptors (which wrap the entire handler), hooks fire at\n * specific points during the agent's reasoning → tool → response cycle.\n *\n * Hook points:\n * - 'before:llm-call'  — before each LLM API call\n * - 'after:llm-call'   — after each LLM response\n * - 'before:tool-call' — before each tool execution\n * - 'after:tool-call'  — after each tool result\n * - 'on:iteration'     — at each loop iteration\n * - 'on:complete'      — when the agent produces a final answer\n * - 'on:error'         — when the agent encounters an error\n *\n * @example\n * ```ts\n * @Agent({ name: 'support', route: '/support' })\n * class SupportAgent {\n *   @MainLoop()\n *   async run() {}\n *\n *   @Hook('before:llm-call')\n *   async injectContext(ctx: HookContext) {\n *     ctx.appendSystemPrompt(`Time: ${new Date().toISOString()}`)\n *   }\n *\n *   @Hook('after:tool-call')\n *   async trackCost(ctx: HookContext) {\n *     await billing.track(ctx.toolCall!.name, ctx.toolCall!.durationMs)\n *   }\n * }\n * ```\n */\nimport { setMeta, getMeta } from '../metadata/index.js'\n\nconst HOOKS_CONFIG = Symbol.for('theokit:agents:hooks')\n\nexport type HookPoint =\n  | 'before:llm-call'\n  | 'after:llm-call'\n  | 'before:tool-call'\n  | 'after:tool-call'\n  | 'on:iteration'\n  | 'on:complete'\n  | 'on:error'\n\nexport interface HookEntry {\n  point: HookPoint\n  propertyKey: string | symbol\n}\n\nexport function Hook(point: HookPoint): MethodDecorator {\n  return (target: object, propertyKey: string | symbol) => {\n    const actualTarget = target.constructor\n    const existing = getMeta<HookEntry[]>(HOOKS_CONFIG, actualTarget) ?? []\n    setMeta(HOOKS_CONFIG, actualTarget, [...existing, { point, propertyKey }])\n  }\n}\n\nexport function getHooks(target: Function): HookEntry[] {\n  return getMeta<HookEntry[]>(HOOKS_CONFIG, target) ?? []\n}\n\nexport function getHooksByPoint(target: Function, point: HookPoint): HookEntry[] {\n  return getHooks(target).filter((h) => h.point === point)\n}\n","/**\n * @Conversation() — declares conversation persistence strategy for an agent.\n *\n * Controls how the agent remembers message history across sessions.\n * Compiles to SDK's ConversationStorageAdapter configuration.\n *\n * @example\n * ```ts\n * @Agent({ name: 'support', route: '/support' })\n * @Conversation({\n *   storage: 'drizzle',\n *   maxHistory: 100,\n *   compaction: 'summarize',\n *   ttl: 24 * 60 * 60 * 1000,\n * })\n * class SupportAgent { ... }\n * ```\n */\nimport { setMeta, getMeta } from '../metadata/index.js'\n\nconst CONVERSATION_CONFIG = Symbol.for('theokit:agents:conversation')\n\nexport type ConversationStorage = 'memory' | 'filesystem' | 'drizzle' | 'redis'\nexport type CompactionStrategy = 'truncate' | 'summarize' | 'sliding-window'\n\nexport interface ConversationOptions {\n  /** Storage backend for conversation history. */\n  storage?: ConversationStorage\n  /** Maximum messages before compaction triggers (0 = no limit). */\n  maxHistory?: number\n  /** How to compact when maxHistory is exceeded. */\n  compaction?: CompactionStrategy\n  /** Time-to-live in milliseconds before conversation expires (0 = never). */\n  ttl?: number\n  /** Number of recent messages to always preserve during compaction. */\n  preserveLastN?: number\n}\n\nexport function Conversation(options: ConversationOptions = {}): ClassDecorator {\n  return (target: Function) => {\n    setMeta(CONVERSATION_CONFIG, target, {\n      storage: 'memory',\n      maxHistory: 0,\n      compaction: 'truncate',\n      ttl: 0,\n      preserveLastN: 5,\n      ...options,\n    })\n  }\n}\n\nexport function getConversationConfig(target: Function): ConversationOptions | undefined {\n  return getMeta<ConversationOptions>(CONVERSATION_CONFIG, target)\n}\n","/**\n * @HumanInTheLoop() — pause agent execution to request human approval.\n *\n * When applied to a @Tool method, the agent pauses before executing the tool\n * and emits an 'approval_required' SSE event. The client must POST to the\n * callback URL to approve or deny. If denied or timed out, the tool is skipped.\n *\n * @example\n * ```ts\n * @Toolbox({ namespace: 'ops' })\n * class OpsTools {\n *   @Tool({ name: 'deploy', description: 'Deploy to prod', input: z.object({...}) })\n *   @HumanInTheLoop({\n *     question: 'Confirm deployment to production?',\n *     timeout: 300_000,\n *     onTimeout: 'abort',\n *   })\n *   async deploy(input: {...}) { ... }\n * }\n * ```\n *\n * SSE event emitted:\n * ```json\n * { \"type\": \"approval_required\", \"toolName\": \"ops.deploy\", \"question\": \"...\", \"callbackUrl\": \"/agents/x/approve/call-123\" }\n * ```\n */\nimport { setMeta, getMeta } from '../metadata/index.js'\n\nconst HITL_CONFIG = Symbol.for('theokit:agents:human-in-the-loop')\n\nexport type TimeoutAction = 'abort' | 'proceed' | 'retry'\n\nexport interface HumanInTheLoopOptions {\n  /** Question shown to the human approver. */\n  question: string\n  /** Timeout in milliseconds before onTimeout fires (default: 300_000 = 5 min). */\n  timeout?: number\n  /** Action when timeout expires (default: 'abort'). */\n  onTimeout?: TimeoutAction\n  /** Show the tool input to the approver (default: true). */\n  showInput?: boolean\n}\n\nexport function HumanInTheLoop(options: HumanInTheLoopOptions): MethodDecorator {\n  return (target: object, propertyKey: string | symbol) => {\n    const actualTarget = target.constructor\n    setMeta(HITL_CONFIG, actualTarget, {\n      timeout: 300_000,\n      onTimeout: 'abort',\n      showInput: true,\n      ...options,\n    }, propertyKey)\n  }\n}\n\nexport function getHumanInTheLoopConfig(\n  target: Function,\n  propertyKey: string | symbol,\n): HumanInTheLoopOptions | undefined {\n  return getMeta<HumanInTheLoopOptions>(HITL_CONFIG, target, propertyKey)\n}\n","/**\n * @Model() — override the LLM model at agent or tool level.\n *\n * Hierarchical resolution via Reflector.getAllAndOverride:\n *   tool @Model > agent @Model > @Agent({ model }) > config default\n *\n * This is a MODEL selector, not a PROVIDER selector. Provider routing\n * (which API key, which endpoint, fallback chains) lives in theo.config.ts\n * as runtime configuration — not in decorators.\n *\n * @example\n * ```ts\n * @Agent({ name: 'support', route: '/support' })\n * @Model('claude-sonnet-4-5-20250929')  // default for all tools\n * class SupportAgent {\n *   @MainLoop()\n *   async run() {}\n * }\n *\n * @Toolbox({ namespace: 'code' })\n * class CodeTools {\n *   @Tool({ name: 'generate', description: 'Generate code', input: z.object({...}) })\n *   @Model('claude-opus-4-6')  // this tool needs the most capable model\n *   async generate() { ... }\n *\n *   @Tool({ name: 'lint', description: 'Lint code', input: z.object({...}) })\n *   // no @Model — inherits from agent level\n *   async lint() { ... }\n * }\n * ```\n */\nimport { createDecorator } from '@theokit/http'\n\n/** Override the LLM model for an agent class or a specific tool method. */\nexport const Model = createDecorator<string>()\n","/**\n * @Artifact() — marks a tool as producing structured output artifacts.\n *\n * Artifacts are SEPARATE from text responses. When a tool produces an artifact\n * (code file, document, diagram, JSON data), the SSE stream emits artifact_start\n * + artifact_chunk events alongside text_delta events.\n *\n * Inspired by assistant-ui's A2AArtifact pattern where artifacts have their own\n * lifecycle (start → chunks → complete) independent of message content.\n *\n * @example\n * ```ts\n * @Toolbox({ namespace: 'code' })\n * class CodeTools {\n *   @Tool({ name: 'generate', description: 'Generate code', input: z.object({...}) })\n *   @Artifact({ mimeType: 'text/typescript', streamable: true })\n *   async generate(input: { spec: string }): Promise<ArtifactResult> {\n *     return {\n *       content: generatedCode,\n *       filename: 'component.tsx',\n *       metadata: { language: 'typescript', loc: 42 },\n *     }\n *   }\n * }\n * ```\n */\nimport { setMeta, getMeta } from '../metadata/index.js'\n\nconst ARTIFACT_CONFIG = Symbol.for('theokit:agents:artifact')\n\nexport interface ArtifactOptions {\n  /** MIME type of the artifact output. */\n  mimeType: string\n  /** Whether the artifact can be streamed in chunks (default: true). */\n  streamable?: boolean\n  /** Maximum size in bytes (0 = no limit). */\n  maxSize?: number\n}\n\n/** Return type for tools decorated with @Artifact. */\nexport interface ArtifactResult {\n  /** The artifact content (string for text, Buffer for binary). */\n  content: string\n  /** Optional filename hint for the client. */\n  filename?: string\n  /** Optional metadata attached to the artifact. */\n  metadata?: Record<string, unknown>\n}\n\nexport function Artifact(options: ArtifactOptions): MethodDecorator {\n  return (target: object, propertyKey: string | symbol) => {\n    const actualTarget = target.constructor\n    setMeta(ARTIFACT_CONFIG, actualTarget, { streamable: true, maxSize: 0, ...options }, propertyKey)\n  }\n}\n\nexport function getArtifactConfig(\n  target: Function,\n  propertyKey: string | symbol,\n): ArtifactOptions | undefined {\n  return getMeta<ArtifactOptions>(ARTIFACT_CONFIG, target, propertyKey)\n}\n","/**\n * @Checkpoint() — enables resumable agent execution from the last successful step.\n *\n * Long-running agents (research, code review, multi-step workflows) can fail\n * partway through. Without checkpointing, users restart from step 1 — wasting\n * tokens, time, and cost.\n *\n * Inspired by tRPC's tracked() + lastEventId pattern and Dapr's actor state\n * checkpointing. The agent persists a recovery point after each successful\n * tool call or iteration, and can resume from that point on retry.\n *\n * @example\n * ```ts\n * @Agent({ name: 'research', route: '/research' })\n * @Checkpoint({\n *   storage: 'drizzle',\n *   strategy: 'after-tool-call',\n *   maxCheckpoints: 20,\n *   ttl: 3_600_000,  // 1h\n * })\n * class ResearchAgent {\n *   @MainLoop({ strategy: 'plan-act-reflect', maxIterations: 15 })\n *   async run() {}\n * }\n *\n * // Resume from checkpoint:\n * // POST /agents/research/chat { resumeToken: 'chk_abc123' }\n * ```\n */\nimport { setMeta, getMeta } from '../metadata/index.js'\n\nconst CHECKPOINT_CONFIG = Symbol.for('theokit:agents:checkpoint')\n\nexport type CheckpointStrategy =\n  | 'after-tool-call'    // checkpoint after every successful tool execution\n  | 'after-iteration'    // checkpoint after every loop iteration\n  | 'manual'             // only checkpoint when explicitly called via ctx.checkpoint()\n\nexport type CheckpointStorage = 'memory' | 'filesystem' | 'drizzle' | 'redis'\n\nexport interface CheckpointOptions {\n  /** Where to persist checkpoints. */\n  storage?: CheckpointStorage\n  /** When to auto-checkpoint (default: 'after-tool-call'). */\n  strategy?: CheckpointStrategy\n  /** Maximum checkpoints to retain per run (rolling window). */\n  maxCheckpoints?: number\n  /** Time-to-live in ms before checkpoints expire (default: 3_600_000 = 1h). */\n  ttl?: number\n}\n\n/** Serializable checkpoint state. */\nexport interface CheckpointState {\n  id: string\n  runId: string\n  agentName: string\n  step: number\n  messages: unknown[]\n  toolResults: unknown[]\n  createdAt: number\n  resumeToken: string\n}\n\nexport function Checkpoint(options: CheckpointOptions = {}): ClassDecorator {\n  return (target: Function) => {\n    setMeta(CHECKPOINT_CONFIG, target, {\n      storage: 'memory',\n      strategy: 'after-tool-call',\n      maxCheckpoints: 10,\n      ttl: 3_600_000,\n      ...options,\n    })\n  }\n}\n\nexport function getCheckpointConfig(target: Function): CheckpointOptions | undefined {\n  return getMeta<CheckpointOptions>(CHECKPOINT_CONFIG, target)\n}\n","/**\n * @Observable() — exposes agent internal state as a real-time stream.\n *\n * Clients subscribe to named observables to monitor agent execution in real-time:\n * token usage, cost, iteration progress, pending approvals, retrieved facts.\n *\n * Inspired by Liveblocks' Presence pattern and tRPC subscriptions. The agent\n * pushes state updates via SSE alongside response events — clients are never\n * \"blind\" during long-running agent operations.\n *\n * @example\n * ```ts\n * @Agent({ name: 'research', route: '/research' })\n * class ResearchAgent {\n *   @MainLoop()\n *   async run() {}\n *\n *   @Observable('metrics')\n *   getMetrics(ctx: AgentContext): AgentMetrics {\n *     return {\n *       tokensUsed: ctx.tokenCount,\n *       costUsd: ctx.costUsd,\n *       iteration: ctx.iteration,\n *       pendingApprovals: ctx.pendingApprovals.length,\n *     }\n *   }\n * }\n *\n * // SSE emits: { type: 'state_update', channel: 'metrics', data: {...} }\n * // Client: eventSource.addEventListener('state_update', handler)\n * ```\n */\nimport { setMeta, getMeta } from '../metadata/index.js'\n\nconst OBSERVABLE_CONFIG = Symbol.for('theokit:agents:observable')\n\nexport interface ObservableEntry {\n  channel: string\n  propertyKey: string | symbol\n}\n\nexport function Observable(channel: string): MethodDecorator {\n  return (target: object, propertyKey: string | symbol) => {\n    const actualTarget = target.constructor\n    const existing = getMeta<ObservableEntry[]>(OBSERVABLE_CONFIG, actualTarget) ?? []\n    setMeta(OBSERVABLE_CONFIG, actualTarget, [...existing, { channel, propertyKey }])\n  }\n}\n\nexport function getObservables(target: Function): ObservableEntry[] {\n  return getMeta<ObservableEntry[]>(OBSERVABLE_CONFIG, target) ?? []\n}\n\nexport function getObservableByChannel(target: Function, channel: string): ObservableEntry | undefined {\n  return getObservables(target).find((o) => o.channel === channel)\n}\n","/**\n * @Sandbox() — declares file/command permission scope for code assistant agents.\n *\n * Controls what the agent can read, write, and execute. The runtime enforces\n * these permissions BEFORE tool execution — a tool that tries to write to a\n * denied path gets a typed error, not a crash.\n *\n * Inspired by Claude Code's permission system (allow/deny per tool + path).\n *\n * @example\n * ```ts\n * @Agent({ name: 'coder', route: '/agents/coder' })\n * @Sandbox({\n *   filesystem: {\n *     read: ['src/**', 'tests/**', 'package.json'],\n *     write: ['src/**', 'tests/**'],\n *     deny: ['node_modules/**', '.env', '*.key'],\n *   },\n *   commands: {\n *     allow: ['npm test', 'tsc --noEmit', 'git diff'],\n *     deny: ['rm -rf', 'git push --force', 'npm publish'],\n *   },\n *   network: false,\n * })\n * class CoderAgent { ... }\n * ```\n */\nimport { resolve } from 'node:path'\n\nimport { setMeta, getMeta } from '../metadata/index.js'\n\nconst SANDBOX_CONFIG = Symbol.for('theokit:agents:sandbox')\n\nexport interface FilesystemPermissions {\n  /** Glob patterns for allowed read paths. */\n  read?: string[]\n  /** Glob patterns for allowed write paths. */\n  write?: string[]\n  /** Glob patterns for DENIED paths (overrides read/write). */\n  deny?: string[]\n}\n\nexport interface CommandPermissions {\n  /** Command prefixes allowed to execute. */\n  allow?: string[]\n  /** Command prefixes denied (overrides allow). */\n  deny?: string[]\n}\n\nexport interface SandboxOptions {\n  /** Filesystem read/write permissions. */\n  filesystem?: FilesystemPermissions\n  /** Shell command execution permissions. */\n  commands?: CommandPermissions\n  /** Allow outbound network from tools (default: true). */\n  network?: boolean\n  /** Maximum execution time per command in ms (default: 120_000). */\n  commandTimeout?: number\n  /** Working directory root (default: process.cwd()). */\n  cwd?: string\n}\n\nexport function Sandbox(options: SandboxOptions): ClassDecorator {\n  return (target: Function) => {\n    setMeta(SANDBOX_CONFIG, target, {\n      network: true,\n      commandTimeout: 120_000,\n      ...options,\n    })\n  }\n}\n\nexport function getSandboxConfig(target: Function): SandboxOptions | undefined {\n  return getMeta<SandboxOptions>(SANDBOX_CONFIG, target)\n}\n\n/**\n * Check if a file path is allowed for the given operation.\n * Deny patterns always win over allow patterns.\n *\n * Security: normalizes paths to prevent traversal (../) and rejects null bytes.\n */\nexport function isPathAllowed(\n  sandbox: SandboxOptions,\n  filePath: string,\n  operation: 'read' | 'write',\n): boolean {\n  // EC-2: null byte injection — reject before any processing\n  if (filePath.includes('\\x00')) return false\n\n  // Path traversal fix: normalize to remove ../ sequences\n  const normalized = resolve('/', filePath).slice(1)\n\n  const fs = sandbox.filesystem\n  if (!fs) return true // no filesystem restrictions\n\n  // Deny always wins\n  if (fs.deny?.some((pattern) => matchGlob(pattern, normalized))) return false\n\n  const allowList = operation === 'read' ? fs.read : fs.write\n  if (!allowList) return true // no explicit allow = allow all (minus deny)\n\n  return allowList.some((pattern) => matchGlob(pattern, normalized))\n}\n\n/**\n * Shell metacharacters that indicate injection attempts.\n * EC-1: includes redirect operators (>, <) and newlines (\\n, \\r).\n */\nconst SHELL_METACHARS = /[;|&$`(){}<>\\n\\r]/\n\n/**\n * Check if a command is allowed to execute.\n * Deny patterns always win. Rejects shell metacharacters.\n *\n * Security: tokenizes command to match binary name, not arbitrary prefix.\n */\nexport function isCommandAllowed(sandbox: SandboxOptions, command: string): boolean {\n  const cmds = sandbox.commands\n  if (!cmds) return true\n\n  // Reject any command with shell metacharacters (injection prevention)\n  if (SHELL_METACHARS.test(command)) return false\n\n  // Extract binary name (first whitespace-delimited token)\n  const binary = command.split(/\\s+/)[0]\n\n  // Deny always wins — check both exact binary match and full command prefix\n  if (cmds.deny?.some((d) => binary === d || command.startsWith(d + ' ') || command === d))\n    return false\n\n  if (!cmds.allow) return true\n\n  // Allow: match exact binary or full command prefix\n  return cmds.allow.some((a) => binary === a || command.startsWith(a + ' ') || command === a)\n}\n\n/**\n * Glob matcher — converts glob pattern to regex at call time.\n * Uses a pre-built RegExp from a sanitized pattern string.\n * Supports *, **, and ? glob characters.\n */\nfunction matchGlob(pattern: string, filePath: string): boolean {\n  // Escape all regex specials except glob chars (* and ?)\n  const escaped = pattern\n    .replace(/[.+^${}()|[\\]\\\\]/g, '\\\\$&')\n    .replace(/\\*\\*/g, '\\0GLOBSTAR\\0')\n    .replace(/\\*/g, '[^/]*')\n    .replace(/\\?/g, '[^/]')\n    .replace(/\\0GLOBSTAR\\0/g, '.*')\n  // Pre-compile regex outside of hot path (pattern is controlled by developer, not user input)\n  const regex = buildGlobRegex(escaped)\n  return regex.test(filePath)\n}\n\n/** Build a regex from a pre-escaped glob pattern string. */\nfunction buildGlobRegex(escapedPattern: string): RegExp {\n  return RegExp(`^${escapedPattern}$`)\n}\n","/**\n * @EditFormat() — declares how a tool outputs file edits.\n *\n * Code assistants show DIFFS, not entire files. This decorator tells the\n * runtime which format the tool produces so the SSE stream emits the\n * correct `file_edit` event type.\n *\n * @example\n * ```ts\n * @Toolbox({ namespace: 'editor' })\n * class EditorTools {\n *   @Tool({ name: 'edit', description: 'Edit file', input: editSchema })\n *   @EditFormat('search-replace')\n *   async edit(input: { file: string; search: string; replace: string }) {\n *     return { file: input.file, search: input.search, replace: input.replace }\n *   }\n *\n *   @Tool({ name: 'write', description: 'Write file', input: writeSchema })\n *   @EditFormat('full-file')\n *   async write(input: { file: string; content: string }) {\n *     return { file: input.file, content: input.content }\n *   }\n * }\n * ```\n */\nimport { createDecorator } from '@theokit/http'\n\nexport type EditFormatType =\n  | 'search-replace'   // { file, search, replace } — Claude Code Edit pattern\n  | 'unified-diff'     // Standard unified diff format\n  | 'full-file'        // Complete file content (Write pattern)\n  | 'line-range'       // { file, startLine, endLine, content }\n\n/** Declare the edit format a tool produces. */\nexport const EditFormat = createDecorator<EditFormatType>()\n","/**\n * applyDecorators() — compose multiple decorators into a single reusable decorator.\n *\n * NestJS-compatible utility. Enables creating \"preset\" decorators that bundle\n * common configurations (auth + throttle + trace + memory + ...) into one decorator.\n *\n * @example\n * ```ts\n * // Create a reusable preset\n * const ProductionAgent = (name: string, route: string) => applyDecorators(\n *   Agent({ name, route, model: 'claude-sonnet-4-5-20250929' }),\n *   UseGuards(AuthGuard, TenantGuard),\n *   Throttle({ limit: 30, ttl: 60_000 }),\n *   Budget({ maxCostUsd: 5.00 }),\n *   Trace(true),\n * )\n *\n * // Apply preset to any agent\n * @ProductionAgent('support', '/api/agents/support')\n * class SupportAgent {\n *   @MainLoop()\n *   async run() {}\n * }\n * ```\n */\n\ntype AnyDecorator = ClassDecorator | MethodDecorator | PropertyDecorator\n\n/**\n * Compose multiple decorators into a single decorator.\n * Works for both class-level and method-level decorators.\n */\nexport function applyDecorators(\n  ...decorators: AnyDecorator[]\n): ClassDecorator & MethodDecorator {\n  return (\n    target: object | Function,\n    propertyKey?: string | symbol,\n    descriptor?: PropertyDescriptor,\n  ) => {\n    for (const decorator of decorators) {\n      if (propertyKey !== undefined && descriptor !== undefined) {\n        // Method-level\n        ;(decorator as MethodDecorator)(target, propertyKey, descriptor)\n      } else {\n        // Class-level\n        ;(decorator as ClassDecorator)(target as Function)\n      }\n    }\n  }\n}\n"],"mappings":"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","names":["MainLoop","options","target","propertyKey","actualTarget","existing","getMeta","AGENT_MAIN_LOOP","console","warn","name","String","meta","strategy","maxIterations","timeoutMs","setMeta","getMainLoop","inferNamespace","className","stripped","replace","toLowerCase","Toolbox","options","target","ns","namespace","name","setMeta","TOOLBOX_CONFIG","Tool","propertyKey","actualTarget","TOOL_CONFIG","existing","getMeta","TOOL_METHODS","getToolboxConfig","getToolMethods","getToolConfig","HOOKS_CONFIG","Symbol","for","Hook","point","target","propertyKey","actualTarget","existing","getMeta","setMeta","getHooks","getHooksByPoint","filter","h","CONVERSATION_CONFIG","Symbol","for","Conversation","options","target","setMeta","storage","maxHistory","compaction","ttl","preserveLastN","getConversationConfig","getMeta","HITL_CONFIG","Symbol","for","HumanInTheLoop","options","target","propertyKey","actualTarget","setMeta","timeout","onTimeout","showInput","getHumanInTheLoopConfig","getMeta","createDecorator","Model","ARTIFACT_CONFIG","Symbol","for","Artifact","options","target","propertyKey","actualTarget","setMeta","streamable","maxSize","getArtifactConfig","getMeta","CHECKPOINT_CONFIG","Symbol","for","Checkpoint","options","target","setMeta","storage","strategy","maxCheckpoints","ttl","getCheckpointConfig","getMeta","OBSERVABLE_CONFIG","Symbol","for","Observable","channel","target","propertyKey","actualTarget","existing","getMeta","setMeta","getObservables","getObservableByChannel","find","o","resolve","SANDBOX_CONFIG","Symbol","for","Sandbox","options","target","setMeta","network","commandTimeout","getSandboxConfig","getMeta","isPathAllowed","sandbox","filePath","operation","includes","normalized","resolve","slice","fs","filesystem","deny","some","pattern","matchGlob","allowList","read","write","SHELL_METACHARS","isCommandAllowed","command","cmds","commands","test","binary","split","d","startsWith","allow","a","escaped","replace","regex","buildGlobRegex","escapedPattern","RegExp","createDecorator","EditFormat","applyDecorators","decorators","target","propertyKey","descriptor","decorator","undefined"]}

package/dist/decorators.d.ts

@@ -1,8 +1,8 @@
-import { A as AgentOptions, d as MainLoopOptions, c as MainLoopMeta, T as ToolOptions, n as ToolboxOptions, B as BudgetOptions, k as PolicyHandler, a as ApprovalOptions } from './mcp-DmtwLSF-.js';
-export { G as Gateway, b as GatewayOptions, M as MCP, e as McpServerConfig, f as McpServersMap, g as Memory, h as MemoryOptions, i as MemoryProvider, j as MemoryScope, P as PlatformName, S as SessionStrategy, l as Skills, m as SkillsOptions, o as getGatewayConfig, p as getMcpConfig, q as getMemoryConfig, r as getSkillsConfig, s as resolveSessionId } from './mcp-DmtwLSF-.js';
+import { A as AgentOptions, f as MainLoopOptions, e as MainLoopMeta, T as ToolOptions, r as ToolboxOptions, B as BudgetOptions, m as PolicyHandler, a as ApprovalOptions } from './skills-DnfvEUSg.js';
+export { C as ContextCompactionStrategy, b as ContextWindow, c as ContextWindowOptions, G as Gateway, d as GatewayOptions, I as IndexStrategy, M as MCP, g as McpServerConfig, h as McpServersMap, i as Memory, j as MemoryOptions, k as MemoryProvider, l as MemoryScope, P as PlatformName, n as ProjectContext, o as ProjectContextOptions, R as RelevanceStrategy, S as SessionStrategy, p as Skills, q as SkillsOptions, 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 'zod';
 
-declare function Agent(options: AgentOptions): ClassDecorator;
+declare function Agent(options?: Partial<AgentOptions>): ClassDecorator;
 declare function getAgentConfig(target: Function): AgentOptions | undefined;
 
 declare function MainLoop(options?: MainLoopOptions): MethodDecorator;
@@ -71,22 +71,6 @@ interface HumanInTheLoopOptions {
 declare function HumanInTheLoop(options: HumanInTheLoopOptions): MethodDecorator;
 declare function getHumanInTheLoopConfig(target: Function, propertyKey: string | symbol): HumanInTheLoopOptions | undefined;
 
-type ContextCompactionStrategy = 'truncate-oldest' | 'summarize-oldest' | 'sliding-window' | 'priority-based';
-interface ContextWindowOptions {
-    /** Maximum tokens before compaction triggers. */
-    maxTokens?: number;
-    /** How to compact when maxTokens is exceeded. */
-    compactionStrategy?: ContextCompactionStrategy;
-    /** Always preserve the system prompt during compaction (default: true). */
-    preserveSystemPrompt?: boolean;
-    /** Number of recent messages to always keep intact (default: 10). */
-    preserveLastN?: number;
-    /** Keep all tool results even during compaction (default: true). */
-    preserveToolResults?: boolean;
-}
-declare function ContextWindow(options?: ContextWindowOptions): ClassDecorator;
-declare function getContextWindowConfig(target: Function): ContextWindowOptions | undefined;
-
 /** Override the LLM model for an agent class or a specific tool method. */
 declare const Model: (value: string) => MethodDecorator & ClassDecorator;
 
@@ -191,25 +175,6 @@ type EditFormatType = 'search-replace' | 'unified-diff' | 'full-file' | 'line-ra
 /** Declare the edit format a tool produces. */
 declare const EditFormat: (value: EditFormatType) => MethodDecorator & ClassDecorator;
 
-type IndexStrategy = 'tree-sitter' | 'regex' | 'none';
-type RelevanceStrategy = 'git-history' | 'import-graph' | 'semantic' | 'manual';
-interface ProjectContextOptions {
-    /** Files that mark the project root (searched upward from cwd). */
-    rootMarkers?: string[];
-    /** How to index the codebase for structural understanding. */
-    indexStrategy?: IndexStrategy;
-    /** Maximum files to include in context per request. */
-    maxFilesInContext?: number;
-    /** How to rank file relevance when selecting context. */
-    relevanceStrategy?: RelevanceStrategy;
-    /** Glob patterns to exclude from indexing and context. */
-    ignorePatterns?: string[];
-    /** File extensions to include in indexing (default: all text files). */
-    includeExtensions?: string[];
-}
-declare function ProjectContext(options?: ProjectContextOptions): ClassDecorator;
-declare function getProjectContextConfig(target: Function): ProjectContextOptions | undefined;
-
 /**
  * applyDecorators() — compose multiple decorators into a single reusable decorator.
  *
@@ -245,4 +210,4 @@ declare function applyDecorators(...decorators: AnyDecorator[]): ClassDecorator
 declare function Mixin(...mixinClasses: Function[]): ClassDecorator;
 declare function getMixins(target: Function): Function[];
 
-export { Agent, AgentOptions, ApprovalOptions, Artifact, type ArtifactOptions, type ArtifactResult, Audit, Budget, BudgetOptions, Checkpoint, type CheckpointOptions, type CheckpointState, type CheckpointStorage, type CheckpointStrategy, type CommandPermissions, type CompactionStrategy, type ContextCompactionStrategy, ContextWindow, type ContextWindowOptions, Conversation, type ConversationOptions, type ConversationStorage, EditFormat, type EditFormatType, type FilesystemPermissions, Hook, type HookEntry, type HookPoint, HumanInTheLoop, type HumanInTheLoopOptions, type IndexStrategy, MainLoop, MainLoopMeta, MainLoopOptions, Mixin, Model, Observable, type ObservableEntry, Policy, PolicyHandler, ProjectContext, type ProjectContextOptions, type RelevanceStrategy, RequiresApproval, RequiresCapability, Sandbox, type SandboxOptions, SubAgents, type TimeoutAction, Tool, ToolOptions, Toolbox, ToolboxOptions, Trace, applyDecorators, getAgentConfig, getArtifactConfig, getCheckpointConfig, getContextWindowConfig, getConversationConfig, getHooks, getHooksByPoint, getHumanInTheLoopConfig, getMainLoop, getMixins, getObservableByChannel, getObservables, getProjectContextConfig, getSandboxConfig, getSubAgents, getToolConfig, getToolMethods, getToolboxConfig, isCommandAllowed, isPathAllowed };
+export { Agent, AgentOptions, ApprovalOptions, Artifact, type ArtifactOptions, type ArtifactResult, Audit, Budget, BudgetOptions, Checkpoint, type CheckpointOptions, type CheckpointState, type CheckpointStorage, type CheckpointStrategy, type CommandPermissions, type CompactionStrategy, Conversation, type ConversationOptions, type ConversationStorage, EditFormat, type EditFormatType, type FilesystemPermissions, Hook, type HookEntry, type HookPoint, HumanInTheLoop, type HumanInTheLoopOptions, MainLoop, MainLoopMeta, MainLoopOptions, Mixin, Model, Observable, type ObservableEntry, Policy, PolicyHandler, RequiresApproval, RequiresCapability, Sandbox, type SandboxOptions, SubAgents, type TimeoutAction, Tool, ToolOptions, Toolbox, ToolboxOptions, Trace, applyDecorators, getAgentConfig, getArtifactConfig, getCheckpointConfig, getConversationConfig, getHooks, getHooksByPoint, getHumanInTheLoopConfig, getMainLoop, getMixins, getObservableByChannel, getObservables, getSandboxConfig, getSubAgents, getToolConfig, getToolMethods, getToolboxConfig, isCommandAllowed, isPathAllowed };

package/dist/decorators.js

@@ -1,7 +1,6 @@
 import {
   Artifact,
   Checkpoint,
-  ContextWindow,
   Conversation,
   EditFormat,
   Hook,
@@ -9,14 +8,12 @@ import {
   MainLoop,
   Model,
   Observable,
-  ProjectContext,
   Sandbox,
   Tool,
   Toolbox,
   applyDecorators,
   getArtifactConfig,
   getCheckpointConfig,
-  getContextWindowConfig,
   getConversationConfig,
   getHooks,
   getHooksByPoint,
@@ -24,37 +21,41 @@ import {
   getMainLoop,
   getObservableByChannel,
   getObservables,
-  getProjectContextConfig,
   getSandboxConfig,
   getToolConfig,
   getToolMethods,
   getToolboxConfig,
   isCommandAllowed,
   isPathAllowed
-} from "./chunk-QNPXMBSH.js";
+} from "./chunk-XWVZS2PQ.js";
 import {
   Agent,
   Audit,
   Budget,
+  ContextWindow,
   Gateway,
   MCP,
   Memory,
   Mixin,
   Policy,
+  ProjectContext,
   RequiresApproval,
   RequiresCapability,
   Skills,
   SubAgents,
   Trace,
   getAgentConfig,
+  getContextWindowConfig,
   getGatewayConfig,
   getMcpConfig,
   getMemoryConfig,
   getMixins,
+  getProjectContextConfig,
   getSkillsConfig,
   getSubAgents,
   resolveSessionId
-} from "./chunk-3LCIXX3T.js";
+} from "./chunk-MVEY7HEY.js";
+import "./chunk-7QVYU63E.js";
 export {
   Agent,
   Artifact,

package/dist/index.d.ts

@@ -1,5 +1,6 @@
-export { Agent, Artifact, ArtifactOptions, ArtifactResult, Audit, Budget, Checkpoint, CheckpointOptions, CheckpointState, CheckpointStorage, CheckpointStrategy, CommandPermissions, CompactionStrategy, ContextCompactionStrategy, ContextWindow, ContextWindowOptions, Conversation, ConversationOptions, ConversationStorage, EditFormat, EditFormatType, FilesystemPermissions, Hook, HookEntry, HookPoint, HumanInTheLoop, HumanInTheLoopOptions, IndexStrategy, MainLoop, Mixin, Model, Observable, ObservableEntry, Policy, ProjectContext, ProjectContextOptions, RelevanceStrategy, RequiresApproval, RequiresCapability, Sandbox, SandboxOptions, SubAgents, TimeoutAction, Tool, Toolbox, Trace, applyDecorators, getAgentConfig, getArtifactConfig, getCheckpointConfig, getContextWindowConfig, getConversationConfig, getHooks, getHooksByPoint, getHumanInTheLoopConfig, getMainLoop, getMixins, getObservableByChannel, getObservables, getProjectContextConfig, getSandboxConfig, getSubAgents, getToolConfig, getToolMethods, getToolboxConfig, isCommandAllowed, isPathAllowed } from './decorators.js';
-export { A as AgentOptions, a as ApprovalOptions, B as BudgetOptions, G as Gateway, b as GatewayOptions, M as MCP, c as MainLoopMeta, d as MainLoopOptions, e as McpServerConfig, f as McpServersMap, g as Memory, h as MemoryOptions, i as MemoryProvider, j as MemoryScope, P as PlatformName, k as PolicyHandler, S as SessionStrategy, l as Skills, m as SkillsOptions, T as ToolOptions, n as ToolboxOptions, o as getGatewayConfig, p as getMcpConfig, q as getMemoryConfig, r as getSkillsConfig, s as resolveSessionId } from './mcp-DmtwLSF-.js';
-export { AgentExecutionContext, AgentManifest, AgentManifestEntry, AgentManifestTool, AgentRoute, AgentRouteContext, AgentRunInfo, AgentStreamEvent, AgentWalkResult, AgentsPluginOptions, ApprovalRequiredEvent, ArtifactChunkEvent, ArtifactStartEvent, BudgetExceededError, CheckpointSavedEvent, CompiledAgentOptions, CompiledTool, DelegateOptions, DelegationError, DelegationResult, DoneEvent, ErrorEvent, FileEditEvent, IterationEvent, RunStartedEvent, StateUpdateEvent, StreamEvent, TextDeltaEvent, ThinkingEvent, ToolCallEvent, ToolResultEvent, ToolWalkResult, ToolboxWalkResult, agentsPlugin, compileAgent, compileTools, createAgentExecutionContext, createRealAgentStream, delegate, generateAgentManifest, generateAgentRoutes, isAgentContext, isApprovalRequired, isDone, isError, isTextDelta, isToolCall, isToolResult, streamAgentResponse, validateUniqueRoutes, walkAgentMetadata } from './bridge.js';
+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';
+export { AgentExecutionContext, AgentManifest, AgentManifestEntry, AgentManifestTool, AgentRoute, AgentRouteContext, AgentRunInfo, AgentStreamEvent, AgentWalkResult, AgentWarningCode, AgentsPluginOptions, ApprovalRequiredEvent, ArtifactChunkEvent, ArtifactStartEvent, BudgetExceededError, CheckpointSavedEvent, CompiledAgentOptions, CompiledContextWindow, CompiledTool, DelegateOptions, DelegationError, DelegationResult, 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';
 import 'zod';
-import '@theokit/http-decorators';
+import '@theokit/http';
+import '@theokit/sdk';

package/dist/index.js

@@ -1,7 +1,6 @@
 import {
   Artifact,
   Checkpoint,
-  ContextWindow,
   Conversation,
   EditFormat,
   Hook,
@@ -9,14 +8,12 @@ import {
   MainLoop,
   Model,
   Observable,
-  ProjectContext,
   Sandbox,
   Tool,
   Toolbox,
   applyDecorators,
   getArtifactConfig,
   getCheckpointConfig,
-  getContextWindowConfig,
   getConversationConfig,
   getHooks,
   getHooksByPoint,
@@ -24,22 +21,25 @@ import {
   getMainLoop,
   getObservableByChannel,
   getObservables,
-  getProjectContextConfig,
   getSandboxConfig,
   getToolConfig,
   getToolMethods,
   getToolboxConfig,
   isCommandAllowed,
   isPathAllowed
-} from "./chunk-QNPXMBSH.js";
+} from "./chunk-XWVZS2PQ.js";
 import {
+  AgentWarningCode,
   BudgetExceededError,
   DelegationError,
   agentsPlugin,
   compileAgent,
+  compileContextWindow,
+  compileProjectContext,
+  compileSkills,
   compileTools,
   createAgentExecutionContext,
-  createRealAgentStream,
+  createSdkAgentStream,
   delegate,
   generateAgentManifest,
   generateAgentRoutes,
@@ -50,35 +50,43 @@ import {
   isTextDelta,
   isToolCall,
   isToolResult,
+  projectContextMetadataOnlyKnobs,
   streamAgentResponse,
+  translateSdkEvent,
   validateUniqueRoutes,
   walkAgentMetadata
-} from "./chunk-SWPOX3LR.js";
+} from "./chunk-2MI27XCA.js";
 import {
   Agent,
   Audit,
   Budget,
+  ContextWindow,
   Gateway,
   MCP,
   Memory,
   Mixin,
   Policy,
+  ProjectContext,
   RequiresApproval,
   RequiresCapability,
   Skills,
   SubAgents,
   Trace,
   getAgentConfig,
+  getContextWindowConfig,
   getGatewayConfig,
   getMcpConfig,
   getMemoryConfig,
   getMixins,
+  getProjectContextConfig,
   getSkillsConfig,
   getSubAgents,
   resolveSessionId
-} from "./chunk-3LCIXX3T.js";
+} from "./chunk-MVEY7HEY.js";
+import "./chunk-7QVYU63E.js";
 export {
   Agent,
+  AgentWarningCode,
   Artifact,
   Audit,
   Budget,
@@ -110,9 +118,12 @@ export {
   agentsPlugin,
   applyDecorators,
   compileAgent,
+  compileContextWindow,
+  compileProjectContext,
+  compileSkills,
   compileTools,
   createAgentExecutionContext,
-  createRealAgentStream,
+  createSdkAgentStream,
   delegate,
   generateAgentManifest,
   generateAgentRoutes,
@@ -147,8 +158,10 @@ export {
   isTextDelta,
   isToolCall,
   isToolResult,
+  projectContextMetadataOnlyKnobs,
   resolveSessionId,
   streamAgentResponse,
+  translateSdkEvent,
   validateUniqueRoutes,
   walkAgentMetadata
 };

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

@@ -1,4 +1,4 @@
-import { ZodTypeAny } from 'zod';
+import { z } from 'zod';
 
 /** Configuration stored by @Agent() decorator. */
 interface AgentOptions {
@@ -45,7 +45,7 @@ interface ToolOptions {
     /** LLM-facing description. */
     description: string;
     /** Zod input schema — compiled to JSON Schema via defineTool(). */
-    input: ZodTypeAny;
+    input: z.ZodType;
     /** Risk level (informational — feeds manifest + UI). */
     risk?: 'low' | 'medium' | 'high';
 }
@@ -66,6 +66,22 @@ type PolicyHandler = (user: {
     roles: string[];
 }) => boolean;
 
+type ContextCompactionStrategy = 'truncate-oldest' | 'summarize-oldest' | 'sliding-window' | 'priority-based';
+interface ContextWindowOptions {
+    /** Maximum tokens before compaction triggers. */
+    maxTokens?: number;
+    /** How to compact when maxTokens is exceeded. */
+    compactionStrategy?: ContextCompactionStrategy;
+    /** Always preserve the system prompt during compaction (default: true). */
+    preserveSystemPrompt?: boolean;
+    /** Number of recent messages to always keep intact (default: 10). */
+    preserveLastN?: number;
+    /** Keep all tool results even during compaction (default: true). */
+    preserveToolResults?: boolean;
+}
+declare function ContextWindow(options?: ContextWindowOptions): ClassDecorator;
+declare function getContextWindowConfig(target: Function): ContextWindowOptions | undefined;
+
 type PlatformName = 'telegram' | 'discord' | 'slack' | 'whatsapp' | 'teams' | 'email' | 'sms' | 'mattermost' | 'line' | 'matrix';
 type SessionStrategy = 'per-user' | 'per-channel' | 'per-thread';
 interface GatewayOptions {
@@ -92,6 +108,20 @@ declare function resolveSessionId(strategy: SessionStrategy, platform: string, s
     topicId?: string;
 }): string;
 
+interface McpServerConfig {
+    /** Command to start the MCP server. */
+    command: string;
+    /** Arguments passed to the command. */
+    args?: string[];
+    /** Environment variables for the server process. */
+    env?: Record<string, string>;
+    /** Working directory for the server process. */
+    cwd?: string;
+}
+type McpServersMap = Record<string, McpServerConfig>;
+declare function MCP(servers: McpServersMap): ClassDecorator;
+declare function getMcpConfig(target: Function): McpServersMap | undefined;
+
 type MemoryProvider = 'built-in' | 'honcho' | 'supermemory' | 'mem0';
 type MemoryScope = 'per-user' | 'per-agent' | 'per-tenant' | 'global';
 interface MemoryOptions {
@@ -109,6 +139,25 @@ interface MemoryOptions {
 declare function Memory(options?: MemoryOptions): ClassDecorator;
 declare function getMemoryConfig(target: Function): MemoryOptions | undefined;
 
+type IndexStrategy = 'tree-sitter' | 'regex' | 'none';
+type RelevanceStrategy = 'git-history' | 'import-graph' | 'semantic' | 'manual';
+interface ProjectContextOptions {
+    /** Files that mark the project root (searched upward from cwd). */
+    rootMarkers?: string[];
+    /** How to index the codebase for structural understanding. */
+    indexStrategy?: IndexStrategy;
+    /** Maximum files to include in context per request. */
+    maxFilesInContext?: number;
+    /** How to rank file relevance when selecting context. */
+    relevanceStrategy?: RelevanceStrategy;
+    /** Glob patterns to exclude from indexing and context. */
+    ignorePatterns?: string[];
+    /** File extensions to include in indexing (default: all text files). */
+    includeExtensions?: string[];
+}
+declare function ProjectContext(options?: ProjectContextOptions): ClassDecorator;
+declare function getProjectContextConfig(target: Function): ProjectContextOptions | undefined;
+
 interface SkillsOptions {
     /** Skill names to include (resolved from .theokit/skills/<name>/SKILL.md). */
     include: string[];
@@ -118,18 +167,4 @@ interface SkillsOptions {
 declare function Skills(namesOrOptions: string[] | SkillsOptions): ClassDecorator;
 declare function getSkillsConfig(target: Function): SkillsOptions | undefined;
 
-interface McpServerConfig {
-    /** Command to start the MCP server. */
-    command: string;
-    /** Arguments passed to the command. */
-    args?: string[];
-    /** Environment variables for the server process. */
-    env?: Record<string, string>;
-    /** Working directory for the server process. */
-    cwd?: string;
-}
-type McpServersMap = Record<string, McpServerConfig>;
-declare function MCP(servers: McpServersMap): ClassDecorator;
-declare function getMcpConfig(target: Function): McpServersMap | undefined;
-
-export { type AgentOptions as A, type BudgetOptions as B, Gateway as G, MCP as M, type PlatformName as P, type SessionStrategy as S, type ToolOptions as T, type ApprovalOptions as a, type GatewayOptions as b, type MainLoopMeta as c, type MainLoopOptions as d, type McpServerConfig as e, type McpServersMap as f, Memory as g, type MemoryOptions as h, type MemoryProvider as i, type MemoryScope as j, type PolicyHandler as k, Skills as l, type SkillsOptions as m, type ToolboxOptions as n, getGatewayConfig as o, getMcpConfig as p, getMemoryConfig as q, getSkillsConfig as r, resolveSessionId as s };
+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 };

package/dist/testing.d.ts

@@ -0,0 +1,47 @@
+/**
+ * createMockAgentStream — test agents without an LLM API key.
+ *
+ * Returns an AsyncIterable that yields typed SSE events in sequence,
+ * simulating an agent conversation. Use in vitest/jest to test agent
+ * wiring, tool call handling, and UI rendering without real LLM costs.
+ *
+ * @example
+ * ```ts
+ * import { createMockAgentStream } from '@theokit/agents/testing'
+ *
+ * const stream = createMockAgentStream({
+ *   responses: [
+ *     { type: 'text', content: 'Here are your tasks:' },
+ *     { type: 'tool_call', name: 'tasks.list', input: {}, output: '[{"id":1}]' },
+ *     { type: 'text', content: 'You have 1 task.' },
+ *   ],
+ * })
+ *
+ * const events = []
+ * for await (const event of stream('hello', 'session-1')) {
+ *   events.push(event)
+ * }
+ * // events: [run_started, text_delta, tool_call, tool_result, text_delta, done]
+ * ```
+ */
+interface MockResponse {
+    type: 'text' | 'tool_call' | 'error';
+    content?: string;
+    name?: string;
+    input?: unknown;
+    output?: string;
+    message?: string;
+}
+interface MockAgentStreamOptions {
+    agentName?: string;
+    responses: MockResponse[];
+    /** Simulated cost in USD (default: 0). */
+    cost?: number;
+}
+interface MockStreamEvent {
+    type: string;
+    [key: string]: unknown;
+}
+declare function createMockAgentStream(opts: MockAgentStreamOptions): (_message: string, _sessionId: string) => AsyncIterable<MockStreamEvent>;
+
+export { type MockAgentStreamOptions, type MockResponse, type MockStreamEvent, createMockAgentStream };

package/dist/testing.js

@@ -0,0 +1,73 @@
+import {
+  __name
+} from "./chunk-7QVYU63E.js";
+
+// src/testing/mock-stream.ts
+function createMockAgentStream(opts) {
+  return (_message, _sessionId) => ({
+    async *[Symbol.asyncIterator]() {
+      await Promise.resolve();
+      const runId = `mock-${Date.now()}`;
+      yield {
+        type: "run_started",
+        runId,
+        agentName: opts.agentName ?? "mock-agent",
+        model: "mock"
+      };
+      let totalTokens = 0;
+      for (const r of opts.responses) {
+        if (r.type === "text" && r.content) {
+          const words = r.content.split(" ");
+          for (const word of words) {
+            yield {
+              type: "text_delta",
+              content: word + " "
+            };
+            totalTokens += 2;
+          }
+        } else if (r.type === "tool_call") {
+          const callId = `tc-${Date.now()}-${crypto.randomUUID().slice(0, 4)}`;
+          yield {
+            type: "tool_call",
+            callId,
+            toolName: r.name ?? "unknown",
+            input: r.input ?? {}
+          };
+          yield {
+            type: "tool_result",
+            callId,
+            toolName: r.name ?? "unknown",
+            output: r.output ?? "",
+            durationMs: 0,
+            isError: false
+          };
+          totalTokens += 10;
+        } else if (r.type === "error") {
+          yield {
+            type: "error",
+            code: "MOCK_ERROR",
+            message: r.message ?? "Mock error",
+            retryable: false
+          };
+          return;
+        }
+      }
+      yield {
+        type: "done",
+        result: opts.responses.filter((r) => r.type === "text").map((r) => r.content).join(" "),
+        usage: {
+          inputTokens: totalTokens,
+          outputTokens: totalTokens,
+          totalTokens: totalTokens * 2
+        },
+        durationMs: 0,
+        cost: opts.cost ?? 0
+      };
+    }
+  });
+}
+__name(createMockAgentStream, "createMockAgentStream");
+export {
+  createMockAgentStream
+};
+//# sourceMappingURL=testing.js.map

package/dist/testing.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/testing/mock-stream.ts"],"sourcesContent":["/**\n * createMockAgentStream — test agents without an LLM API key.\n *\n * Returns an AsyncIterable that yields typed SSE events in sequence,\n * simulating an agent conversation. Use in vitest/jest to test agent\n * wiring, tool call handling, and UI rendering without real LLM costs.\n *\n * @example\n * ```ts\n * import { createMockAgentStream } from '@theokit/agents/testing'\n *\n * const stream = createMockAgentStream({\n *   responses: [\n *     { type: 'text', content: 'Here are your tasks:' },\n *     { type: 'tool_call', name: 'tasks.list', input: {}, output: '[{\"id\":1}]' },\n *     { type: 'text', content: 'You have 1 task.' },\n *   ],\n * })\n *\n * const events = []\n * for await (const event of stream('hello', 'session-1')) {\n *   events.push(event)\n * }\n * // events: [run_started, text_delta, tool_call, tool_result, text_delta, done]\n * ```\n */\n\nexport interface MockResponse {\n  type: 'text' | 'tool_call' | 'error'\n  content?: string\n  name?: string\n  input?: unknown\n  output?: string\n  message?: string\n}\n\nexport interface MockAgentStreamOptions {\n  agentName?: string\n  responses: MockResponse[]\n  /** Simulated cost in USD (default: 0). */\n  cost?: number\n}\n\nexport interface MockStreamEvent {\n  type: string\n  [key: string]: unknown\n}\n\nexport function createMockAgentStream(opts: MockAgentStreamOptions) {\n  return (_message: string, _sessionId: string): AsyncIterable<MockStreamEvent> => ({\n    async *[Symbol.asyncIterator]() {\n      await Promise.resolve() // yield to event loop for async contract\n      const runId = `mock-${Date.now()}`\n      yield { type: 'run_started', runId, agentName: opts.agentName ?? 'mock-agent', model: 'mock' }\n\n      let totalTokens = 0\n      for (const r of opts.responses) {\n        if (r.type === 'text' && r.content) {\n          const words = r.content.split(' ')\n          for (const word of words) {\n            yield { type: 'text_delta', content: word + ' ' }\n            totalTokens += 2\n          }\n        } else if (r.type === 'tool_call') {\n          const callId = `tc-${Date.now()}-${crypto.randomUUID().slice(0, 4)}`\n          yield { type: 'tool_call', callId, toolName: r.name ?? 'unknown', input: r.input ?? {} }\n          yield {\n            type: 'tool_result',\n            callId,\n            toolName: r.name ?? 'unknown',\n            output: r.output ?? '',\n            durationMs: 0,\n            isError: false,\n          }\n          totalTokens += 10\n        } else if (r.type === 'error') {\n          yield {\n            type: 'error',\n            code: 'MOCK_ERROR',\n            message: r.message ?? 'Mock error',\n            retryable: false,\n          }\n          return\n        }\n      }\n\n      yield {\n        type: 'done',\n        result: opts.responses\n          .filter((r) => r.type === 'text')\n          .map((r) => r.content)\n          .join(' '),\n        usage: {\n          inputTokens: totalTokens,\n          outputTokens: totalTokens,\n          totalTokens: totalTokens * 2,\n        },\n        durationMs: 0,\n        cost: opts.cost ?? 0,\n      }\n    },\n  })\n}\n"],"mappings":";;;;;AAgDO,SAASA,sBAAsBC,MAA4B;AAChE,SAAO,CAACC,UAAkBC,gBAAwD;IAChF,QAAQC,OAAOC,aAAa,IAAC;AAC3B,YAAMC,QAAQC,QAAO;AACrB,YAAMC,QAAQ,QAAQC,KAAKC,IAAG,CAAA;AAC9B,YAAM;QAAEC,MAAM;QAAeH;QAAOI,WAAWX,KAAKW,aAAa;QAAcC,OAAO;MAAO;AAE7F,UAAIC,cAAc;AAClB,iBAAWC,KAAKd,KAAKe,WAAW;AAC9B,YAAID,EAAEJ,SAAS,UAAUI,EAAEE,SAAS;AAClC,gBAAMC,QAAQH,EAAEE,QAAQE,MAAM,GAAA;AAC9B,qBAAWC,QAAQF,OAAO;AACxB,kBAAM;cAAEP,MAAM;cAAcM,SAASG,OAAO;YAAI;AAChDN,2BAAe;UACjB;QACF,WAAWC,EAAEJ,SAAS,aAAa;AACjC,gBAAMU,SAAS,MAAMZ,KAAKC,IAAG,CAAA,IAAMY,OAAOC,WAAU,EAAGC,MAAM,GAAG,CAAA,CAAA;AAChE,gBAAM;YAAEb,MAAM;YAAaU;YAAQI,UAAUV,EAAEW,QAAQ;YAAWC,OAAOZ,EAAEY,SAAS,CAAC;UAAE;AACvF,gBAAM;YACJhB,MAAM;YACNU;YACAI,UAAUV,EAAEW,QAAQ;YACpBE,QAAQb,EAAEa,UAAU;YACpBC,YAAY;YACZC,SAAS;UACX;AACAhB,yBAAe;QACjB,WAAWC,EAAEJ,SAAS,SAAS;AAC7B,gBAAM;YACJA,MAAM;YACNoB,MAAM;YACNC,SAASjB,EAAEiB,WAAW;YACtBC,WAAW;UACb;AACA;QACF;MACF;AAEA,YAAM;QACJtB,MAAM;QACNuB,QAAQjC,KAAKe,UACVmB,OAAO,CAACpB,MAAMA,EAAEJ,SAAS,MAAA,EACzByB,IAAI,CAACrB,MAAMA,EAAEE,OAAO,EACpBoB,KAAK,GAAA;QACRC,OAAO;UACLC,aAAazB;UACb0B,cAAc1B;UACdA,aAAaA,cAAc;QAC7B;QACAe,YAAY;QACZY,MAAMxC,KAAKwC,QAAQ;MACrB;IACF;EACF;AACF;AAtDgBzC;","names":["createMockAgentStream","opts","_message","_sessionId","Symbol","asyncIterator","Promise","resolve","runId","Date","now","type","agentName","model","totalTokens","r","responses","content","words","split","word","callId","crypto","randomUUID","slice","toolName","name","input","output","durationMs","isError","code","message","retryable","result","filter","map","join","usage","inputTokens","outputTokens","cost"]}