@cuylabs/agent-core 0.3.0 → 0.5.0

package/dist/mcp/index.d.ts

@@ -0,0 +1,26 @@
+import { M as MCPConfig, a as MCPManager, d as MCPServerConfig, H as HttpTransportConfig, S as SseTransportConfig, f as StdioTransportConfig } from '../types-VQgymC1N.js';
+export { b as MCPPrompt, c as MCPResource, e as MCPServerStatus } from '../types-VQgymC1N.js';
+import 'ai';
+
+/**
+ * Create an MCP manager for connecting to multiple MCP servers.
+ */
+declare function createMCPManager(config: MCPConfig): MCPManager;
+/**
+ * Helper to define a single MCP server config.
+ */
+declare function defineServer(config: MCPServerConfig): MCPServerConfig;
+/**
+ * Helper to create a stdio server config.
+ */
+declare function stdioServer(command: string, args?: string[], options?: Omit<StdioTransportConfig, "transport" | "command" | "args">): StdioTransportConfig;
+/**
+ * Helper to create an HTTP server config.
+ */
+declare function httpServer(url: string, options?: Omit<HttpTransportConfig, "transport" | "url">): HttpTransportConfig;
+/**
+ * Helper to create an SSE server config.
+ */
+declare function sseServer(url: string, options?: Omit<SseTransportConfig, "transport" | "url">): SseTransportConfig;
+
+export { HttpTransportConfig, MCPConfig, MCPManager, MCPServerConfig, SseTransportConfig, StdioTransportConfig, createMCPManager, defineServer, httpServer, sseServer, stdioServer };

package/dist/mcp/index.js

@@ -0,0 +1,14 @@
+import {
+  createMCPManager,
+  defineServer,
+  httpServer,
+  sseServer,
+  stdioServer
+} from "../chunk-ZXAKHMWH.js";
+export {
+  createMCPManager,
+  defineServer,
+  httpServer,
+  sseServer,
+  stdioServer
+};

package/dist/messages-BYWGn8TY.d.ts

@@ -0,0 +1,110 @@
+/**
+ * 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/middleware/index.d.ts

@@ -0,0 +1,7 @@
+export { f as AgentMiddleware, M as MiddlewareRunner, T as ToolCallDecision } from '../runner-C7aMP_x3.js';
+export { c as ApprovalMiddlewareConfig, O as OtelMiddlewareConfig, T as TelemetryConfig, e as TelemetryConfigResult, f as approvalMiddleware, g as createTelemetryConfig, o as otelMiddleware } from '../index-tmhaADz5.js';
+import 'ai';
+import '../messages-BYWGn8TY.js';
+import '../tool-pFAnJc5Y.js';
+import 'zod';
+import '../tool-DYp6-cC3.js';

package/dist/middleware/index.js

@@ -0,0 +1,12 @@
+import {
+  MiddlewareRunner,
+  approvalMiddleware,
+  createTelemetryConfig,
+  otelMiddleware
+} from "../chunk-OTUGSCED.js";
+export {
+  MiddlewareRunner,
+  approvalMiddleware,
+  createTelemetryConfig,
+  otelMiddleware
+};

package/dist/models/index.d.ts

@@ -0,0 +1,33 @@
+export { g as getModelId, a as getProviderId } from '../identifiers-BLUxFqV_.js';
+import { LanguageModel } from 'ai';
+
+type AdapterKind = "openai" | "anthropic" | "google" | "openai-compatible";
+type AdapterSettings = {
+    apiKey?: string;
+    baseUrl?: string;
+    headers?: Record<string, string>;
+    extra?: Record<string, unknown>;
+};
+type EngineSpec = {
+    adapter: AdapterKind | string;
+    settings?: AdapterSettings;
+    build?: (modelId: string, settings: AdapterSettings) => LanguageModel;
+};
+type ModelSpec = {
+    engine: string;
+    id: string;
+    settings?: AdapterSettings;
+};
+type Directory = {
+    engines: Record<string, EngineSpec>;
+    entries?: Record<string, ModelSpec>;
+};
+type Resolver = (key: string) => Promise<LanguageModel>;
+/**
+ * @deprecated Use `Resolver` (async) instead. Kept for backwards compatibility
+ * with custom `build` functions that return synchronously.
+ */
+type SyncResolver = (key: string) => LanguageModel;
+declare function createResolver(directory: Directory): Resolver;
+
+export { type AdapterSettings, type Directory, type EngineSpec, type ModelSpec, type Resolver, type SyncResolver, createResolver };

package/dist/models/index.js

