@theokit/agents 0.46.0 → 1.0.0

package/dist/decorators.d.ts

@@ -1,176 +0,0 @@
-import { A as AgentOptions, f as MainLoopOptions, M as MainLoopMeta, g as ToolOptions, h as ToolboxOptions, B as BudgetOptions, P as PolicyHandler, a as ApprovalOptions, G as Guardrail } from './types-DVA4LQsA.js';
-export { i as Checkpoint, j as CheckpointOptions, k as CheckpointState, l as CheckpointStorage, m as CheckpointStrategy, n as Compaction, o as CompactionDecoratorConfig, p as ContextCompactionStrategy, q as ContextWindow, r as ContextWindowOptions, s as Gateway, t as GatewayOptions, u as HumanInTheLoop, H as HumanInTheLoopOptions, I as IndexStrategy, v as MCP, w as McpServerConfig, x as McpServersMap, y as Memory, z as MemoryOptions, D as MemoryProvider, E as MemoryScope, F as PlatformName, J as ProjectContext, K as ProjectContextOptions, L as RelevanceStrategy, S as SessionStrategy, N as Skills, O as SkillsOptions, T as TimeoutAction, Q as getCheckpointConfig, U as getCompactionConfig, V as getContextWindowConfig, W as getGatewayConfig, X as getHumanInTheLoopConfig, Y as getMcpConfig, Z as getMemoryConfig, _ as getProjectContextConfig, $ as getSkillsConfig, a0 as resolveSessionId } from './types-DVA4LQsA.js';
-import '@theokit/sdk';
-import 'zod';
-
-declare function Agent(options?: Partial<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[];
-
-/**
- * `@Guardrails([...])` — M9 class-decorator surface for input/output guardrails.
- *
- * The functional `defineAgent({ guardrails: [...] })` path already applies guards at the framework
- * boundary (ADR-0040 § D2). This decorator gives the `@Agent` class path the SAME capability: the
- * declared guards compile into `compiled.guardrails` (via `walkAgentMetadata`), so `AgentRunner`
- * applies them identically. Metadata-only (like `@MCP`/`@Skills`) — it describes, the runner runs.
- *
- * @example
- * ```ts
- * @Agent({ name: 'support', route: '/api/agents/support' })
- * @Guardrails([promptInjectionDetector(), piiDetector({ redact: true })])
- * class SupportAgent {}
- * ```
- */
-
-declare function Guardrails(guardrails: readonly Guardrail[]): ClassDecorator;
-declare function getGuardrailsConfig(target: Function): readonly Guardrail[] | undefined;
-
-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[];
-
-/** 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;
-
-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.
- *
- * Security: normalizes paths to prevent traversal (../) and rejects null bytes.
- */
-declare function isPathAllowed(sandbox: SandboxOptions, filePath: string, operation: 'read' | 'write'): boolean;
-/**
- * Check if a command is allowed to execute.
- * Deny patterns always win. Rejects shell metacharacters.
- *
- * Security: tokenizes command to match binary name, not arbitrary prefix.
- */
-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;
-
-/**
- * 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, type CommandPermissions, EditFormat, type EditFormatType, type FilesystemPermissions, Guardrails, Hook, type HookEntry, type HookPoint, MainLoop, MainLoopMeta, MainLoopOptions, Mixin, Model, Observable, type ObservableEntry, Policy, PolicyHandler, RequiresApproval, RequiresCapability, Sandbox, type SandboxOptions, SubAgents, Tool, ToolOptions, Toolbox, ToolboxOptions, Trace, applyDecorators, getAgentConfig, getArtifactConfig, getGuardrailsConfig, getHooks, getHooksByPoint, getMainLoop, getMixins, getObservableByChannel, getObservables, getSandboxConfig, getSubAgents, getToolConfig, getToolMethods, getToolboxConfig, isCommandAllowed, isPathAllowed };

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":"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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","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"]}