@cuylabs/agent-core 0.7.0 → 0.9.0

package/dist/{chunk-5K7AQVOU.js → chunk-WKHDSSXG.js}

@@ -1,12 +1,16 @@
-import {
-  buildReasoningOptionsSync
-} from "./chunk-ZPMACVZK.js";
 import {
   executeAgentToolCall
-} from "./chunk-IEFIQENH.js";
+} from "./chunk-H3FUYU52.js";
+import {
+  LLMError,
+  isRetryable
+} from "./chunk-4QFNWPIF.js";
 import {
   snapshotScope
 } from "./chunk-N7P4PN3O.js";
+import {
+  buildReasoningOptionsSync
+} from "./chunk-UDCZ673N.js";
 
 // src/inference/toolset.ts
 import { tool, zodSchema } from "ai";
@@ -21,6 +25,7 @@ async function buildToolSet(options) {
       execute: async (params) => (await executeAgentToolCall({
         toolName: id,
         tool: info,
+        initialized,
         params,
         cwd: options.cwd,
         abort: options.abort,
@@ -44,201 +49,114 @@ import {
   streamText
 } from "ai";
 
-// src/errors/classify.ts
-function isRetryableCategory(category) {
-  switch (category) {
-    case "rate_limit":
-    case "overloaded":
-    case "network":
-    case "timeout":
-      return true;
-    case "auth":
-    case "invalid_request":
-    case "context_overflow":
-    case "content_filter":
-    case "cancelled":
-    case "unknown":
-      return false;
-  }
+// src/inference/middleware-support.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && Object.getPrototypeOf(value) === Object.prototype;
 }
-function classifyFromStatusAndMessage(status, message) {
-  const lowerMessage = message.toLowerCase();
-  if (status) {
-    if (status === 429) return "rate_limit";
-    if (status === 401 || status === 403) return "auth";
-    if (status === 400) {
-      if (lowerMessage.includes("context") || lowerMessage.includes("token")) {
-        return "context_overflow";
-      }
-      return "invalid_request";
-    }
-    if (status === 503 || status === 502) return "overloaded";
-    if (status >= 500) return "network";
-  }
-  if (lowerMessage.includes("rate") && lowerMessage.includes("limit")) {
-    return "rate_limit";
-  }
-  if (lowerMessage.includes("overload") || lowerMessage.includes("capacity")) {
-    return "overloaded";
-  }
-  if (lowerMessage.includes("too_many_requests")) {
-    return "rate_limit";
-  }
-  if (lowerMessage.includes("unauthorized") || lowerMessage.includes("invalid api key")) {
-    return "auth";
-  }
-  if (lowerMessage.includes("context") && lowerMessage.includes("length")) {
-    return "context_overflow";
-  }
-  if (lowerMessage.includes("content") && lowerMessage.includes("filter")) {
-    return "content_filter";
-  }
-  if (lowerMessage.includes("timeout") || lowerMessage.includes("timed out")) {
-    return "timeout";
-  }
-  if (lowerMessage.includes("network") || lowerMessage.includes("econnrefused") || lowerMessage.includes("econnreset")) {
-    return "network";
-  }
-  return "unknown";
+function isAsyncIterable(value) {
+  return typeof value === "object" && value !== null && Symbol.asyncIterator in value;
 }
-function parseRetryDelay(headers) {
-  const retryAfterMs = headers["retry-after-ms"];
-  if (retryAfterMs) {
-    const parsed = parseFloat(retryAfterMs);
-    if (!Number.isNaN(parsed) && parsed > 0) {
-      return parsed;
-    }
+function stringifyToolOutput(output) {
+  if (typeof output === "string") {
+    return output;
   }
-  const retryAfter = headers["retry-after"];
-  if (retryAfter) {
-    const seconds = parseFloat(retryAfter);
-    if (!Number.isNaN(seconds) && seconds > 0) {
-      return Math.ceil(seconds * 1e3);
-    }
-    const dateMs = Date.parse(retryAfter);
-    if (!Number.isNaN(dateMs)) {
-      const delayMs = dateMs - Date.now();
-      if (delayMs > 0) {
-        return Math.ceil(delayMs);
-      }
-    }
+  try {
+    const serialized = JSON.stringify(output);
+    return serialized ?? String(output);
+  } catch {
+    return String(output);
   }
-  return void 0;
 }
-
-// src/errors/extract.ts
-function extractFromAISDKError(error) {
-  const result = {};
-  const anyError = error;
-  if (typeof anyError.status === "number") {
-    result.status = anyError.status;
-  } else if (typeof anyError.statusCode === "number") {
-    result.status = anyError.statusCode;
-  }
-  if (anyError.responseHeaders && typeof anyError.responseHeaders === "object") {
-    result.headers = anyError.responseHeaders;
-  } else if (anyError.headers && typeof anyError.headers === "object") {
-    result.headers = anyError.headers;
-  }
-  if (anyError.data && typeof anyError.data === "object") {
-    const data = anyError.data;
-    if (data.type === "error" && typeof data.error === "object") {
-      const innerError = data.error;
-      if (innerError.type === "too_many_requests") {
-        result.category = "rate_limit";
-      } else if (innerError.type === "overloaded") {
-        result.category = "overloaded";
-      }
-    }
-    if (typeof data.isRetryable === "boolean" && !data.isRetryable && !result.category) {
-      result.category = "invalid_request";
-    }
-  }
-  return result;
+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;
 }
-
-// src/errors/llm-error.ts
-var LLMError = class _LLMError extends Error {
-  category;
-  status;
-  headers;
-  provider;
-  model;
-  isRetryable;
-  retryDelayMs;
-  constructor(options) {
-    super(options.message, { cause: options.cause });
-    this.name = "LLMError";
-    this.status = options.status;
-    this.headers = options.headers;
-    this.provider = options.provider;
-    this.model = options.model;
-    this.category = options.category ?? classifyFromStatusAndMessage(
-      options.status,
-      options.message
-    );
-    this.isRetryable = isRetryableCategory(this.category);
-    this.retryDelayMs = this.headers ? parseRetryDelay(this.headers) : void 0;
-  }
-  static from(error, context) {
-    if (error instanceof _LLMError) {
-      return error;
+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;
     }
-    if (error instanceof Error) {
-      if (error.name === "AbortError" || error.message.includes("abort")) {
-        return new _LLMError({
-          message: error.message,
-          category: "cancelled",
-          cause: error,
-          ...context
+    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 new _LLMError({
-        message: error.message,
-        cause: error,
-        ...extractFromAISDKError(error),
-        ...context
-      });
-    }
-    return new _LLMError({
-      message: String(error),
-      category: "unknown",
-      ...context
-    });
-  }
-  get description() {
-    const parts = [this.message];
-    if (this.provider) parts.unshift(`[${this.provider}]`);
-    if (this.status) parts.push(`(HTTP ${this.status})`);
-    if (this.isRetryable && this.retryDelayMs) {
-      parts.push(`retry in ${Math.ceil(this.retryDelayMs / 1e3)}s`);
-    }
-    return parts.join(" ");
-  }
-};
-
-// src/errors/utils.ts
-function isRetryable(error) {
-  if (error instanceof LLMError) {
-    return error.isRetryable;
-  }
-  return LLMError.from(error).isRetryable;
-}
-function getRetryDelay(error) {
-  if (error instanceof LLMError) {
-    return error.isRetryable ? error.retryDelayMs : void 0;
-  }
-  const llmError = LLMError.from(error);
-  return llmError.isRetryable ? llmError.retryDelayMs : void 0;
-}
-function getErrorCategory(error) {
-  if (error instanceof LLMError) {
-    return error.category;
+    };
   }
-  return LLMError.from(error).category;
+  return wrapped;
 }
 
-// src/retry.ts
+// src/inference/retry.ts
 var DEFAULT_RETRY_CONFIG = {
   maxAttempts: 3,
   initialDelayMs: 2e3,
@@ -377,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;
 }
@@ -471,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) {
@@ -532,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,
@@ -549,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 () => {
@@ -569,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 });
@@ -596,12 +523,6 @@ var LLM = Inference;
 
 export {
   buildToolSet,
-  isRetryableCategory,
-  parseRetryDelay,
-  LLMError,
-  isRetryable,
-  getRetryDelay,
-  getErrorCategory,
   DEFAULT_RETRY_CONFIG,
   createRetryState,
   calculateDelay,

package/dist/{chunk-BNSHUWCV.js → chunk-WWYYNWEW.js}

@@ -30,7 +30,7 @@ function estimateConversationTokens(messages) {
   return total;
 }
 
-// src/types/agent/compaction.ts
+// src/agent/types/compaction.ts
 var PRUNE_PROTECTED_TOOLS = ["skill"];
 
 // src/context/pruning.ts

package/dist/context/index.js

@@ -10,7 +10,7 @@ import {
   pruneContext,
   pruneToolResults,
   shouldPruneContext
-} from "../chunk-BNSHUWCV.js";
+} from "../chunk-WWYYNWEW.js";
 export {
   ContextManager,
   DEFAULT_CONTEXT_LIMITS,

package/dist/events-CE72w8W4.d.ts

@@ -0,0 +1,149 @@
+import * as ai from 'ai';
+import { T as TokenUsage, M as Message } from './messages-BYWGn8TY.js';
+
+/** Agent status for UI display */
+type AgentStatus = "idle" | "processing" | "thinking" | "reasoning" | "calling-tool" | "waiting-approval" | "error";
+/** Approval request for UI */
+interface ApprovalEvent {
+    id: string;
+    tool: string;
+    args: unknown;
+    description: string;
+    risk: "safe" | "moderate" | "dangerous";
+}
+/** Neutral turn-commit boundaries for runtime/durability integrations */
+type AgentTurnBoundaryKind = "input-commit-start" | "input-commit-finish" | "intervention-commit-start" | "intervention-commit-finish" | "step-commit-start" | "step-commit-finish" | "output-commit-start" | "output-commit-finish";
+/**
+ * Events emitted during agent execution
+ *
+ * These events are designed for UI consumption:
+ * - status: Overall agent state for status indicators
+ * - approval-request: User confirmation needed
+ * - progress: Step counts for progress bars
+ */
+type AgentEvent = {
+    type: "status";
+    status: AgentStatus;
+} | {
+    type: "approval-request";
+    request: ApprovalEvent;
+} | {
+    type: "approval-resolved";
+    id: string;
+    action: "allow" | "deny" | "remember";
+} | {
+    type: "step-start";
+    step: number;
+    maxSteps: number;
+} | {
+    type: "step-finish";
+    step: number;
+    usage?: TokenUsage;
+    finishReason?: string;
+} | {
+    type: "turn-boundary";
+    boundary: AgentTurnBoundaryKind;
+    step?: number;
+    messageRole?: Message["role"];
+    pendingToolCallCount?: number;
+} | {
+    type: "message";
+    message: Message;
+} | {
+    type: "text-start";
+} | {
+    type: "text-delta";
+    text: string;
+} | {
+    type: "text-end";
+} | {
+    type: "reasoning-start";
+    id: string;
+} | {
+    type: "reasoning-delta";
+    id: string;
+    text: string;
+} | {
+    type: "reasoning-end";
+    id: string;
+} | {
+    type: "tool-start";
+    toolName: string;
+    toolCallId: string;
+    input: unknown;
+} | {
+    type: "tool-result";
+    toolName: string;
+    toolCallId: string;
+    result: unknown;
+} | {
+    type: "tool-error";
+    toolName: string;
+    toolCallId: string;
+    error: string;
+} | {
+    type: "computer-call";
+    callId: string;
+    action: unknown;
+    pendingSafetyChecks?: unknown[];
+} | {
+    type: "computer-result";
+    callId: string;
+    result: unknown;
+} | {
+    type: "intervention-applied";
+    id: string;
+    message: string;
+} | {
+    type: "doom-loop";
+    toolName: string;
+    repeatCount: number;
+} | {
+    type: "context-overflow";
+    inputTokens: number;
+    limit: number;
+} | {
+    type: "turn-summary";
+    turnId: string;
+    files: Array<{
+        path: string;
+        type: "created" | "modified" | "deleted" | "unchanged";
+        additions: number;
+        deletions: number;
+    }>;
+    additions: number;
+    deletions: number;
+} | {
+    type: "retry";
+    attempt: number;
+    delayMs: number;
+    error: Error;
+} | {
+    type: "error";
+    error: Error;
+} | {
+    type: "complete";
+    usage?: TokenUsage;
+    output?: string;
+};
+/**
+ * Step-processing result - what happens after reducing one streamed step
+ */
+type StepProcessingResult = "continue" | "stop" | "compact";
+/**
+ * @deprecated Use `StepProcessingResult`.
+ */
+type ProcessorResult = StepProcessingResult;
+/**
+ * Stream input for model inference
+ */
+interface StreamInput {
+    sessionID: string;
+    model: ai.LanguageModel;
+    system: string[];
+    messages: ai.ModelMessage[];
+    abort: AbortSignal;
+    tools: Record<string, unknown>;
+}
+
+export type { AgentEvent as A, ProcessorResult as P, StepProcessingResult as S, AgentStatus as a, AgentTurnBoundaryKind as b, ApprovalEvent as c, StreamInput as d };