@theokit/agents 0.1.0-alpha.0

package/dist/decorators.d.ts

@@ -0,0 +1,244 @@
+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 'zod';
+
+declare function Agent(options: AgentOptions): ClassDecorator;
+declare function getAgentConfig(target: Function): AgentOptions | undefined;
+
+declare function MainLoop(options?: MainLoopOptions): MethodDecorator;
+declare function getMainLoop(target: Function): MainLoopMeta | undefined;
+
+declare function Toolbox(options?: ToolboxOptions): ClassDecorator;
+declare function Tool(options: ToolOptions): MethodDecorator;
+declare function getToolboxConfig(target: Function): ToolboxOptions | undefined;
+declare function getToolMethods(target: Function): (string | symbol)[];
+declare function getToolConfig(target: Function, propertyKey: string | symbol): ToolOptions | undefined;
+
+/** Mark a tool as requiring human approval before execution. */
+declare const RequiresApproval: (value: ApprovalOptions) => MethodDecorator & ClassDecorator;
+/** Require specific capabilities (permissions) to execute a tool. */
+declare const RequiresCapability: (value: string[]) => MethodDecorator & ClassDecorator;
+/** Set a cost budget for an agent or tool scope. */
+declare const Budget: (value: BudgetOptions) => MethodDecorator & ClassDecorator;
+/** Attach policy handler functions (CASL-style authorization). */
+declare const Policy: (value: PolicyHandler[]) => MethodDecorator & ClassDecorator;
+
+/** Enable distributed tracing for a tool/toolbox/agent. */
+declare const Trace: (value: boolean) => MethodDecorator & ClassDecorator;
+/** Enable audit logging for a tool/toolbox/agent. */
+declare const Audit: (value: boolean) => MethodDecorator & ClassDecorator;
+
+declare function SubAgents(agentClasses: Function[]): ClassDecorator;
+declare function getSubAgents(target: Function): Function[];
+
+type HookPoint = 'before:llm-call' | 'after:llm-call' | 'before:tool-call' | 'after:tool-call' | 'on:iteration' | 'on:complete' | 'on:error';
+interface HookEntry {
+    point: HookPoint;
+    propertyKey: string | symbol;
+}
+declare function Hook(point: HookPoint): MethodDecorator;
+declare function getHooks(target: Function): HookEntry[];
+declare function getHooksByPoint(target: Function, point: HookPoint): HookEntry[];
+
+type ConversationStorage = 'memory' | 'filesystem' | 'drizzle' | 'redis';
+type CompactionStrategy = 'truncate' | 'summarize' | 'sliding-window';
+interface ConversationOptions {
+    /** Storage backend for conversation history. */
+    storage?: ConversationStorage;
+    /** Maximum messages before compaction triggers (0 = no limit). */
+    maxHistory?: number;
+    /** How to compact when maxHistory is exceeded. */
+    compaction?: CompactionStrategy;
+    /** Time-to-live in milliseconds before conversation expires (0 = never). */
+    ttl?: number;
+    /** Number of recent messages to always preserve during compaction. */
+    preserveLastN?: number;
+}
+declare function Conversation(options?: ConversationOptions): ClassDecorator;
+declare function getConversationConfig(target: Function): ConversationOptions | undefined;
+
+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;
+}
+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;
+
+interface ArtifactOptions {
+    /** MIME type of the artifact output. */
+    mimeType: string;
+    /** Whether the artifact can be streamed in chunks (default: true). */
+    streamable?: boolean;
+    /** Maximum size in bytes (0 = no limit). */
+    maxSize?: number;
+}
+/** Return type for tools decorated with @Artifact. */
+interface ArtifactResult {
+    /** The artifact content (string for text, Buffer for binary). */
+    content: string;
+    /** Optional filename hint for the client. */
+    filename?: string;
+    /** Optional metadata attached to the artifact. */
+    metadata?: Record<string, unknown>;
+}
+declare function Artifact(options: ArtifactOptions): MethodDecorator;
+declare function getArtifactConfig(target: Function, propertyKey: string | symbol): ArtifactOptions | undefined;
+
+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;
+
+interface ObservableEntry {
+    channel: string;
+    propertyKey: string | symbol;
+}
+declare function Observable(channel: string): MethodDecorator;
+declare function getObservables(target: Function): ObservableEntry[];
+declare function getObservableByChannel(target: Function, channel: string): ObservableEntry | undefined;
+
+interface FilesystemPermissions {
+    /** Glob patterns for allowed read paths. */
+    read?: string[];
+    /** Glob patterns for allowed write paths. */
+    write?: string[];
+    /** Glob patterns for DENIED paths (overrides read/write). */
+    deny?: string[];
+}
+interface CommandPermissions {
+    /** Command prefixes allowed to execute. */
+    allow?: string[];
+    /** Command prefixes denied (overrides allow). */
+    deny?: string[];
+}
+interface SandboxOptions {
+    /** Filesystem read/write permissions. */
+    filesystem?: FilesystemPermissions;
+    /** Shell command execution permissions. */
+    commands?: CommandPermissions;
+    /** Allow outbound network from tools (default: true). */
+    network?: boolean;
+    /** Maximum execution time per command in ms (default: 120_000). */
+    commandTimeout?: number;
+    /** Working directory root (default: process.cwd()). */
+    cwd?: string;
+}
+declare function Sandbox(options: SandboxOptions): ClassDecorator;
+declare function getSandboxConfig(target: Function): SandboxOptions | undefined;
+/**
+ * Check if a file path is allowed for the given operation.
+ * Deny patterns always win over allow patterns.
+ */
+declare function isPathAllowed(sandbox: SandboxOptions, filePath: string, operation: 'read' | 'write'): boolean;
+/**
+ * Check if a command is allowed to execute.
+ * Deny patterns always win over allow patterns.
+ */
+declare function isCommandAllowed(sandbox: SandboxOptions, command: string): boolean;
+
+type EditFormatType = 'search-replace' | 'unified-diff' | 'full-file' | 'line-range';
+/** 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.
+ *
+ * NestJS-compatible utility. Enables creating "preset" decorators that bundle
+ * common configurations (auth + throttle + trace + memory + ...) into one decorator.
+ *
+ * @example
+ * ```ts
+ * // Create a reusable preset
+ * const ProductionAgent = (name: string, route: string) => applyDecorators(
+ *   Agent({ name, route, model: 'claude-sonnet-4-5-20250929' }),
+ *   UseGuards(AuthGuard, TenantGuard),
+ *   Throttle({ limit: 30, ttl: 60_000 }),
+ *   Budget({ maxCostUsd: 5.00 }),
+ *   Trace(true),
+ * )
+ *
+ * // Apply preset to any agent
+ * @ProductionAgent('support', '/api/agents/support')
+ * class SupportAgent {
+ *   @MainLoop()
+ *   async run() {}
+ * }
+ * ```
+ */
+type AnyDecorator = ClassDecorator | MethodDecorator | PropertyDecorator;
+/**
+ * Compose multiple decorators into a single decorator.
+ * Works for both class-level and method-level decorators.
+ */
+declare function applyDecorators(...decorators: AnyDecorator[]): ClassDecorator & MethodDecorator;
+
+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 };