@@ -0,0 +1,12 @@
+import {
+  createResolver
+} from "../chunk-6TDTQJ4P.js";
+import {
+  getModelId,
+  getProviderId
+} from "../chunk-DWYX7ASF.js";
+export {
+  createResolver,
+  getModelId,
+  getProviderId
+};

package/dist/network-D76DS5ot.d.ts

@@ -0,0 +1,5 @@
+import { N as NetworkStatus } from './resolver-DOfZ-xuk.js';
+
+declare function getNetworkStatus(): NetworkStatus;
+
+export { getNetworkStatus as g };

package/dist/prompt/index.d.ts

@@ -0,0 +1,224 @@
+import { c as ModelFamily, E as EnvironmentInfo, I as InstructionFile } from '../runner-C7aMP_x3.js';
+export { a as PromptBuildContext, P as PromptConfig, b as PromptSection } from '../runner-C7aMP_x3.js';
+import { LanguageModel } from 'ai';
+export { P as PromptBuilder, c as createPromptBuilder } from '../builder-RcTZuYnO.js';
+export { d as SkillConfig } from '../tool-pFAnJc5Y.js';
+import '../messages-BYWGn8TY.js';
+import '../tool-DYp6-cC3.js';
+import '../registry-CuRWWtcT.js';
+import 'zod';
+
+/**
+ * Prompt Templates — Base system prompts per model family
+ *
+ * agent-core provides **generic, domain-agnostic** templates.
+ * These establish the agent's general approach and tool-use discipline
+ * without assuming a specific domain (coding, browsing, etc.).
+ *
+ * Domain-specific templates belong in consumer packages:
+ * - agent-code → coding templates ("read files before editing", etc.)
+ * - computer-agent → computer-use templates
+ * - your-custom-agent → whatever you need
+ *
+ * Consumer packages inject their templates via:
+ *   createPromptBuilder({ baseTemplate: MY_CODING_TEMPLATE })
+ *   builder.addSection({ id: "coding", ... })
+ *
+ * This file also contains model family detection, which IS infrastructure
+ * and belongs here — any consumer benefits from knowing the model family
+ * to optimize prompt formatting.
+ */
+
+/**
+ * Detect which model family a LanguageModel belongs to.
+ *
+ * Uses the provider string first (most reliable), then falls back
+ * to pattern matching on the model ID.
+ *
+ * @example
+ * ```typescript
+ * import { anthropic } from "@ai-sdk/anthropic";
+ * detectModelFamily(anthropic("claude-sonnet-4-20250514")); // "anthropic"
+ *
+ * import { openai } from "@ai-sdk/openai";
+ * detectModelFamily(openai("gpt-4o")); // "openai"
+ * ```
+ */
+declare function detectModelFamily(model: LanguageModel): ModelFamily;
+/**
+ * Get the base template for a model family.
+ *
+ * @param family - Model family identifier
+ * @returns The generic system prompt template
+ */
+declare function getTemplate(family: ModelFamily): string;
+/**
+ * Get all available template families.
+ * Useful for debugging or letting users choose.
+ */
+declare function getAvailableFamilies(): ModelFamily[];
+
+/**
+ * Environment Block — Runtime context for the system prompt
+ *
+ * Gathers information about the working environment (cwd, platform,
+ * git status, date, shell) and formats it as a structured block
+ * that gets injected into the prompt at priority 20.
+ *
+ * This gives the model awareness of:
+ * - Where it's working (directory, project)
+ * - What platform it's on (affects path separators, commands)
+ * - Current time (useful for time-sensitive tasks)
+ * - Git state (branch, clean/dirty)
+ */
+
+/**
+ * Gather runtime environment information.
+ *
+ * Collects cwd, platform, git status, date, and shell.
+ * Git commands use a short timeout to avoid hanging on slow repos.
+ *
+ * @param cwd - Working directory to gather info for
+ * @returns Environment info object
+ */
+declare function gatherEnvironment(cwd: string): EnvironmentInfo;
+/**
+ * Format environment info as a prompt-friendly block.
+ *
+ * Output example:
+ * ```
+ * <workspace>
+ * Directory: /Users/dev/my-project
+ * Project: my-project
+ * Platform: macOS (darwin arm64)
+ * Date: Saturday, February 8, 2026
+ * Shell: /bin/zsh
+ * Git: main (clean)
+ * </workspace>
+ * ```
+ */
+declare function formatEnvironment(info: EnvironmentInfo): string;
+/**
+ * Create a short one-line summary of the environment.
+ * Useful for compact contexts or logging.
+ */
+declare function summarizeEnvironment(info: EnvironmentInfo): string;
+
+/**
+ * Instruction File Discovery — Project rules from the filesystem
+ *
+ * Discovers instruction files (AGENTS.md, CLAUDE.md, COPILOT.md, etc.)
+ * by walking up the directory tree from cwd. These files provide
+ * project-specific or workspace-level guidance to the agent.
+ *
+ * Discovery order (general → specific):
+ * 1. Global instruction files (from config)
+ * 2. Workspace-level files (found near git root or higher directories)
+ * 3. Project-level files (found in or near cwd)
+ *
+ * All discovered files are included, ordered from most general to most
+ * specific. This means project-level instructions appear last and
+ * effectively take precedence in case of conflicting guidance.
+ *
+ * Compatible with:
+ * - AGENTS.md convention
+ * - CLAUDE.md convention
+ * - COPILOT.md convention
+ * - CuyLabs' own .cuylabs/instructions.md
+ */
+
+/**
+ * Default file patterns to search for.
+ * Checked in each directory when walking up from cwd.
+ */
+declare const DEFAULT_INSTRUCTION_PATTERNS: string[];
+/**
+ * Maximum file size for instruction files (50KB).
+ * Files larger than this are skipped to prevent prompt bloat.
+ */
+declare const DEFAULT_MAX_FILE_SIZE = 51200;
+/**
+ * Maximum directories to walk up from cwd.
+ */
+declare const DEFAULT_MAX_DEPTH = 10;
+/**
+ * Discover instruction files by walking up the directory tree from cwd.
+ *
+ * Searches for files matching the given patterns in each directory,
+ * starting from `cwd` and walking up to the filesystem root (or until
+ * `maxDepth` is reached).
+ *
+ * Results are ordered from **most general** (shallowest/root-level) to
+ * **most specific** (deepest/cwd-level), so that specific project rules
+ * appear last and take natural precedence.
+ *
+ * @param cwd - Starting directory for the search
+ * @param patterns - File name patterns to look for (e.g. ["AGENTS.md"])
+ * @param options - Discovery options
+ * @returns Array of discovered instruction files, general → specific
+ *
+ * @example
+ * ```typescript
+ * const files = await discoverInstructions("/Users/dev/project/src", [
+ *   "AGENTS.md",
+ *   "CLAUDE.md",
+ * ]);
+ *
+ * // Might find:
+ * // 1. /Users/dev/project/AGENTS.md (depth: 1, workspace)
+ * // 2. /Users/dev/project/src/AGENTS.md (depth: 0, project)
+ * ```
+ */
+declare function discoverInstructions(cwd: string, patterns?: string[], options?: {
+    maxDepth?: number;
+    maxFileSize?: number;
+    stopAtGitRoot?: boolean;
+}): Promise<InstructionFile[]>;
+/**
+ * Load global instruction files from explicit paths.
+ *
+ * Global instructions are always included regardless of cwd.
+ * Useful for organization-wide coding standards or team rules.
+ *
+ * @param paths - Absolute paths to global instruction files
+ * @param maxSize - Maximum file size in bytes
+ * @returns Array of loaded instruction files
+ */
+declare function loadGlobalInstructions(paths: string[], maxSize?: number): Promise<InstructionFile[]>;
+/**
+ * Format discovered instruction files into a prompt block.
+ *
+ * Each file is wrapped in a tagged block with its source path
+ * for transparency. Files are already ordered general → specific.
+ *
+ * Output example:
+ * ```
+ * <project-instructions>
+ *
+ * <instructions source="AGENTS.md" scope="workspace">
+ * ... workspace-level content ...
+ * </instructions>
+ *
+ * <instructions source="src/AGENTS.md" scope="project">
+ * ... project-specific content ...
+ * </instructions>
+ *
+ * </project-instructions>
+ * ```
+ */
+declare function formatInstructions(files: InstructionFile[], basePath?: string): string;
+
+/** Priority for the base template section. */
+declare const PRIORITY_BASE = 10;
+/** Priority for the environment block section. */
+declare const PRIORITY_ENVIRONMENT = 20;
+/** Priority for instruction files. */
+declare const PRIORITY_INSTRUCTIONS = 30;
+/** Priority for custom user-defined sections. */
+declare const PRIORITY_CUSTOM = 50;
+/** Priority for skill summary injection. */
+declare const PRIORITY_SKILLS = 70;
+/** Priority for per-turn override content. */
+declare const PRIORITY_OVERRIDE = 90;
+
+export { DEFAULT_INSTRUCTION_PATTERNS, DEFAULT_MAX_DEPTH, DEFAULT_MAX_FILE_SIZE, EnvironmentInfo, InstructionFile, ModelFamily, PRIORITY_BASE, PRIORITY_CUSTOM, PRIORITY_ENVIRONMENT, PRIORITY_INSTRUCTIONS, PRIORITY_OVERRIDE, PRIORITY_SKILLS, detectModelFamily, discoverInstructions, formatEnvironment, formatInstructions, gatherEnvironment, getAvailableFamilies, getTemplate, loadGlobalInstructions, summarizeEnvironment };

