@cuylabs/agent-core 0.9.0 → 0.10.0

package/dist/messages-BYWGn8TY.d.ts

@@ -1,110 +0,0 @@
-/**
- * Message and token types for @cuylabs/agent-core
- *
- * Defines the message model used across conversations,
- * including all role variants and token usage tracking.
- */
-/**
- * Message roles
- */
-type MessageRole = "user" | "assistant" | "tool" | "system";
-/**
- * Base message interface
- */
-interface MessageBase {
-    id: string;
-    role: MessageRole;
-    createdAt: Date;
-}
-/**
- * User message
- */
-interface UserMessage extends MessageBase {
-    role: "user";
-    content: string;
-    /** Optional custom system prompt for this message */
-    system?: string;
-}
-/**
- * Assistant message
- */
-interface AssistantMessage extends MessageBase {
-    role: "assistant";
-    content: string;
-    /** Finish reason */
-    finish?: "stop" | "length" | "tool-calls" | "content-filter" | "error" | "unknown";
-    /** Token usage for this response */
-    tokens?: TokenUsage;
-    /** Cost in USD */
-    cost?: number;
-    /** Error if any */
-    error?: MessageError;
-    /** Tool calls made by the assistant (when finish === "tool-calls") */
-    toolCalls?: Array<{
-        toolCallId: string;
-        toolName: string;
-        args: unknown;
-    }>;
-}
-/**
- * Tool result message
- */
-interface ToolMessage extends MessageBase {
-    role: "tool";
-    content: string;
-    toolCallId: string;
-    toolName: string;
-    result: unknown;
-    /**
-     * Timestamp when this tool result was compacted/pruned.
-     * Once set, this message won't be pruned again.
-     */
-    compactedAt?: number;
-}
-/**
- * System message
- */
-interface SystemMessage extends MessageBase {
-    role: "system";
-    content: string;
-}
-/**
- * Union of all message types
- */
-type Message = UserMessage | AssistantMessage | ToolMessage | SystemMessage;
-/**
- * Error in a message
- */
-interface MessageError {
-    name: string;
-    message: string;
-    code?: string;
-    status?: number;
-}
-/**
- * Token usage statistics
- */
-interface TokenUsage {
-    inputTokens?: number;
-    outputTokens?: number;
-    totalTokens?: number;
-    /** Cache read tokens (if supported) */
-    cacheReadTokens?: number;
-    /** Cache write tokens (if supported) */
-    cacheWriteTokens?: number;
-}
-/**
- * Session state
- */
-interface Session {
-    id: string;
-    messages: Message[];
-    createdAt: Date;
-    updatedAt: Date;
-    /** Optional title */
-    title?: string;
-    /** Parent session ID for forking */
-    parentID?: string;
-}
-
-export type { AssistantMessage as A, Message as M, Session as S, TokenUsage as T, UserMessage as U, MessageBase as a, MessageError as b, MessageRole as c, SystemMessage as d, ToolMessage as e };

package/dist/presets/index.d.ts

@@ -1,53 +0,0 @@
-import { P as Preset, A as AppliedPreset } from '../types-BlZwmnuW.js';
-import { T as Tool } from '../tool-CZWN3KbO.js';
-import 'ai';
-import '../types-CQaXbRsS.js';
-import 'zod';
-import '../tool-DkhSCV2Y.js';
-import '../types-CHiPh8U2.js';
-import '../types-CQL-SvTn.js';
-
-/**
- * Filter tools using preset allow/deny patterns.
- *
- * Explicit allow matches win over deny matches. This lets presets define a
- * broad deny rule like `"*"` and then carve out a safe allow-list.
- */
-declare function filterTools(tools: Tool.AnyInfo[], options: {
-    allow?: string[];
-    deny?: string[];
-}): Tool.AnyInfo[];
-
-/**
- * Apply a preset to available tools and a parent system prompt.
- */
-declare function applyPreset(preset: Preset, availableTools: Tool.AnyInfo[], baseSystemPrompt?: string): AppliedPreset;
-/**
- * Merge multiple presets. Later presets override earlier scalar values.
- */
-declare function mergePresets(...presets: Preset[]): Preset;
-/**
- * Create a custom preset with sensible defaults.
- */
-declare function createPreset(options: Partial<Preset> & {
-    name: string;
-}): Preset;
-
-declare const explore: Preset;
-declare const plan: Preset;
-declare const review: Preset;
-declare const quick: Preset;
-declare const careful: Preset;
-declare const code: Preset;
-declare const watch: Preset;
-declare const Presets: {
-    readonly explore: Preset;
-    readonly plan: Preset;
-    readonly review: Preset;
-    readonly quick: Preset;
-    readonly careful: Preset;
-    readonly code: Preset;
-    readonly watch: Preset;
-};
-
-export { AppliedPreset, Preset, Presets, applyPreset, careful, code, createPreset, explore, filterTools, mergePresets, plan, quick, review, watch };

