@cuylabs/agent-core 0.4.0 → 0.5.0

package/dist/chunk-ZXAKHMWH.js

@@ -0,0 +1,283 @@
+// src/mcp/modules.ts
+var mcpModule;
+var stdioModule;
+async function getMcpSdkModule() {
+  if (!mcpModule) {
+    try {
+      mcpModule = await import("@ai-sdk/mcp");
+    } catch {
+      throw new Error(
+        "MCP support requires @ai-sdk/mcp. Install it with: npm install @ai-sdk/mcp"
+      );
+    }
+  }
+  return mcpModule;
+}
+async function getStdioClientModule() {
+  if (!stdioModule) {
+    try {
+      stdioModule = await import("@modelcontextprotocol/sdk/client/stdio.js");
+    } catch {
+      throw new Error(
+        "Stdio MCP transport requires @modelcontextprotocol/sdk. Install it with: npm install @modelcontextprotocol/sdk"
+      );
+    }
+  }
+  return stdioModule;
+}
+
+// src/mcp/manager.ts
+var DefaultMCPManager = class {
+  config;
+  connections = /* @__PURE__ */ new Map();
+  toolCache;
+  constructor(config) {
+    this.config = config;
+  }
+  async connect() {
+    const results = /* @__PURE__ */ new Map();
+    const connectPromises = Object.entries(this.config).map(
+      async ([name, serverConfig]) => {
+        if (serverConfig.enabled === false) {
+          const status = { status: "disabled" };
+          this.connections.set(name, {
+            client: void 0,
+            config: serverConfig,
+            status
+          });
+          results.set(name, status);
+          return;
+        }
+        results.set(name, { status: "connecting" });
+        try {
+          const { client, toolCount } = await this.createClient(name, serverConfig);
+          const status = { status: "connected", toolCount };
+          this.connections.set(name, { client, config: serverConfig, status });
+          results.set(name, status);
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          const status = {
+            status: "error",
+            error: errorMessage
+          };
+          results.set(name, status);
+          this.connections.set(name, {
+            client: void 0,
+            config: serverConfig,
+            status
+          });
+        }
+      }
+    );
+    await Promise.all(connectPromises);
+    this.toolCache = void 0;
+    return results;
+  }
+  async getTools() {
+    if (this.toolCache) {
+      return this.toolCache;
+    }
+    const allTools = {};
+    const toolPromises = Array.from(this.connections.entries()).map(
+      async ([serverName, connection]) => {
+        if (connection.status.status !== "connected") {
+          return;
+        }
+        try {
+          const tools = await connection.client.tools();
+          for (const [toolName, tool] of Object.entries(tools)) {
+            allTools[`${serverName}__${toolName}`] = tool;
+          }
+        } catch (error) {
+          console.warn(`[mcp] Failed to get tools from ${serverName}:`, error);
+        }
+      }
+    );
+    await Promise.all(toolPromises);
+    this.toolCache = allTools;
+    return allTools;
+  }
+  getStatus(serverName) {
+    const connection = this.connections.get(serverName);
+    return connection?.status ?? { status: "disconnected" };
+  }
+  getAllStatus() {
+    const status = /* @__PURE__ */ new Map();
+    for (const [name, connection] of this.connections) {
+      status.set(name, connection.status);
+    }
+    return status;
+  }
+  async listResources() {
+    const resources = [];
+    const promises = Array.from(this.connections.entries()).map(
+      async ([serverName, connection]) => {
+        if (connection.status.status !== "connected") {
+          return;
+        }
+        try {
+          const result = await connection.client.listResources();
+          for (const resource of result.resources) {
+            resources.push({
+              uri: resource.uri,
+              name: resource.name,
+              description: resource.description,
+              mimeType: resource.mimeType,
+              server: serverName
+            });
+          }
+        } catch {
+        }
+      }
+    );
+    await Promise.all(promises);
+    return resources;
+  }
+  async readResource(uri) {
+    for (const [, connection] of this.connections) {
+      if (connection.status.status !== "connected") {
+        continue;
+      }
+      try {
+        return await connection.client.readResource({ uri });
+      } catch {
+      }
+    }
+    throw new Error(`Resource not found: ${uri}`);
+  }
+  async listPrompts() {
+    const prompts = [];
+    const promises = Array.from(this.connections.entries()).map(
+      async ([serverName, connection]) => {
+        if (connection.status.status !== "connected") {
+          return;
+        }
+        try {
+          const result = await connection.client.experimental_listPrompts();
+          for (const prompt of result.prompts) {
+            prompts.push({
+              name: prompt.name,
+              description: prompt.description,
+              arguments: prompt.arguments,
+              server: serverName
+            });
+          }
+        } catch {
+        }
+      }
+    );
+    await Promise.all(promises);
+    return prompts;
+  }
+  async getPrompt(serverName, promptName, args) {
+    const connection = this.connections.get(serverName);
+    if (!connection || connection.status.status !== "connected") {
+      throw new Error(`Server not connected: ${serverName}`);
+    }
+    return await connection.client.experimental_getPrompt({
+      name: promptName,
+      arguments: args
+    });
+  }
+  async close() {
+    const closePromises = Array.from(this.connections.values()).map(
+      async (connection) => {
+        if (connection.client) {
+          try {
+            await connection.client.close();
+          } catch {
+          }
+        }
+      }
+    );
+    await Promise.all(closePromises);
+    this.connections.clear();
+    this.toolCache = void 0;
+  }
+  isConnected() {
+    for (const connection of this.connections.values()) {
+      if (connection.status.status === "connected") {
+        return true;
+      }
+    }
+    return false;
+  }
+  async createClient(name, config) {
+    const { createMCPClient } = await getMcpSdkModule();
+    const timeout = config.timeout ?? 3e4;
+    const withTimeout = (promise, ms) => {
+      return Promise.race([
+        promise,
+        new Promise(
+          (_, reject) => setTimeout(
+            () => reject(new Error(`MCP connection timeout after ${ms}ms`)),
+            ms
+          )
+        )
+      ]);
+    };
+    if (config.transport === "stdio") {
+      const { StdioClientTransport } = await getStdioClientModule();
+      const transport = new StdioClientTransport({
+        command: config.command,
+        args: config.args,
+        env: config.env,
+        cwd: config.cwd
+      });
+      const client2 = await createMCPClient({
+        transport,
+        name: config.name ?? name
+      });
+      const tools2 = await withTimeout(client2.tools(), timeout);
+      return { client: client2, toolCount: Object.keys(tools2).length };
+    }
+    const client = await createMCPClient({
+      transport: {
+        type: config.transport,
+        url: config.url,
+        headers: config.headers
+      },
+      name: config.name ?? name
+    });
+    const tools = await withTimeout(client.tools(), timeout);
+    return { client, toolCount: Object.keys(tools).length };
+  }
+};
+
+// src/mcp/factories.ts
+function createMCPManager(config) {
+  return new DefaultMCPManager(config);
+}
+function defineServer(config) {
+  return config;
+}
+function stdioServer(command, args, options) {
+  return {
+    transport: "stdio",
+    command,
+    args,
+    ...options
+  };
+}
+function httpServer(url, options) {
+  return {
+    transport: "http",
+    url,
+    ...options
+  };
+}
+function sseServer(url, options) {
+  return {
+    transport: "sse",
+    url,
+    ...options
+  };
+}
+
+export {
+  createMCPManager,
+  defineServer,
+  stdioServer,
+  httpServer,
+  sseServer
+};