package/dist/decorators.js

@@ -0,0 +1,113 @@
+import {
+  Artifact,
+  Checkpoint,
+  ContextWindow,
+  Conversation,
+  EditFormat,
+  Hook,
+  HumanInTheLoop,
+  MainLoop,
+  Model,
+  Observable,
+  ProjectContext,
+  Sandbox,
+  Tool,
+  Toolbox,
+  applyDecorators,
+  getArtifactConfig,
+  getCheckpointConfig,
+  getContextWindowConfig,
+  getConversationConfig,
+  getHooks,
+  getHooksByPoint,
+  getHumanInTheLoopConfig,
+  getMainLoop,
+  getObservableByChannel,
+  getObservables,
+  getProjectContextConfig,
+  getSandboxConfig,
+  getToolConfig,
+  getToolMethods,
+  getToolboxConfig,
+  isCommandAllowed,
+  isPathAllowed
+} from "./chunk-XUACDN32.js";
+import {
+  Agent,
+  Audit,
+  Budget,
+  Gateway,
+  MCP,
+  Memory,
+  Mixin,
+  Policy,
+  RequiresApproval,
+  RequiresCapability,
+  Skills,
+  SubAgents,
+  Trace,
+  getAgentConfig,
+  getGatewayConfig,
+  getMcpConfig,
+  getMemoryConfig,
+  getMixins,
+  getSkillsConfig,
+  getSubAgents,
+  resolveSessionId
+} from "./chunk-3LCIXX3T.js";
+export {
+  Agent,
+  Artifact,
+  Audit,
+  Budget,
+  Checkpoint,
+  ContextWindow,
+  Conversation,
+  EditFormat,
+  Gateway,
+  Hook,
+  HumanInTheLoop,
+  MCP,
+  MainLoop,
+  Memory,
+  Mixin,
+  Model,
+  Observable,
+  Policy,
+  ProjectContext,
+  RequiresApproval,
+  RequiresCapability,
+  Sandbox,
+  Skills,
+  SubAgents,
+  Tool,
+  Toolbox,
+  Trace,
+  applyDecorators,
+  getAgentConfig,
+  getArtifactConfig,
+  getCheckpointConfig,
+  getContextWindowConfig,
+  getConversationConfig,
+  getGatewayConfig,
+  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

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+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, CheckpointSavedEvent, CompiledAgentOptions, CompiledTool, DoneEvent, ErrorEvent, FileEditEvent, IterationEvent, RunStartedEvent, StateUpdateEvent, StreamEvent, TextDeltaEvent, ThinkingEvent, ToolCallEvent, ToolResultEvent, ToolWalkResult, ToolboxWalkResult, agentsPlugin, compileAgent, compileTools, createAgentExecutionContext, generateAgentManifest, generateAgentRoutes, isAgentContext, isApprovalRequired, isDone, isError, isTextDelta, isToolCall, isToolResult, streamAgentResponse, validateUniqueRoutes, walkAgentMetadata } from './bridge.js';
+import 'zod';
+import '@theokit/http-decorators';