package/dist/registry-DwYqsQkX.d.ts

@@ -1,164 +0,0 @@
-import { S as SkillDiscoveryResult, a as SkillMetadata, b as SkillContent, c as SkillResource, d as SkillConfig } from './types-BfNpU8NS.js';
-
-/**
- * Skill Registry — in-memory store for discovered skills
- *
- * The registry is the central coordination point for the skill system.
- * It holds discovered metadata (L1), handles on-demand content loading
- * (L2/L3), provides the prompt summary for injection, and manages
- * the lifecycle of skill state.
- *
- * ```
- *   discoverSkills() → SkillRegistry → promptSummary (L1 → system prompt)
- *                                     → loadSkill()   (L2 → tool response)
- *                                     → loadResource  (L3 → tool response)
- * ```
- *
- * The registry is designed to be created once per agent and shared
- * across the agent's lifetime, including across forked sub-agents.
- *
- * @example
- * ```typescript
- * const registry = await createSkillRegistry("/path/to/project", {
- *   externalDirs: [".agents", ".claude"],
- * });
- *
- * // L1: summary goes into system prompt
- * const summary = registry.formatSummary();
- *
- * // L2: agent calls skill tool → full content loaded
- * const content = await registry.loadContent("testing");
- *
- * // L3: agent reads a bundled reference
- * const ref = await registry.loadResource("testing", "references/patterns.md");
- * ```
- */
-
-/**
- * In-memory registry of discovered skills with lazy content loading.
- *
- * Holds L1 metadata for all skills. Content (L2) and resources (L3)
- * are loaded on demand and cached for the registry's lifetime.
- */
-declare class SkillRegistry {
-    /** All discovered skill metadata indexed by name */
-    private readonly skills;
-    /** Cached full content for skills that have been loaded */
-    private readonly contentCache;
-    /** Discovery metadata */
-    readonly discoveryResult: SkillDiscoveryResult;
-    constructor(discoveryResult: SkillDiscoveryResult);
-    /** Get a skill's metadata by name. Returns undefined if not found. */
-    get(name: string): SkillMetadata | undefined;
-    /** Check if a skill exists by name. */
-    has(name: string): boolean;
-    /** Get all skill metadata entries. */
-    list(): SkillMetadata[];
-    /** Number of registered skills. */
-    get size(): number;
-    /** Skill names as an array. */
-    get names(): string[];
-    /**
-     * Load a skill's full content (L2: body + resource listing).
-     *
-     * Results are cached — subsequent calls return the cached content
-     * without re-reading the filesystem.
-     *
-     * @param name Skill name
-     * @returns Full skill content, or null if the skill doesn't exist
-     */
-    loadContent(name: string): Promise<SkillContent | null>;
-    /**
-     * Load a specific bundled resource from a skill (L3).
-     *
-     * The skill's content must be loaded first (via `loadContent`)
-     * so the resource listing is available.
-     *
-     * @param skillName  Skill name
-     * @param relativePath  Relative path to the resource within the skill dir
-     * @returns Resource file content as UTF-8 string
-     * @throws If the skill or resource doesn't exist
-     */
-    loadResource(skillName: string, relativePath: string): Promise<string>;
-    /**
-     * Get the list of resources for a loaded skill.
-     *
-     * @param name Skill name
-     * @returns Resource list, or empty array if skill isn't loaded yet
-     */
-    getResources(name: string): SkillResource[];
-    /**
-     * Format a summary of all available skills for injection into the system prompt.
-     *
-     * This is the L1 layer — the agent sees names and descriptions of all
-     * available skills, enabling it to decide which to activate via tool calls.
-     *
-     * The output format uses XML tags (consistent with the instruction format
-     * in `formatInstructions`) for clear delineation in the prompt.
-     *
-     * Returns empty string if no skills are available.
-     *
-     * @example Output:
-     * ```xml
-     * <available-skills>
-     *
-     * You have access to the following skills. To activate a skill and load its
-     * full instructions, call the `skill` tool with the skill's name.
-     *
-     * <skill name="testing" scope="project">
-     * Write comprehensive test suites with vitest, covering unit, integration,
-     * and snapshot testing patterns.
-     * </skill>
-     *
-     * <skill name="frontend-design" scope="user">
-     * Create distinctive, production-grade frontend interfaces with high design quality.
-     * </skill>
-     *
-     * </available-skills>
-     * ```
-     */
-    formatSummary(): string;
-    /**
-     * Format the full content of a loaded skill for a tool response.
-     *
-     * Wraps the skill body in XML with metadata, and lists bundled resources
-     * so the agent knows what's available at L3.
-     *
-     * @param content Previously loaded skill content
-     * @returns Formatted string for tool response
-     */
-    formatContent(content: SkillContent): string;
-    /** Clear the content cache, forcing reloads on next access. */
-    clearContentCache(): void;
-    /** Check if a skill's content has been loaded and cached. */
-    isContentLoaded(name: string): boolean;
-}
-/**
- * Create a skill registry by discovering all available skills.
- *
- * This is the recommended way to initialize the skill system.
- * It runs discovery, deduplicates by scope priority, and returns
- * a ready-to-use registry.
- *
- * @param cwd     Current working directory
- * @param config  Skill configuration
- * @returns A populated SkillRegistry
- *
- * @example
- * ```typescript
- * const registry = await createSkillRegistry("/path/to/project", {
- *   externalDirs: [".agents", ".claude"],
- *   roots: ["./company-skills"],
- * });
- *
- * console.log(`Found ${registry.size} skills`);
- * console.log(registry.formatSummary());
- * ```
- */
-declare function createSkillRegistry(cwd: string, config?: SkillConfig): Promise<SkillRegistry>;
-/**
- * Create an empty skill registry (for agents that don't use skills).
- */
-declare function emptySkillRegistry(): SkillRegistry;
-
-export { SkillRegistry as S, createSkillRegistry as c, emptySkillRegistry as e };

