@theokit/agents 0.47.0 → 1.0.1

package/dist/decorators.js

@@ -1,308 +0,0 @@
-import {
-  AGENT_MAIN_LOOP,
-  Agent,
-  Audit,
-  Budget,
-  Checkpoint,
-  Compaction,
-  ContextWindow,
-  Gateway,
-  Guardrails,
-  HumanInTheLoop,
-  MCP,
-  Memory,
-  Mixin,
-  Policy,
-  ProjectContext,
-  RequiresApproval,
-  RequiresCapability,
-  Skills,
-  SubAgents,
-  TOOLBOX_CONFIG,
-  TOOL_CONFIG,
-  TOOL_METHODS,
-  Trace,
-  getAgentConfig,
-  getCheckpointConfig,
-  getCompactionConfig,
-  getContextWindowConfig,
-  getGatewayConfig,
-  getGuardrailsConfig,
-  getHumanInTheLoopConfig,
-  getMcpConfig,
-  getMemoryConfig,
-  getMeta,
-  getMixins,
-  getProjectContextConfig,
-  getSkillsConfig,
-  getSubAgents,
-  resolveSessionId,
-  setMeta
-} from "./chunk-NERDIS45.js";
-import {
-  __name
-} from "./chunk-7QVYU63E.js";
-
-// src/decorators/main-loop.ts
-function MainLoop(options = {}) {
-  return (target, propertyKey) => {
-    const actualTarget = target.constructor;
-    const existing = getMeta(AGENT_MAIN_LOOP, actualTarget);
-    if (existing) {
-      console.warn(`[@theokit/agents] ${actualTarget.name}: @MainLoop() already declared on '${String(existing.propertyKey)}'. Overwriting with '${String(propertyKey)}'.`);
-    }
-    const meta = {
-      propertyKey,
-      strategy: options.strategy ?? "simple-chat",
-      maxIterations: options.maxIterations,
-      timeoutMs: options.timeoutMs
-    };
-    setMeta(AGENT_MAIN_LOOP, actualTarget, meta);
-  };
-}
-__name(MainLoop, "MainLoop");
-function getMainLoop(target) {
-  return getMeta(AGENT_MAIN_LOOP, target);
-}
-__name(getMainLoop, "getMainLoop");
-
-// src/decorators/tool.ts
-function inferNamespace(className) {
-  const stripped = className.replace(/Tools$/, "");
-  return stripped.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").toLowerCase();
-}
-__name(inferNamespace, "inferNamespace");
-function Toolbox(options = {}) {
-  return (target) => {
-    const ns = options.namespace ?? inferNamespace(target.name);
-    setMeta(TOOLBOX_CONFIG, target, {
-      ...options,
-      namespace: ns
-    });
-  };
-}
-__name(Toolbox, "Toolbox");
-function Tool(options) {
-  return (target, propertyKey) => {
-    const actualTarget = target.constructor;
-    setMeta(TOOL_CONFIG, actualTarget, options, propertyKey);
-    const existing = getMeta(TOOL_METHODS, actualTarget) ?? [];
-    setMeta(TOOL_METHODS, actualTarget, [
-      ...existing,
-      propertyKey
-    ]);
-  };
-}
-__name(Tool, "Tool");
-function getToolboxConfig(target) {
-  return getMeta(TOOLBOX_CONFIG, target);
-}
-__name(getToolboxConfig, "getToolboxConfig");
-function getToolMethods(target) {
-  return getMeta(TOOL_METHODS, target) ?? [];
-}
-__name(getToolMethods, "getToolMethods");
-function getToolConfig(target, propertyKey) {
-  return getMeta(TOOL_CONFIG, target, propertyKey);
-}
-__name(getToolConfig, "getToolConfig");
-
-// src/decorators/hook.ts
-var HOOKS_CONFIG = /* @__PURE__ */ Symbol.for("theokit:agents:hooks");
-function Hook(point) {
-  return (target, propertyKey) => {
-    const actualTarget = target.constructor;
-    const existing = getMeta(HOOKS_CONFIG, actualTarget) ?? [];
-    setMeta(HOOKS_CONFIG, actualTarget, [
-      ...existing,
-      {
-        point,
-        propertyKey
-      }
-    ]);
-  };
-}
-__name(Hook, "Hook");
-function getHooks(target) {
-  return getMeta(HOOKS_CONFIG, target) ?? [];
-}
-__name(getHooks, "getHooks");
-function getHooksByPoint(target, point) {
-  return getHooks(target).filter((h) => h.point === point);
-}
-__name(getHooksByPoint, "getHooksByPoint");
-
-// src/decorators/model.ts
-import { createDecorator } from "@theokit/http";
-var Model = createDecorator();
-
-// src/decorators/artifact.ts
-var ARTIFACT_CONFIG = /* @__PURE__ */ Symbol.for("theokit:agents:artifact");
-function Artifact(options) {
-  return (target, propertyKey) => {
-    const actualTarget = target.constructor;
-    setMeta(ARTIFACT_CONFIG, actualTarget, {
-      streamable: true,
-      maxSize: 0,
-      ...options
-    }, propertyKey);
-  };
-}
-__name(Artifact, "Artifact");
-function getArtifactConfig(target, propertyKey) {
-  return getMeta(ARTIFACT_CONFIG, target, propertyKey);
-}
-__name(getArtifactConfig, "getArtifactConfig");
-
-// src/decorators/observable.ts
-var OBSERVABLE_CONFIG = /* @__PURE__ */ Symbol.for("theokit:agents:observable");
-function Observable(channel) {
-  return (target, propertyKey) => {
-    const actualTarget = target.constructor;
-    const existing = getMeta(OBSERVABLE_CONFIG, actualTarget) ?? [];
-    setMeta(OBSERVABLE_CONFIG, actualTarget, [
-      ...existing,
-      {
-        channel,
-        propertyKey
-      }
-    ]);
-  };
-}
-__name(Observable, "Observable");
-function getObservables(target) {
-  return getMeta(OBSERVABLE_CONFIG, target) ?? [];
-}
-__name(getObservables, "getObservables");
-function getObservableByChannel(target, channel) {
-  return getObservables(target).find((o) => o.channel === channel);
-}
-__name(getObservableByChannel, "getObservableByChannel");
-
-// src/decorators/sandbox.ts
-import { resolve } from "path";
-var SANDBOX_CONFIG = /* @__PURE__ */ Symbol.for("theokit:agents:sandbox");
-function Sandbox(options) {
-  return (target) => {
-    setMeta(SANDBOX_CONFIG, target, {
-      network: true,
-      commandTimeout: 12e4,
-      ...options
-    });
-  };
-}
-__name(Sandbox, "Sandbox");
-function getSandboxConfig(target) {
-  return getMeta(SANDBOX_CONFIG, target);
-}
-__name(getSandboxConfig, "getSandboxConfig");
-function isPathAllowed(sandbox, filePath, operation) {
-  if (filePath.includes("\0")) return false;
-  const normalized = resolve("/", filePath).slice(1);
-  const fs = sandbox.filesystem;
-  if (!fs) return true;
-  if (fs.deny?.some((pattern) => matchGlob(pattern, normalized))) return false;
-  const allowList = operation === "read" ? fs.read : fs.write;
-  if (!allowList) return true;
-  return allowList.some((pattern) => matchGlob(pattern, normalized));
-}
-__name(isPathAllowed, "isPathAllowed");
-var SHELL_METACHARS = /[;|&$`(){}<>\n\r]/;
-function isCommandAllowed(sandbox, command) {
-  const cmds = sandbox.commands;
-  if (!cmds) return true;
-  if (SHELL_METACHARS.test(command)) return false;
-  const binary = command.split(/\s+/)[0];
-  if (cmds.deny?.some((d) => binary === d || command.startsWith(d + " ") || command === d)) return false;
-  if (!cmds.allow) return true;
-  return cmds.allow.some((a) => binary === a || command.startsWith(a + " ") || command === a);
-}
-__name(isCommandAllowed, "isCommandAllowed");
-function matchGlob(pattern, filePath) {
-  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "\0GLOBSTAR\0").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/\0GLOBSTAR\0/g, ".*");
-  const regex = buildGlobRegex(escaped);
-  return regex.test(filePath);
-}
-__name(matchGlob, "matchGlob");
-function buildGlobRegex(escapedPattern) {
-  return RegExp(`^${escapedPattern}$`);
-}
-__name(buildGlobRegex, "buildGlobRegex");
-
-// src/decorators/edit-format.ts
-import { createDecorator as createDecorator2 } from "@theokit/http";
-var EditFormat = createDecorator2();
-
-// src/decorators/apply-decorators.ts
-function applyDecorators(...decorators) {
-  return (target, propertyKey, descriptor) => {
-    for (const decorator of decorators) {
-      if (propertyKey !== void 0 && descriptor !== void 0) {
-        ;
-        decorator(target, propertyKey, descriptor);
-      } else {
-        ;
-        decorator(target);
-      }
-    }
-  };
-}
-__name(applyDecorators, "applyDecorators");
-export {
-  Agent,
-  Artifact,
-  Audit,
-  Budget,
-  Checkpoint,
-  Compaction,
-  ContextWindow,
-  EditFormat,
-  Gateway,
-  Guardrails,
-  Hook,
-  HumanInTheLoop,
-  MCP,
-  MainLoop,
-  Memory,
-  Mixin,
-  Model,
-  Observable,
-  Policy,
-  ProjectContext,
-  RequiresApproval,
-  RequiresCapability,
-  Sandbox,
-  Skills,
-  SubAgents,
-  Tool,
-  Toolbox,
-  Trace,
-  applyDecorators,
-  getAgentConfig,
-  getArtifactConfig,
-  getCheckpointConfig,
-  getCompactionConfig,
-  getContextWindowConfig,
-  getGatewayConfig,
-  getGuardrailsConfig,
-  getHooks,
-  getHooksByPoint,
-  getHumanInTheLoopConfig,
-  getMainLoop,
-  getMcpConfig,
-  getMemoryConfig,
-  getMixins,
-  getObservableByChannel,
-  getObservables,
-  getProjectContextConfig,
-  getSandboxConfig,
-  getSkillsConfig,
-  getSubAgents,
-  getToolConfig,
-  getToolMethods,
-  getToolboxConfig,
-  isCommandAllowed,
-  isPathAllowed,
-  resolveSessionId
-};
-//# sourceMappingURL=decorators.js.map

package/dist/decorators.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/decorators/main-loop.ts","../src/decorators/tool.ts","../src/decorators/hook.ts","../src/decorators/model.ts","../src/decorators/artifact.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 * @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 * @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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAQO,SAASA,SAASC,UAA2B,CAAC,GAAC;AACpD,SAAO,CAACC,QAAgBC,gBAAAA;AACtB,UAAMC,eAAeF,OAAO;AAC5B,UAAMG,WAAWC,QAAsBC,iBAAiBH,YAAAA;AACxD,QAAIC,UAAU;AACZG,cAAQC,KACN,qBAAqBL,aAAaM,IAAI,sCAAsCC,OAAON,SAASF,WAAW,CAAA,wBAAyBQ,OAAOR,WAAAA,CAAAA,IAAgB;IAE3J;AACA,UAAMS,OAAqB;MACzBT;MACAU,UAAUZ,QAAQY,YAAY;MAC9BC,eAAeb,QAAQa;MACvBC,WAAWd,QAAQc;IACrB;AACAC,YAAQT,iBAAiBH,cAAcQ,IAAAA;EACzC;AACF;AAjBgBZ;AAmBT,SAASiB,YAAYf,QAAgB;AAC1C,SAAOI,QAAsBC,iBAAiBL,MAAAA;AAChD;AAFgBe;;;ACZhB,SAASC,eAAeC,WAAiB;AACvC,QAAMC,WAAWD,UAAUE,QAAQ,UAAU,EAAA;AAC7C,SAAOD,SACJC,QAAQ,sBAAsB,OAAA,EAC9BA,QAAQ,wBAAwB,OAAA,EAChCC,YAAW;AAChB;AANSJ;AAQF,SAASK,QAAQC,UAA0B,CAAC,GAAC;AAClD,SAAO,CAACC,WAAAA;AACN,UAAMC,KAAKF,QAAQG,aAAaT,eAAeO,OAAOG,IAAI;AAC1DC,YAAQC,gBAAgBL,QAAQ;MAAE,GAAGD;MAASG,WAAWD;IAAG,CAAA;EAC9D;AACF;AALgBH;AAOT,SAASQ,KAAKP,SAAoB;AACvC,SAAO,CAACC,QAAgBO,gBAAAA;AACtB,UAAMC,eAAeR,OAAO;AAC5BI,YAAQK,aAAaD,cAAcT,SAASQ,WAAAA;AAE5C,UAAMG,WAAWC,QAA6BC,cAAcJ,YAAAA,KAAiB,CAAA;AAC7EJ,YAAQQ,cAAcJ,cAAc;SAAIE;MAAUH;KAAY;EAChE;AACF;AARgBD;AAUT,SAASO,iBAAiBb,QAAgB;AAC/C,SAAOW,QAAwBN,gBAAgBL,MAAAA;AACjD;AAFgBa;AAIT,SAASC,eAAed,QAAgB;AAC7C,SAAOW,QAA6BC,cAAcZ,MAAAA,KAAW,CAAA;AAC/D;AAFgBc;AAIT,SAASC,cACdf,QACAO,aAA4B;AAE5B,SAAOI,QAAqBF,aAAaT,QAAQO,WAAAA;AACnD;AALgBQ;;;ACZhB,IAAMC,eAAeC,uBAAOC,IAAI,sBAAA;AAgBzB,SAASC,KAAKC,OAAgB;AACnC,SAAO,CAACC,QAAgBC,gBAAAA;AACtB,UAAMC,eAAeF,OAAO;AAC5B,UAAMG,WAAWC,QAAqBT,cAAcO,YAAAA,KAAiB,CAAA;AACrEG,YAAQV,cAAcO,cAAc;SAAIC;MAAU;QAAEJ;QAAOE;MAAY;KAAE;EAC3E;AACF;AANgBH;AAQT,SAASQ,SAASN,QAAgB;AACvC,SAAOI,QAAqBT,cAAcK,MAAAA,KAAW,CAAA;AACvD;AAFgBM;AAIT,SAASC,gBAAgBP,QAAkBD,OAAgB;AAChE,SAAOO,SAASN,MAAAA,EAAQQ,OAAO,CAACC,MAAMA,EAAEV,UAAUA,KAAAA;AACpD;AAFgBQ;;;ACjChB,SAASG,uBAAuB;AAGzB,IAAMC,QAAQD,gBAAAA;;;ACNrB,IAAME,kBAAkBC,uBAAOC,IAAI,yBAAA;AAqB5B,SAASC,SAASC,SAAwB;AAC/C,SAAO,CAACC,QAAgBC,gBAAAA;AACtB,UAAMC,eAAeF,OAAO;AAC5BG,YAAQR,iBAAiBO,cAAc;MAAEE,YAAY;MAAMC,SAAS;MAAG,GAAGN;IAAQ,GAAGE,WAAAA;EACvF;AACF;AALgBH;AAOT,SAASQ,kBACdN,QACAC,aAA4B;AAE5B,SAAOM,QAAyBZ,iBAAiBK,QAAQC,WAAAA;AAC3D;AALgBK;;;ACtBhB,IAAME,oBAAoBC,uBAAOC,IAAI,2BAAA;AAO9B,SAASC,WAAWC,SAAe;AACxC,SAAO,CAACC,QAAgBC,gBAAAA;AACtB,UAAMC,eAAeF,OAAO;AAC5B,UAAMG,WAAWC,QAA2BT,mBAAmBO,YAAAA,KAAiB,CAAA;AAChFG,YAAQV,mBAAmBO,cAAc;SAAIC;MAAU;QAAEJ;QAASE;MAAY;KAAE;EAClF;AACF;AANgBH;AAQT,SAASQ,eAAeN,QAAgB;AAC7C,SAAOI,QAA2BT,mBAAmBK,MAAAA,KAAW,CAAA;AAClE;AAFgBM;AAIT,SAASC,uBAAuBP,QAAkBD,SAAe;AACtE,SAAOO,eAAeN,MAAAA,EAAQQ,KAAK,CAACC,MAAMA,EAAEV,YAAYA,OAAAA;AAC1D;AAFgBQ;;;AC1BhB,SAASG,eAAe;AAIxB,IAAMC,iBAAiBC,uBAAOC,IAAI,wBAAA;AA+B3B,SAASC,QAAQC,SAAuB;AAC7C,SAAO,CAACC,WAAAA;AACNC,YAAQN,gBAAgBK,QAAQ;MAC9BE,SAAS;MACTC,gBAAgB;MAChB,GAAGJ;IACL,CAAA;EACF;AACF;AARgBD;AAUT,SAASM,iBAAiBJ,QAAgB;AAC/C,SAAOK,QAAwBV,gBAAgBK,MAAAA;AACjD;AAFgBI;AAUT,SAASE,cACdC,SACAC,UACAC,WAA2B;AAG3B,MAAID,SAASE,SAAS,IAAA,EAAS,QAAO;AAGtC,QAAMC,aAAaC,QAAQ,KAAKJ,QAAAA,EAAUK,MAAM,CAAA;AAEhD,QAAMC,KAAKP,QAAQQ;AACnB,MAAI,CAACD,GAAI,QAAO;AAGhB,MAAIA,GAAGE,MAAMC,KAAK,CAACC,YAAYC,UAAUD,SAASP,UAAAA,CAAAA,EAAc,QAAO;AAEvE,QAAMS,YAAYX,cAAc,SAASK,GAAGO,OAAOP,GAAGQ;AACtD,MAAI,CAACF,UAAW,QAAO;AAEvB,SAAOA,UAAUH,KAAK,CAACC,YAAYC,UAAUD,SAASP,UAAAA,CAAAA;AACxD;AArBgBL;AA2BhB,IAAMiB,kBAAkB;AAQjB,SAASC,iBAAiBjB,SAAyBkB,SAAe;AACvE,QAAMC,OAAOnB,QAAQoB;AACrB,MAAI,CAACD,KAAM,QAAO;AAGlB,MAAIH,gBAAgBK,KAAKH,OAAAA,EAAU,QAAO;AAG1C,QAAMI,SAASJ,QAAQK,MAAM,KAAA,EAAO,CAAA;AAGpC,MAAIJ,KAAKV,MAAMC,KAAK,CAACc,MAAMF,WAAWE,KAAKN,QAAQO,WAAWD,IAAI,GAAA,KAAQN,YAAYM,CAAAA,EACpF,QAAO;AAET,MAAI,CAACL,KAAKO,MAAO,QAAO;AAGxB,SAAOP,KAAKO,MAAMhB,KAAK,CAACiB,MAAML,WAAWK,KAAKT,QAAQO,WAAWE,IAAI,GAAA,KAAQT,YAAYS,CAAAA;AAC3F;AAlBgBV;AAyBhB,SAASL,UAAUD,SAAiBV,UAAgB;AAElD,QAAM2B,UAAUjB,QACbkB,QAAQ,qBAAqB,MAAA,EAC7BA,QAAQ,SAAS,cAAA,EACjBA,QAAQ,OAAO,OAAA,EACfA,QAAQ,OAAO,MAAA,EACfA,QAAQ,iBAAiB,IAAA;AAE5B,QAAMC,QAAQC,eAAeH,OAAAA;AAC7B,SAAOE,MAAMT,KAAKpB,QAAAA;AACpB;AAXSW;AAcT,SAASmB,eAAeC,gBAAsB;AAC5C,SAAOC,OAAO,IAAID,cAAAA,GAAiB;AACrC;AAFSD;;;ACnIT,SAASG,mBAAAA,wBAAuB;AASzB,IAAMC,aAAaD,iBAAAA;;;ACFnB,SAASE,mBACXC,YAA0B;AAE7B,SAAO,CACLC,QACAC,aACAC,eAAAA;AAEA,eAAWC,aAAaJ,YAAY;AAClC,UAAIE,gBAAgBG,UAAaF,eAAeE,QAAW;;AAEvDD,kBAA8BH,QAAQC,aAAaC,UAAAA;MACvD,OAAO;;AAEHC,kBAA6BH,MAAAA;MACjC;IACF;EACF;AACF;AAlBgBF;","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","createDecorator","Model","ARTIFACT_CONFIG","Symbol","for","Artifact","options","target","propertyKey","actualTarget","setMeta","streamable","maxSize","getArtifactConfig","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/types-DVA4LQsA.d.ts

@@ -1,313 +0,0 @@
-import { SystemPromptResolver } from '@theokit/sdk';
-import { z } from 'zod';
-
-/**
- * Provider-agnostic extended-thinking knob (M1 reasoning-visibility). The common set autocompletes;
- * `(string & {})` accepts provider-specific values forward-compat (mirrors `AgentRunErrorCode`) — the
- * SDK validates the value against the model's catalog. Defined in this leaf module so every layer
- * (`@Agent` config, compiler, runner, sdk-adapter) imports it without an import cycle.
- */
-type ReasoningEffort = 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | (string & {});
-/** Configuration stored by @Agent() decorator. */
-interface AgentOptions {
-    /** Unique agent name (kebab-case). */
-    name: string;
-    /** HTTP route prefix (e.g., '/api/agents/support'). */
-    route: string;
-    /** LLM model identifier (e.g., 'claude-sonnet-4-5-20250929'). */
-    model?: string;
-    /** Extended-thinking effort; mapped to the SDK `ModelSelection.params` so the provider reasons. */
-    reasoningEffort?: ReasoningEffort;
-    /**
-     * Opt-in (default false): convert inline `<think>…</think>` in the text stream into `thinking`
-     * events (M2) — for models that emit reasoning as inline tags (qwen/deepseek) rather than via a
-     * native reasoning param. Off by default since a code assistant may emit literal `<think>` in text.
-     */
-    parseThinkTags?: boolean;
-    /**
-     * Opt-in (default false): strip a leaked Hermes `<function=…></tool_call>` tool-call dialect out of
-     * the visible text (theocode#32) — for models (qwen/qwen3-coder) that intermittently emit tool calls
-     * as text instead of native `tool_calls`. Off by default since a code assistant may emit a literal
-     * `<function=` in answer/code text. Sibling of {@link parseThinkTags}.
-     */
-    stripToolDialect?: boolean;
-    /**
-     * Opt-in (default false): recover a leaked Hermes `<function=…></tool_call>` tool-call dialect so the
-     * call actually EXECUTES (theokit#58 follow-up). Where {@link stripToolDialect} only hides the leaked
-     * block from the visible text, this enables the SDK's `extractToolCallsFromContent` on the chat route,
-     * so a `chat_completions` finish with ZERO native `tool_calls` has its text scanned for the dialect and
-     * any recovered calls are dispatched by the loop. For models (qwen/qwen3-coder via OpenRouter) that
-     * leak tool calls as text. Off by default (a code assistant may print a literal `<function=`); fail-open.
-     * Has effect only when {@link AgentOptions} routes a provider via `providers.routes`. Sibling of
-     * {@link stripToolDialect} — typically enabled together.
-     */
-    recoverLeakedToolCalls?: boolean;
-    /** Enable SSE streaming (default: true). */
-    stream?: boolean;
-    /** Maximum loop iterations before forcing a terminal response. */
-    maxIterations?: number;
-    /** Timeout in milliseconds for the entire agent run. */
-    timeoutMs?: number;
-    /**
-     * System prompt for the agent. Either a static string OR a
-     * {@link SystemPromptResolver} computed per request (V4-L.1, Axis-B) — the SDK
-     * invokes the resolver each send with the run's `SystemPromptContext` (cwd, etc.).
-     */
-    systemPrompt?: string | SystemPromptResolver;
-}
-/** Configuration stored by @MainLoop() decorator. */
-interface MainLoopOptions {
-    /** Execution strategy. */
-    strategy?: 'simple-chat' | 'plan-act-reflect' | 'react';
-    /** Maximum iterations for this loop. */
-    maxIterations?: number;
-    /** Timeout in milliseconds. */
-    timeoutMs?: number;
-}
-/** Internal representation of a resolved @MainLoop. */
-interface MainLoopMeta {
-    propertyKey: string | symbol;
-    strategy: 'simple-chat' | 'plan-act-reflect' | 'react';
-    maxIterations?: number;
-    timeoutMs?: number;
-}
-/** Configuration stored by @Toolbox() decorator. */
-interface ToolboxOptions {
-    /** Namespace prefix for all tools in this toolbox (e.g., 'support'). */
-    namespace?: string;
-}
-/** Configuration stored by @Tool() decorator. */
-interface ToolOptions {
-    /** Tool name (surfaced to LLM). */
-    name: string;
-    /** LLM-facing description. */
-    description: string;
-    /** Zod input schema — compiled to JSON Schema via defineTool(). */
-    input: z.ZodType;
-    /** Risk level (informational — feeds manifest + UI). */
-    risk?: 'low' | 'medium' | 'high';
-}
-/** Budget configuration for @Budget() decorator. */
-interface BudgetOptions {
-    /** Maximum cost in USD for this scope. */
-    maxCostUsd: number;
-    /** Rolling window for budget tracking. */
-    window?: 'daily' | 'monthly';
-}
-/** Approval configuration for @RequiresApproval() decorator. */
-interface ApprovalOptions {
-    /** Reason shown to the approver. */
-    reason: string;
-}
-/** Policy handler function type. */
-type PolicyHandler = (user: {
-    roles: string[];
-}) => boolean;
-
-type CheckpointStrategy = 'after-tool-call' | 'after-iteration' | 'manual';
-type CheckpointStorage = 'memory' | 'filesystem' | 'drizzle' | 'redis';
-interface CheckpointOptions {
-    /** Where to persist checkpoints. */
-    storage?: CheckpointStorage;
-    /** When to auto-checkpoint (default: 'after-tool-call'). */
-    strategy?: CheckpointStrategy;
-    /** Maximum checkpoints to retain per run (rolling window). */
-    maxCheckpoints?: number;
-    /** Time-to-live in ms before checkpoints expire (default: 3_600_000 = 1h). */
-    ttl?: number;
-}
-/** Serializable checkpoint state. */
-interface CheckpointState {
-    id: string;
-    runId: string;
-    agentName: string;
-    step: number;
-    messages: unknown[];
-    toolResults: unknown[];
-    createdAt: number;
-    resumeToken: string;
-}
-declare function Checkpoint(options?: CheckpointOptions): ClassDecorator;
-declare function getCheckpointConfig(target: Function): CheckpointOptions | undefined;
-
-/** 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. */
-    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 {
-    /** Platform adapters this agent supports. */
-    platforms: PlatformName[];
-    /** How to resolve agentId from inbound events (default: 'per-user'). */
-    sessionStrategy?: SessionStrategy;
-    /** Auto-start typing indicator while agent processes (default: true). */
-    typing?: boolean;
-}
-declare function Gateway(options: GatewayOptions): ClassDecorator;
-declare function getGatewayConfig(target: Function): GatewayOptions | undefined;
-/**
- * Resolve a stable agentId from a platform event based on the session strategy.
- *
- * Mirrors @theokit/gateway SessionRouter.defaultStrategy() but is configurable
- * via the @Gateway decorator.
- */
-declare function resolveSessionId(strategy: SessionStrategy, platform: string, sender: {
-    id: string;
-}, channel: {
-    id: string;
-    type: 'dm' | 'group' | 'thread';
-    topicId?: string;
-}): string;
-
-type TimeoutAction = 'abort' | 'proceed' | 'retry';
-interface HumanInTheLoopOptions {
-    /** Question shown to the human approver. */
-    question: string;
-    /** Timeout in milliseconds before onTimeout fires (default: 300_000 = 5 min). */
-    timeout?: number;
-    /** Action when timeout expires (default: 'abort'). */
-    onTimeout?: TimeoutAction;
-    /** Show the tool input to the approver (default: true). */
-    showInput?: boolean;
-    /**
-     * M20 — an optional JSON-schema descriptor of the custom payload the approver may attach (edited
-     * args, a review note). Carried into the `approval_required` event + `GET /approvals` so the UI
-     * knows what to collect. A plain JSON object, not a live Zod schema (keeps the wire serializable).
-     */
-    payloadSchema?: Record<string, unknown>;
-}
-declare function HumanInTheLoop(options: HumanInTheLoopOptions): MethodDecorator;
-declare function getHumanInTheLoopConfig(target: Function, propertyKey: string | symbol): HumanInTheLoopOptions | 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;
-
-type MemoryProvider = 'built-in' | 'honcho' | 'supermemory' | 'mem0';
-type MemoryScope = 'per-user' | 'per-agent' | 'per-tenant' | 'global';
-interface MemoryOptions {
-    /** Memory provider backend. */
-    provider?: MemoryProvider;
-    /** Enable semantic search via embeddings. */
-    embeddings?: boolean;
-    /** Enable full-text search (FTS5). */
-    fts?: boolean;
-    /** Memory isolation scope (default: 'per-user'). */
-    scope?: MemoryScope;
-    /** Maximum facts to retain per scope (0 = unlimited). */
-    maxFacts?: number;
-}
-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[];
-    /** Auto-discover all skills in .theokit/skills/ (default: false). */
-    autoDiscover?: boolean;
-}
-declare function Skills(namesOrOptions: string[] | SkillsOptions): ClassDecorator;
-declare function getSkillsConfig(target: Function): SkillsOptions | undefined;
-
-/**
- * M9 (theokit-ai-first) — guardrail contract + typed errors.
- *
- * ADR-0040 § D2: guardrails are a HOME/BOUNDARY concern (filter user input before the SDK,
- * filter model output before the client). They REUSE the SDK runtime — this module makes zero
- * LLM calls. A guard reports one of three actions; the pipeline (`pipeline.ts`) enforces them.
- */
-/** What a guard decided for a piece of text. */
-type GuardrailAction = 'allow' | 'block' | 'redact';
-/**
- * The result of a single guard check.
- * - `allow`  — text passes untouched.
- * - `block`  — the pipeline throws {@link GuardrailViolationError}; the run stops fail-fast.
- * - `redact` — the pipeline replaces the text with {@link GuardrailResult.text} and continues.
- */
-interface GuardrailResult {
-    action: GuardrailAction;
-    /** Human-readable reason — required in spirit for `block`, surfaced in the thrown error. */
-    reason?: string;
-    /** The transformed text — present (and used) only when `action === 'redact'`. */
-    text?: string;
-}
-/**
- * A guardrail. A guard MAY inspect input (before the model), output (after the model), or both.
- * A guard that omits a phase hook is skipped for that phase.
- */
-interface Guardrail {
-    readonly name: string;
-    checkInput?(text: string): GuardrailResult | Promise<GuardrailResult>;
-    checkOutput?(text: string): GuardrailResult | Promise<GuardrailResult>;
-}
-/** Which boundary phase a violation happened in. */
-type GuardrailPhase = 'input' | 'output';
-/** Thrown (fail-fast) when a guard returns `action: 'block'`. Typed per error-handling.md. */
-declare class GuardrailViolationError extends Error {
-    readonly guardName: string;
-    readonly phase: GuardrailPhase;
-    readonly reason: string;
-    constructor(guardName: string, phase: GuardrailPhase, reason: string);
-}
-/** Thrown when {@link costGuard}'s cumulative token budget is exceeded. */
-declare class CostBudgetExceededError extends Error {
-    readonly usedTokens: number;
-    readonly maxTokens: number;
-    constructor(usedTokens: number, maxTokens: number);
-}
-
-export { getSkillsConfig as $, type AgentOptions as A, type BudgetOptions as B, CostBudgetExceededError as C, type MemoryProvider as D, type MemoryScope as E, type PlatformName as F, type Guardrail as G, type HumanInTheLoopOptions as H, type IndexStrategy as I, ProjectContext as J, type ProjectContextOptions as K, type RelevanceStrategy as L, type MainLoopMeta as M, Skills as N, type SkillsOptions as O, type PolicyHandler as P, getCheckpointConfig as Q, type ReasoningEffort as R, type SessionStrategy as S, type TimeoutAction as T, getCompactionConfig as U, getContextWindowConfig as V, getGatewayConfig as W, getHumanInTheLoopConfig as X, getMcpConfig as Y, getMemoryConfig as Z, getProjectContextConfig as _, type ApprovalOptions as a, resolveSessionId as a0, type GuardrailAction as b, type GuardrailPhase as c, type GuardrailResult as d, GuardrailViolationError as e, type MainLoopOptions as f, type ToolOptions as g, type ToolboxOptions as h, Checkpoint as i, type CheckpointOptions as j, type CheckpointState as k, type CheckpointStorage as l, type CheckpointStrategy as m, Compaction as n, type CompactionDecoratorConfig as o, type ContextCompactionStrategy as p, ContextWindow as q, type ContextWindowOptions as r, Gateway as s, type GatewayOptions as t, HumanInTheLoop as u, MCP as v, type McpServerConfig as w, type McpServersMap as x, Memory as y, type MemoryOptions as z };