@cuylabs/agent-core 0.8.0 → 0.9.0

package/dist/{chunk-N6HWIEEA.js → chunk-WKHDSSXG.js}

@@ -1,16 +1,16 @@
 import {
   executeAgentToolCall
-} from "./chunk-7VKQ4WPB.js";
+} from "./chunk-H3FUYU52.js";
 import {
-  buildReasoningOptionsSync
-} from "./chunk-SQU2AJHO.js";
+  LLMError,
+  isRetryable
+} from "./chunk-4QFNWPIF.js";
 import {
   snapshotScope
 } from "./chunk-N7P4PN3O.js";
 import {
-  LLMError,
-  isRetryable
-} from "./chunk-RZITT45F.js";
+  buildReasoningOptionsSync
+} from "./chunk-UDCZ673N.js";
 
 // src/inference/toolset.ts
 import { tool, zodSchema } from "ai";
@@ -25,6 +25,7 @@ async function buildToolSet(options) {
       execute: async (params) => (await executeAgentToolCall({
         toolName: id,
         tool: info,
+        initialized,
         params,
         cwd: options.cwd,
         abort: options.abort,
@@ -48,7 +49,114 @@ import {
   streamText
 } from "ai";
 
-// src/retry.ts
+// src/inference/middleware-support.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && Object.getPrototypeOf(value) === Object.prototype;
+}
+function isAsyncIterable(value) {
+  return typeof value === "object" && value !== null && Symbol.asyncIterator in value;
+}
+function stringifyToolOutput(output) {
+  if (typeof output === "string") {
+    return output;
+  }
+  try {
+    const serialized = JSON.stringify(output);
+    return serialized ?? String(output);
+  } catch {
+    return String(output);
+  }
+}
+async function runAfterToolCall(options) {
+  const { middleware, toolName, params, output, ctx } = options;
+  const transformed = await middleware.runAfterToolCall(
+    toolName,
+    params,
+    {
+      title: toolName,
+      output: stringifyToolOutput(output),
+      metadata: {}
+    },
+    ctx
+  );
+  return typeof output === "string" ? transformed.output : output;
+}
+function mergeProviderOptions(base, override) {
+  if (!base) return override;
+  if (!override) return base;
+  const merged = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    const current = merged[key];
+    merged[key] = isPlainObject(current) && isPlainObject(value) ? mergeProviderOptions(
+      current,
+      value
+    ) : value;
+  }
+  return merged;
+}
+function wrapMcpToolsForMiddleware(options) {
+  const { tools, middleware, cwd, sessionID, abort, agent } = options;
+  if (!middleware?.hasMiddleware) {
+    return tools;
+  }
+  const wrapped = {};
+  for (const [toolName, tool2] of Object.entries(tools)) {
+    if (!tool2.execute) {
+      wrapped[toolName] = tool2;
+      continue;
+    }
+    wrapped[toolName] = {
+      ...tool2,
+      execute: async (params, execOptions) => {
+        const ctx = {
+          cwd,
+          abort: execOptions.abortSignal ?? abort,
+          sessionID,
+          messageID: execOptions.toolCallId,
+          agent: agent ?? "default",
+          scope: snapshotScope(),
+          extra: {
+            toolCallId: execOptions.toolCallId,
+            messages: execOptions.messages,
+            experimentalContext: execOptions.experimental_context
+          }
+        };
+        const decision = await middleware.runBeforeToolCall(
+          toolName,
+          params,
+          ctx
+        );
+        if (decision.action === "deny") {
+          return decision.reason ?? `Tool call denied: ${toolName}`;
+        }
+        const result = tool2.execute(params, execOptions);
+        if (isAsyncIterable(result)) {
+          let lastOutput;
+          for await (const chunk of result) {
+            lastOutput = chunk;
+          }
+          return await runAfterToolCall({
+            middleware,
+            toolName,
+            params,
+            output: lastOutput,
+            ctx
+          });
+        }
+        return await runAfterToolCall({
+          middleware,
+          toolName,
+          params,
+          output: await result,
+          ctx
+        });
+      }
+    };
+  }
+  return wrapped;
+}
+
+// src/inference/retry.ts
 var DEFAULT_RETRY_CONFIG = {
   maxAttempts: 3,
   initialDelayMs: 2e3,
@@ -187,11 +295,6 @@ function applyModelCallInput(target, modelCall) {
   target.toolExecutionMode = modelCall.toolExecutionMode;
   target.activeModelCall = modelCall;
 }
-function mergeProviderOptions(base, override) {
-  if (!base) return override;
-  if (!override) return base;
-  return { ...base, ...override };
-}
 function isBlockedModelCall(value) {
   return "block" in value && value.block === true;
 }
@@ -281,6 +384,11 @@ async function callStreamTextWithOtelContext(options) {
     abortSignal: input.abort,
     providerOptions: mergedProviderOptions,
     experimental_telemetry: input.telemetry,
+    // The AI SDK defaults to console.error(error) for stream failures.
+    // We normalize and surface these errors through our own runtime events,
+    // so suppress the duplicate raw dump here.
+    onError: () => {
+    },
     prepareStep: input.intervention ? async ({ messages }) => {
       const pending = input.intervention.drainImmediate();
       if (pending.length === 0) {
@@ -342,11 +450,14 @@ async function stream(input) {
     if (!input.retry || input.retry.maxAttempts === 0) {
       return wrapModelStream(await runCustomStream(), input);
     }
-    return wrapModelStream(await withRetry(
-      async () => await runCustomStream(),
-      input.retry,
-      input.abort
-    ), input);
+    return wrapModelStream(
+      await withRetry(
+        async () => await runCustomStream(),
+        input.retry,
+        input.abort
+      ),
+      input
+    );
   }
   const toolSet = await buildToolSet({
     tools: input.tools,
@@ -359,9 +470,16 @@ async function stream(input) {
     middleware: input.middleware,
     executionMode: input.toolExecutionMode
   });
+  const mcpToolSet = wrapMcpToolsForMiddleware({
+    tools: input.mcpTools ?? {},
+    middleware: input.middleware,
+    cwd: input.cwd,
+    sessionID: input.sessionID,
+    abort: input.abort
+  });
   const allTools = {
     ...toolSet,
-    ...input.mcpTools ?? {}
+    ...mcpToolSet
   };
   const providerOptions = input.reasoningLevel ? buildReasoningOptionsSync(input.model, input.reasoningLevel) : void 0;
   const createStream = async () => {
@@ -379,11 +497,10 @@ async function stream(input) {
   if (!input.retry || input.retry.maxAttempts === 0) {
     return wrapModelStream(await createStream(), input);
   }
-  return wrapModelStream(await withRetry(
-    async () => await createStream(),
-    input.retry,
-    input.abort
-  ), input);
+  return wrapModelStream(
+    await withRetry(async () => await createStream(), input.retry, input.abort),
+    input
+  );
 }
 async function streamOnce(input) {
   return await stream({ ...input, retry: void 0 });

package/dist/index-BCqEGzBj.d.ts

@@ -0,0 +1,251 @@
+import { R as ReasoningLevel, a as ReasoningConfig } from './types-CQaXbRsS.js';
+import { LanguageModel } from 'ai';
+import { ProviderOptions } from '@ai-sdk/provider-utils';
+
+/**
+ * Model Capability Types for @cuylabs/agent-core
+ *
+ * Defines the structure for model capabilities that can be sourced from
+ * static patterns, local cache, or remote APIs.
+ */
+/**
+ * Input modalities a model can accept
+ */
+type InputModality = "text" | "image" | "audio" | "video" | "pdf";
+/**
+ * Output modalities a model can produce
+ */
+type OutputModality = "text" | "image" | "audio" | "video";
+/**
+ * Comprehensive model capabilities
+ */
+interface ModelCapabilities {
+    /** Model supports extended reasoning/thinking */
+    reasoning: boolean;
+    /** Model supports function/tool calling */
+    toolCalling: boolean;
+    /** Model supports temperature adjustment */
+    temperature: boolean;
+    /** Model supports file attachments */
+    attachments: boolean;
+    /** Model supports streaming responses */
+    streaming: boolean;
+    /** Supported input modalities */
+    inputModalities: InputModality[];
+    /** Supported output modalities */
+    outputModalities: OutputModality[];
+    /** Maximum context window in tokens */
+    contextWindow?: number;
+    /** Maximum output tokens */
+    maxOutput?: number;
+}
+/**
+ * Provider-specific compatibility flags
+ * These handle quirks in different provider implementations
+ */
+interface ProviderCompatibility {
+    /** Supports OpenAI-style reasoning_effort parameter */
+    supportsReasoningEffort?: boolean;
+    /** Supports developer/system role distinction */
+    supportsDeveloperRole?: boolean;
+    /** Field name for max tokens (varies by provider) */
+    maxTokensField?: "max_tokens" | "max_completion_tokens";
+    /** Requires thinking as text tags vs structured */
+    requiresThinkingTags?: boolean;
+    /** Provider-specific thinking format */
+    thinkingFormat?: "openai" | "anthropic" | "google" | "zai";
+}
+/**
+ * Complete model entry with metadata
+ */
+interface ModelEntry {
+    /** Model identifier (e.g., "gpt-4o", "claude-sonnet-4") */
+    id: string;
+    /** Human-readable model name */
+    name: string;
+    /** Provider identifier (e.g., "openai", "anthropic") */
+    provider: string;
+    /** Model capabilities */
+    capabilities: ModelCapabilities;
+    /** Provider-specific compatibility settings */
+    compatibility?: ProviderCompatibility;
+    /** Cost per million tokens (input) */
+    costInput?: number;
+    /** Cost per million tokens (output) */
+    costOutput?: number;
+    /** When this entry was last updated */
+    updatedAt?: string;
+}
+/**
+ * Priority levels for capability sources
+ */
+declare enum SourcePriority {
+    /** User configuration overrides everything */
+    UserConfig = 0,
+    /** Local cache from previous fetch */
+    LocalCache = 1,
+    /** Bundled static data (build-time) */
+    BundledData = 2,
+    /** Pattern-based inference (fallback) */
+    PatternMatch = 3,
+    /** Remote API (if network available) */
+    RemoteAPI = 4
+}
+/**
+ * Result from a capability source lookup
+ */
+interface SourceResult {
+    /** The model entry if found */
+    entry?: ModelEntry;
+    /** Which source provided this result */
+    source: SourcePriority;
+    /** Whether this is a confident match */
+    confident: boolean;
+    /** Error message if lookup failed */
+    error?: string;
+}
+/**
+ * Capability source interface
+ */
+interface CapabilitySource {
+    /** Source priority (lower = higher priority) */
+    priority: SourcePriority;
+    /** Human-readable source name */
+    name: string;
+    /** Look up capabilities for a model */
+    lookup(modelId: string, provider?: string): Promise<SourceResult>;
+    /** Check if this source is available */
+    isAvailable(): Promise<boolean>;
+}
+/**
+ * Options for the capability resolver
+ */
+interface ResolverOptions {
+    /** Enable remote API fetching (default: false) */
+    enableRemoteFetch?: boolean;
+    /** Remote API URL (default: https://models.dev) */
+    remoteApiUrl?: string;
+    /** Cache directory path */
+    cachePath?: string;
+    /** Cache TTL in milliseconds (default: 1 hour) */
+    cacheTtlMs?: number;
+    /** Network timeout in milliseconds (default: 10 seconds) */
+    networkTimeoutMs?: number;
+    /** Custom user overrides for specific models */
+    modelOverrides?: Record<string, Partial<ModelCapabilities>>;
+}
+/**
+ * Default resolver options
+ */
+declare const DEFAULT_RESOLVER_OPTIONS: Required<ResolverOptions>;
+
+/**
+ * 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 { type CapabilitySource as C, DEFAULT_RESOLVER_OPTIONS as D, type InputModality as I, type ModelCapabilities as M, type OutputModality as O, type ProviderCompatibility as P, type ResolverOptions as R, SourcePriority as S, type ModelEntry as a, type SourceResult as b, buildAnthropicOptions as c, buildBedrockOptions as d, buildGoogleOptions as e, buildGroqOptions as f, buildOpenAIOptions as g, buildOpenRouterOptions as h, buildReasoningOptions as i, buildReasoningOptionsSync as j, buildXAIOptions as k, getProviderOptionsKey as l, getReasoningConfig as m, getReasoningConfigSync as n, supportsReasoningSync as o, supportsReasoning as s };