package/dist/config-D2xeGEHK.d.ts

@@ -0,0 +1,52 @@
+import { LanguageModel } from 'ai';
+import { ProviderOptions } from '@ai-sdk/provider-utils';
+import { R as ReasoningLevel, a as ReasoningConfig } from './types-CQaXbRsS.js';
+
+/**
+ * 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 { buildReasoningOptionsSync as a, buildReasoningOptions as b, getReasoningConfigSync as c, supportsReasoningSync as d, getReasoningConfig as g, supportsReasoning as s };

package/dist/context/index.d.ts

@@ -0,0 +1,259 @@
+import { M as Message } from '../messages-BYWGn8TY.js';
+import { ModelMessage, LanguageModel } from 'ai';
+
+/**
+ * Token Estimation Utilities
+ *
+ * Provides lightweight heuristic-based token counting for messages
+ * and conversations. Uses the chars/4 approximation — simple but
+ * effective for context-window planning decisions.
+ *
+ * These are *estimates*, not exact counts. For billing or hard limits,
+ * use the provider's native tokeniser instead.
+ */
+
+/**
+ * Estimate token count for a plain string.
+ *
+ * Uses the widely-accepted `chars / 4` heuristic.
+ *
+ * @param text - Text to estimate
+ * @returns Estimated token count (always ≥ 1 for non-empty input)
+ */
+declare function estimateTokens(text: string): number;
+/**
+ * Estimate token count for a single message.
+ *
+ * Handles:
+ * - Plain string content
+ * - Multi-part / multimodal arrays (text parts + images)
+ *
+ * @param message - A `Message` (internal) or `ModelMessage` (AI SDK)
+ * @returns Estimated token count
+ */
+declare function estimateMessageTokens(message: Message | ModelMessage): number;
+/**
+ * Estimate total tokens for an entire conversation.
+ *
+ * Adds a small per-message overhead (≈ 4 tokens) for message
+ * framing (`role`, delimiters, etc.).
+ *
+ * @param messages - Array of messages to estimate
+ * @returns Estimated total token count
+ */
+declare function estimateConversationTokens(messages: (Message | ModelMessage)[]): number;
+
+/**
+ * Context Overflow Detection & Pruning
+ *
+ * Detects when a conversation is approaching the model's context-window
+ * limit and prunes old / redundant content to stay within bounds.
+ *
+ * Two pruning strategies are available:
+ * 1. **Tool-result pruning** — replaces large, stale tool outputs with
+ *    compact placeholders (lightweight, no model call).
+ * 2. **Conversation cutting** — identifies a safe cut-point and removes
+ *    older messages entirely (optionally summarised by the manager).
+ */
+
+/**
+ * Context limits configuration.
+ *
+ * All values are in *estimated* tokens (see {@link estimateTokens}).
+ */
+interface ContextLimits {
+    /** Maximum context window size in tokens */
+    contextWindow: number;
+    /** Reserve tokens for output generation */
+    reserveTokens: number;
+    /** Protect this many recent tokens from pruning */
+    protectedTokens: number;
+    /** Minimum tokens to trigger pruning (avoid pruning tiny contexts) */
+    pruneMinimum: number;
+}
+/**
+ * Default context limits.
+ * Based on typical 128 k context-window models.
+ */
+declare const DEFAULT_CONTEXT_LIMITS: ContextLimits;
+/**
+ * Check whether the context is overflowing.
+ *
+ * @param tokens - Current estimated token count
+ * @param limits - Context limits (defaults to 128 k window)
+ * @returns `true` if context exceeds the safe threshold
+ */
+declare function isContextOverflowing(tokens: number, limits?: ContextLimits): boolean;
+/**
+ * Check whether pruning should be triggered.
+ *
+ * Returns `false` when the conversation is still small enough that
+ * pruning would be wasteful (below {@link ContextLimits.pruneMinimum}).
+ */
+declare function shouldPruneContext(tokens: number, limits?: ContextLimits): boolean;
+/**
+ * Result of a pruning operation.
+ */
+interface PruneResult {
+    /** Messages after pruning (may include a summary message) */
+    messages: Message[];
+    /** Number of messages removed */
+    removedCount: number;
+    /** Estimated tokens removed */
+    tokensRemoved: number;
+    /** Whether summarisation was used */
+    summarized: boolean;
+    /** The summary content, if generated */
+    summary?: string;
+}
+/**
+ * Find a safe index at which the conversation can be "cut".
+ *
+ * Rules:
+ * - Never cut in the middle of a tool-call sequence
+ * - Prefer cutting after assistant / user messages
+ * - Keep at least {@link protectedTokens} tokens at the end
+ *
+ * @param messages       - Full message array
+ * @param protectedTokens - Tokens to preserve at the end
+ * @returns Cut index (exclusive — remove messages *before* this index).
+ *          Returns `0` when no safe cut-point exists.
+ */
+declare function findCutPoint(messages: Message[], protectedTokens?: number): number;
+/**
+ * Prune old, large tool results from the conversation.
+ *
+ * Prune strategy:
+ * - Walks backwards through messages
+ * - Protects recent outputs (within {@link protectedTokens})
+ * - Skips protected tools (e.g. "skill")
+ * - Stamps pruned messages with a `compactedAt` timestamp
+ *
+ * @param messages       - Messages to prune
+ * @param protectedTokens - Don't prune tool results in the last N tokens
+ * @param options        - Extra tool names to protect
+ * @returns New message array with large tool outputs replaced
+ */
+declare function pruneToolResults(messages: Message[], protectedTokens?: number, options?: {
+    /** Additional tools to protect from pruning */
+    protectedTools?: string[];
+}): Message[];
+
+/**
+ * Context Summarisation
+ *
+ * When tool-result pruning alone isn't enough to stay within the
+ * context window, the manager can *cut* the conversation and replace
+ * the removed portion with an LLM-generated summary.
+ *
+ * This module provides the summary-generation logic and the
+ * top-level `pruneContext()` orchestration function.
+ */
+
+/**
+ * Options for summary generation.
+ */
+interface SummarizationOptions {
+    /** Model used to generate the summary */
+    model: LanguageModel;
+    /** Max tokens for the summary output */
+    maxTokens?: number;
+    /** Custom summarisation system prompt */
+    customPrompt?: string;
+}
+/**
+ * Options for {@link pruneContext}.
+ */
+interface PruneContextOptions {
+    /** Model for summarisation (omit to skip summary generation) */
+    model?: LanguageModel;
+    /** Context limits to enforce */
+    limits?: ContextLimits;
+    /** Custom summarisation prompt */
+    summaryPrompt?: string;
+}
+/**
+ * Generate a natural-language summary of a message sequence.
+ *
+ * @param messages - Messages to summarise
+ * @param options  - Model & prompt configuration
+ * @returns Summary text
+ */
+declare function generateSummary(messages: Message[], options: SummarizationOptions): Promise<string>;
+/**
+ * Prune a conversation to fit within context-window limits.
+ *
+ * Strategy (in order):
+ * 1. Prune old tool outputs (lightweight, no model call)
+ * 2. If still overflowing, find a safe cut-point and remove
+ *    older messages — optionally generating an LLM summary.
+ *
+ * @param messages - Current message array
+ * @param options  - Limits, model, and prompt overrides
+ * @returns A {@link PruneResult} with the trimmed messages
+ */
+declare function pruneContext(messages: Message[], options?: PruneContextOptions): Promise<PruneResult>;
+
+/**
+ * Context Manager
+ *
+ * Stateful wrapper around the context-management primitives.
+ * Tracks per-session context limits and provides a single entry
+ * point for token estimation, overflow detection, and pruning.
+ */
+
+/**
+ * Per-session context manager.
+ *
+ * Holds the active context-window limits and provides convenience
+ * methods for checking, reporting, and pruning context.
+ *
+ * @example
+ * ```typescript
+ * const ctx = new ContextManager({ limits: { contextWindow: 200_000 } });
+ *
+ * if (ctx.shouldPrune(messages)) {
+ *   const result = await ctx.prune(messages);
+ *   console.log(`Removed ${result.removedCount} messages`);
+ * }
+ * ```
+ */
+declare class ContextManager {
+    private limits;
+    private model?;
+    private summaryPrompt?;
+    constructor(options?: {
+        limits?: Partial<ContextLimits>;
+        model?: LanguageModel;
+        summaryPrompt?: string;
+    });
+    /** Get a copy of the current context limits. */
+    getLimits(): ContextLimits;
+    /** Update context limits (e.g. when switching models). */
+    setLimits(limits: Partial<ContextLimits>): void;
+    /** Set the model used for summarisation. */
+    setModel(model: LanguageModel): void;
+    /** Estimate total tokens for a message array. */
+    estimateTokens(messages: (Message | ModelMessage)[]): number;
+    /** Check whether the context is overflowing. */
+    isOverflowing(messages: (Message | ModelMessage)[]): boolean;
+    /** Check whether pruning should be triggered. */
+    shouldPrune(messages: (Message | ModelMessage)[]): boolean;
+    /** Prune context to fit within limits. */
+    prune(messages: Message[]): Promise<PruneResult>;
+    /**
+     * Get a snapshot of token statistics.
+     *
+     * Useful for dashboards, logging, or deciding whether to prune.
+     */
+    getStats(messages: (Message | ModelMessage)[]): {
+        tokens: number;
+        limit: number;
+        available: number;
+        utilizationPercent: number;
+        isOverflowing: boolean;
+        shouldPrune: boolean;
+    };
+}
+
+export { type ContextLimits, ContextManager, DEFAULT_CONTEXT_LIMITS, type PruneContextOptions, type PruneResult, type SummarizationOptions, estimateConversationTokens, estimateMessageTokens, estimateTokens, findCutPoint, generateSummary, isContextOverflowing, pruneContext, pruneToolResults, shouldPruneContext };

package/dist/context/index.js

@@ -0,0 +1,26 @@
+import {
+  ContextManager,
+  DEFAULT_CONTEXT_LIMITS,
+  estimateConversationTokens,
+  estimateMessageTokens,
+  estimateTokens,
+  findCutPoint,
+  generateSummary,
+  isContextOverflowing,
+  pruneContext,
+  pruneToolResults,
+  shouldPruneContext
+} from "../chunk-QAQADS4X.js";
+export {
+  ContextManager,
+  DEFAULT_CONTEXT_LIMITS,
+  estimateConversationTokens,
+  estimateMessageTokens,
+  estimateTokens,
+  findCutPoint,
+  generateSummary,
+  isContextOverflowing,
+  pruneContext,
+  pruneToolResults,
+  shouldPruneContext
+};

package/dist/identifiers-BLUxFqV_.d.ts

@@ -0,0 +1,12 @@
+import { LanguageModel } from 'ai';
+
+/**
+ * Extract a model ID string from a LanguageModel instance.
+ */
+declare function getModelId(model: LanguageModel): string;
+/**
+ * Extract a provider identifier from a LanguageModel instance.
+ */
+declare function getProviderId(model: LanguageModel): string | undefined;
+
+export { getProviderId as a, getModelId as g };