package/dist/prompt/index.js

@@ -0,0 +1,45 @@
+import {
+  DEFAULT_INSTRUCTION_PATTERNS,
+  DEFAULT_MAX_DEPTH,
+  DEFAULT_MAX_FILE_SIZE,
+  PRIORITY_BASE,
+  PRIORITY_CUSTOM,
+  PRIORITY_ENVIRONMENT,
+  PRIORITY_INSTRUCTIONS,
+  PRIORITY_OVERRIDE,
+  PRIORITY_SKILLS,
+  PromptBuilder,
+  createPromptBuilder,
+  detectModelFamily,
+  discoverInstructions,
+  formatEnvironment,
+  formatInstructions,
+  gatherEnvironment,
+  getAvailableFamilies,
+  getTemplate,
+  loadGlobalInstructions,
+  summarizeEnvironment
+} from "../chunk-IVUJDISU.js";
+import "../chunk-LRHOS4ZN.js";
+export {
+  DEFAULT_INSTRUCTION_PATTERNS,
+  DEFAULT_MAX_DEPTH,
+  DEFAULT_MAX_FILE_SIZE,
+  PRIORITY_BASE,
+  PRIORITY_CUSTOM,
+  PRIORITY_ENVIRONMENT,
+  PRIORITY_INSTRUCTIONS,
+  PRIORITY_OVERRIDE,
+  PRIORITY_SKILLS,
+  PromptBuilder,
+  createPromptBuilder,
+  detectModelFamily,
+  discoverInstructions,
+  formatEnvironment,
+  formatInstructions,
+  gatherEnvironment,
+  getAvailableFamilies,
+  getTemplate,
+  loadGlobalInstructions,
+  summarizeEnvironment
+};