package/dist/index.js

@@ -0,0 +1,147 @@
+import {
+  Artifact,
+  Checkpoint,
+  ContextWindow,
+  Conversation,
+  EditFormat,
+  Hook,
+  HumanInTheLoop,
+  MainLoop,
+  Model,
+  Observable,
+  ProjectContext,
+  Sandbox,
+  Tool,
+  Toolbox,
+  applyDecorators,
+  getArtifactConfig,
+  getCheckpointConfig,
+  getContextWindowConfig,
+  getConversationConfig,
+  getHooks,
+  getHooksByPoint,
+  getHumanInTheLoopConfig,
+  getMainLoop,
+  getObservableByChannel,
+  getObservables,
+  getProjectContextConfig,
+  getSandboxConfig,
+  getToolConfig,
+  getToolMethods,
+  getToolboxConfig,
+  isCommandAllowed,
+  isPathAllowed
+} from "./chunk-XUACDN32.js";
+import {
+  agentsPlugin,
+  compileAgent,
+  compileTools,
+  createAgentExecutionContext,
+  generateAgentManifest,
+  generateAgentRoutes,
+  isAgentContext,
+  isApprovalRequired,
+  isDone,
+  isError,
+  isTextDelta,
+  isToolCall,
+  isToolResult,
+  streamAgentResponse,
+  validateUniqueRoutes,
+  walkAgentMetadata
+} from "./chunk-YK76AQNU.js";
+import {
+  Agent,
+  Audit,
+  Budget,
+  Gateway,
+  MCP,
+  Memory,
+  Mixin,
+  Policy,
+  RequiresApproval,
+  RequiresCapability,
+  Skills,
+  SubAgents,
+  Trace,
+  getAgentConfig,
+  getGatewayConfig,
+  getMcpConfig,
+  getMemoryConfig,
+  getMixins,
+  getSkillsConfig,
+  getSubAgents,
+  resolveSessionId
+} from "./chunk-3LCIXX3T.js";
+export {
+  Agent,
+  Artifact,
+  Audit,
+  Budget,
+  Checkpoint,
+  ContextWindow,
+  Conversation,
+  EditFormat,
+  Gateway,
+  Hook,
+  HumanInTheLoop,
+  MCP,
+  MainLoop,
+  Memory,
+  Mixin,
+  Model,
+  Observable,
+  Policy,
+  ProjectContext,
+  RequiresApproval,
+  RequiresCapability,
+  Sandbox,
+  Skills,
+  SubAgents,
+  Tool,
+  Toolbox,
+  Trace,
+  agentsPlugin,
+  applyDecorators,
+  compileAgent,
+  compileTools,
+  createAgentExecutionContext,
+  generateAgentManifest,
+  generateAgentRoutes,
+  getAgentConfig,
+  getArtifactConfig,
+  getCheckpointConfig,
+  getContextWindowConfig,
+  getConversationConfig,
+  getGatewayConfig,
+  getHooks,
+  getHooksByPoint,
+  getHumanInTheLoopConfig,
+  getMainLoop,
+  getMcpConfig,
+  getMemoryConfig,
+  getMixins,
+  getObservableByChannel,
+  getObservables,
+  getProjectContextConfig,
+  getSandboxConfig,
+  getSkillsConfig,
+  getSubAgents,
+  getToolConfig,
+  getToolMethods,
+  getToolboxConfig,
+  isAgentContext,
+  isApprovalRequired,
+  isCommandAllowed,
+  isDone,
+  isError,
+  isPathAllowed,
+  isTextDelta,
+  isToolCall,
+  isToolResult,
+  resolveSessionId,
+  streamAgentResponse,
+  validateUniqueRoutes,
+  walkAgentMetadata
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/mcp-DmtwLSF-.d.ts

@@ -0,0 +1,135 @@
+import { ZodTypeAny } from 'zod';
+
+/** 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;
+    /** 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. */
+    systemPrompt?: string;
+}
+/** 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: ZodTypeAny;
+    /** 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 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 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;
+
+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;
+
+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 };