package/dist/runner-CI-XeR16.d.ts

@@ -1,91 +0,0 @@
-import { A as AgentMiddleware, M as ModelCallInput, a as ModelCallContext, B as BlockedModelCall, S as StreamChunk, b as ModelCallOutput, T as ToolCallDecision, P as PromptBuildContext, c as PromptSection } from './types-DTSkxakL.js';
-import { A as AgentEvent } from './events-CE72w8W4.js';
-import { T as TokenUsage } from './messages-BYWGn8TY.js';
-import { T as ToolContext } from './tool-DkhSCV2Y.js';
-import { T as Tool } from './tool-CZWN3KbO.js';
-
-/**
- * Middleware Runner
- *
- * Executes middleware hooks in the correct order with proper
- * error handling and short-circuit semantics.
- *
- * This is the internal engine — consumers never see it.
- * They interact with middleware through AgentConfig.middleware.
- */
-
-/**
- * Middleware runner — holds an ordered list of middleware and
- * exposes methods to run each hook type with correct semantics.
- *
- * Immutable after construction. Fork creates a new runner
- * (with inherited + additional middleware).
- */
-declare class MiddlewareRunner {
-    private readonly stack;
-    constructor(middleware?: AgentMiddleware[]);
-    /** Number of registered middleware */
-    get count(): number;
-    /** Whether any middleware is registered */
-    get hasMiddleware(): boolean;
-    /** Get the middleware list (for fork inheritance) */
-    getMiddleware(): readonly AgentMiddleware[];
-    runModelInput(input: ModelCallInput, ctx: ModelCallContext): Promise<ModelCallInput | BlockedModelCall>;
-    runModelChunk(chunk: StreamChunk, ctx: ModelCallContext): Promise<StreamChunk | undefined>;
-    runModelOutput(output: ModelCallOutput, ctx: ModelCallContext): Promise<ModelCallOutput>;
-    /**
-     * Run all `beforeToolCall` hooks in order.
-     *
-     * Returns `{ action: "allow" }` if all middleware allow (or have no hook).
-     * Returns `{ action: "deny", reason }` on first denial — remaining
-     * middleware are skipped.
-     */
-    runBeforeToolCall(tool: string, args: unknown, ctx: ToolContext): Promise<ToolCallDecision>;
-    /**
-     * Run all `afterToolCall` hooks in reverse order.
-     *
-     * Each hook receives the result from the previous hook (or the
-     * original tool result for the first hook). Errors are caught
-     * and logged — the original result passes through.
-     */
-    runAfterToolCall(tool: string, args: unknown, result: Tool.ExecuteResult, ctx: ToolContext): Promise<Tool.ExecuteResult>;
-    /**
-     * Collect prompt sections from all middleware.
-     *
-     * Returns a flat array of sections. Each middleware can return a single
-     * section, an array of sections, or undefined/empty.
-     */
-    collectPromptSections(ctx: PromptBuildContext): PromptSection[];
-    /**
-     * Broadcast an event to all middleware observers.
-     *
-     * Non-blocking — errors are caught and logged. This never
-     * slows down the streaming pipeline.
-     */
-    emitEvent(event: AgentEvent): void;
-    /**
-     * Get the OTel context for a session from the telemetry middleware.
-     * Returns undefined if no telemetry middleware is registered.
-     */
-    getOtelContext(sessionId: string): unknown | undefined;
-    /**
-     * Run all `onChatStart` hooks in order.
-     *
-     * Errors are caught and logged — a broken logger should not
-     * prevent the chat from starting.
-     */
-    runChatStart(sessionId: string, message: string): Promise<void>;
-    /**
-     * Run all `onChatEnd` hooks in order.
-     *
-     * Always called, even when the stream errored. Errors in handlers
-     * are caught and logged.
-     */
-    runChatEnd(sessionId: string, result: {
-        usage?: TokenUsage;
-        error?: Error;
-        output?: string;
-    }): Promise<void>;
-}
-
-export { MiddlewareRunner as M };

package/dist/scope/index.d.ts

@@ -1,10 +0,0 @@
-import { e as ScopeOptions, a as Scope, S as ScopeSnapshot } from '../types-CQL-SvTn.js';
-export { b as ScopeAttributeValue, c as ScopeAttributes, d as ScopeKind } from '../types-CQL-SvTn.js';
-
-declare function currentScope(): Scope | undefined;
-declare function snapshotScope(scope?: Scope | undefined): ScopeSnapshot | undefined;
-declare function createScope(options: ScopeOptions): Scope;
-declare function withinScope<T>(options: ScopeOptions, fn: () => T | Promise<T>): Promise<T>;
-declare function restoreScope<T>(snapshot: ScopeSnapshot | undefined, fn: () => T | Promise<T>): Promise<T>;
-
-export { Scope, ScopeOptions, ScopeSnapshot, createScope, currentScope, restoreScope, snapshotScope, withinScope };

package/dist/scope/index.js

@@ -1,14 +0,0 @@
-import {
-  createScope,
-  currentScope,
-  restoreScope,
-  snapshotScope,
-  withinScope
-} from "../chunk-N7P4PN3O.js";
-export {
-  createScope,
-  currentScope,
-  restoreScope,
-  snapshotScope,
-  withinScope
-};