package/dist/reasoning/index.d.ts

@@ -0,0 +1,71 @@
+import { R as ReasoningLevel } from '../types-CQaXbRsS.js';
+export { E as EXTENDED_LEVELS, F as FIXED_LEVELS, a as ReasoningConfig, S as STANDARD_LEVELS, s as shouldIncludeReasoningSummary } from '../types-CQaXbRsS.js';
+import { P as ProviderCompatibility } from '../resolver-DOfZ-xuk.js';
+export { e as extractModelId, a as extractProvider } from '../resolver-DOfZ-xuk.js';
+export { b as buildReasoningOptions, a as buildReasoningOptionsSync, g as getReasoningConfig, c as getReasoningConfigSync, s as supportsReasoning, d as supportsReasoningSync } from '../config-D2xeGEHK.js';
+import 'ai';
+import '@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;
+
+export { ReasoningLevel, buildAnthropicOptions, buildBedrockOptions, buildGoogleOptions, buildGroqOptions, buildOpenAIOptions, buildOpenRouterOptions, buildXAIOptions, getProviderOptionsKey };

package/dist/reasoning/index.js

@@ -0,0 +1,47 @@
+import {
+  EXTENDED_LEVELS,
+  FIXED_LEVELS,
+  STANDARD_LEVELS,
+  buildAnthropicOptions,
+  buildBedrockOptions,
+  buildGoogleOptions,
+  buildGroqOptions,
+  buildOpenAIOptions,
+  buildOpenRouterOptions,
+  buildReasoningOptions,
+  buildReasoningOptionsSync,
+  buildXAIOptions,
+  getProviderOptionsKey,
+  getReasoningConfig,
+  getReasoningConfigSync,
+  shouldIncludeReasoningSummary,
+  supportsReasoning,
+  supportsReasoningSync
+} from "../chunk-X635CM2F.js";
+import {
+  extractModelId,
+  extractProvider
+} from "../chunk-QWFMX226.js";
+import "../chunk-DWYX7ASF.js";
+export {
+  EXTENDED_LEVELS,
+  FIXED_LEVELS,
+  STANDARD_LEVELS,
+  buildAnthropicOptions,
+  buildBedrockOptions,
+  buildGoogleOptions,
+  buildGroqOptions,
+  buildOpenAIOptions,
+  buildOpenRouterOptions,
+  buildReasoningOptions,
+  buildReasoningOptionsSync,
+  buildXAIOptions,
+  extractModelId,
+  extractProvider,
+  getProviderOptionsKey,
+  getReasoningConfig,
+  getReasoningConfigSync,
+  shouldIncludeReasoningSummary,
+  supportsReasoning,
+  supportsReasoningSync
+};