@cuylabs/agent-core 0.8.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-BnpEOYV-.js';
-import { T as Tool } from '../tool-BHbyUAy3.js';
-import 'ai';
-import '../types-CQaXbRsS.js';
-import 'zod';
-import '../tool-DLXAR9Ce.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/presets/index.js

@@ -1,28 +0,0 @@
-import {
-  Presets,
-  applyPreset,
-  careful,
-  code,
-  createPreset,
-  explore,
-  filterTools,
-  mergePresets,
-  plan,
-  quick,
-  review,
-  watch
-} from "../chunk-CAA7FHIH.js";
-export {
-  Presets,
-  applyPreset,
-  careful,
-  code,
-  createPreset,
-  explore,
-  filterTools,
-  mergePresets,
-  plan,
-  quick,
-  review,
-  watch
-};

package/dist/reasoning/index.d.ts

@@ -1,116 +0,0 @@
-import { R as ReasoningLevel, a as ReasoningConfig } from '../types-CQaXbRsS.js';
-export { E as EXTENDED_LEVELS, F as FIXED_LEVELS, S as STANDARD_LEVELS, s as shouldIncludeReasoningSummary } from '../types-CQaXbRsS.js';
-import { P as ProviderCompatibility } from '../types-QA4WhEfz.js';
-import { LanguageModel } from 'ai';
-import { ProviderOptions } from '@ai-sdk/provider-utils';
-
-/**
- * Provider-Specific Reasoning Option Builders
- *
- * Each function takes a {@link ReasoningLevel} and returns the
- * provider-options object expected by the Vercel AI SDK's
- * `providerOptions` parameter.
- *
- * Provider key mapping (`getProviderOptionsKey`) is also defined
- * here so that callers can wrap the raw options correctly.
- */
-
-/**
- * Build OpenAI reasoning options.
- *
- * OpenAI reasoning models use:
- * - `reasoningEffort` — controls depth
- * - `reasoningSummary` — controls whether reasoning is streamed
- *   (`"auto"` = condensed summary, `"detailed"` = full)
- *
- * `reasoningSummary` requires a verified OpenAI organisation.
- * Set `CODE_AGENT_DISABLE_REASONING_SUMMARY=true` to skip it.
- */
-declare function buildOpenAIOptions(level: ReasoningLevel, compat?: ProviderCompatibility): Record<string, unknown> | undefined;
-/**
- * Build Anthropic thinking options.
- *
- * Uses `thinking.type: "enabled"` with `budgetTokens`.
- */
-declare function buildAnthropicOptions(level: ReasoningLevel): Record<string, unknown> | undefined;
-/**
- * Build Google / Gemini reasoning options.
- *
- * - **Gemini 3+** uses `thinkingLevel` (`"low"` / `"high"`)
- * - **Gemini 2.5 and earlier** uses `thinkingBudget` (token count)
- */
-declare function buildGoogleOptions(level: ReasoningLevel, modelId?: string): Record<string, unknown> | undefined;
-/**
- * Build xAI / Grok reasoning options.
- */
-declare function buildXAIOptions(level: ReasoningLevel): Record<string, unknown> | undefined;
-/**
- * Build Groq reasoning options.
- */
-declare function buildGroqOptions(level: ReasoningLevel): Record<string, unknown> | undefined;
-/**
- * Build Amazon Bedrock reasoning options.
- *
- * - Anthropic / Claude models use `budgetTokens`
- * - Amazon Nova models use `maxReasoningEffort`
- */
-declare function buildBedrockOptions(level: ReasoningLevel, modelId?: string): Record<string, unknown> | undefined;
-/**
- * Build OpenRouter reasoning options.
- */
-declare function buildOpenRouterOptions(level: ReasoningLevel): Record<string, unknown> | undefined;
-/**
- * Resolve the `providerOptions` key for a given SDK provider string.
- *
- * Falls back to the first dot-segment (e.g. `"foo.bar"` → `"foo"`).
- */
-declare function getProviderOptionsKey(provider: string): string;
-
-/**
- * Reasoning Configuration & Option Builders
- *
- * Orchestrates capability detection and provider-specific option
- * building to produce ready-to-use `providerOptions` for the
- * Vercel AI SDK.
- *
- * Two flavours of every function are provided:
- * - **Async** (`getReasoningConfig`, `buildReasoningOptions`) —
- *   uses the full capability resolver (network + cache).
- * - **Sync** (`getReasoningConfigSync`, `buildReasoningOptionsSync`) —
- *   uses fast pattern-matching only (no network).
- */
-
-/**
- * Get the reasoning configuration for a model.
- *
- * Uses the full capability resolver (including network lookups)
- * for the most accurate result.
- */
-declare function getReasoningConfig(model: LanguageModel): Promise<ReasoningConfig>;
-/**
- * Synchronous reasoning config using pattern-matching only.
- *
- * Faster but less accurate than {@link getReasoningConfig}.
- * Good for hot paths where async is impractical.
- */
-declare function getReasoningConfigSync(model: LanguageModel): ReasoningConfig;
-/**
- * Build `providerOptions` for a reasoning level (async).
- *
- * Returns `undefined` when reasoning is off or unsupported.
- */
-declare function buildReasoningOptions(model: LanguageModel, level: ReasoningLevel): Promise<ProviderOptions | undefined>;
-/**
- * Build `providerOptions` for a reasoning level (sync / pattern-only).
- */
-declare function buildReasoningOptionsSync(model: LanguageModel, level: ReasoningLevel): ProviderOptions | undefined;
-/**
- * Check whether a model supports reasoning (async, full resolver).
- */
-declare function supportsReasoning(model: LanguageModel): Promise<boolean>;
-/**
- * Synchronous check using pattern-matching only.
- */
-declare function supportsReasoningSync(model: LanguageModel): boolean;
-
-export { ReasoningConfig, ReasoningLevel, buildAnthropicOptions, buildBedrockOptions, buildGoogleOptions, buildGroqOptions, buildOpenAIOptions, buildOpenRouterOptions, buildReasoningOptions, buildReasoningOptionsSync, buildXAIOptions, getProviderOptionsKey, getReasoningConfig, getReasoningConfigSync, supportsReasoning, supportsReasoningSync };

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 };