@cuylabs/agent-core 0.6.0 → 0.7.0

package/dist/chunk-5K7AQVOU.js

@@ -0,0 +1,619 @@
+import {
+  buildReasoningOptionsSync
+} from "./chunk-ZPMACVZK.js";
+import {
+  executeAgentToolCall
+} from "./chunk-IEFIQENH.js";
+import {
+  snapshotScope
+} from "./chunk-N7P4PN3O.js";
+
+// src/inference/toolset.ts
+import { tool, zodSchema } from "ai";
+async function buildToolSet(options) {
+  const toolSet = {};
+  const executionMode = options.executionMode ?? "auto";
+  for (const [id, info] of Object.entries(options.tools)) {
+    const initialized = await info.init({ cwd: options.cwd });
+    toolSet[id] = executionMode === "auto" ? tool({
+      description: initialized.description,
+      inputSchema: zodSchema(initialized.parameters),
+      execute: async (params) => (await executeAgentToolCall({
+        toolName: id,
+        tool: info,
+        params,
+        cwd: options.cwd,
+        abort: options.abort,
+        sessionID: options.sessionID,
+        messageID: options.messageID,
+        ...options.host ? { host: options.host } : {},
+        ...options.turnTracker ? { turnTracker: options.turnTracker } : {},
+        ...options.middleware ? { middleware: options.middleware } : {}
+      })).output
+    }) : tool({
+      description: initialized.description,
+      inputSchema: zodSchema(initialized.parameters)
+    });
+  }
+  return toolSet;
+}
+
+// src/inference/stream.ts
+import {
+  stepCountIs,
+  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;
+  }
+}
+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 parseRetryDelay(headers) {
+  const retryAfterMs = headers["retry-after-ms"];
+  if (retryAfterMs) {
+    const parsed = parseFloat(retryAfterMs);
+    if (!Number.isNaN(parsed) && parsed > 0) {
+      return parsed;
+    }
+  }
+  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);
+      }
+    }
+  }
+  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;
+}
+
+// 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;
+    }
+    if (error instanceof Error) {
+      if (error.name === "AbortError" || error.message.includes("abort")) {
+        return new _LLMError({
+          message: error.message,
+          category: "cancelled",
+          cause: error,
+          ...context
+        });
+      }
+      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;
+}
+
+// src/retry.ts
+var DEFAULT_RETRY_CONFIG = {
+  maxAttempts: 3,
+  initialDelayMs: 2e3,
+  backoffFactor: 2,
+  maxDelayMs: 3e4,
+  jitter: true
+};
+function createRetryState() {
+  return {
+    attempt: 0,
+    errors: [],
+    canRetry: true,
+    nextDelayMs: void 0
+  };
+}
+function calculateDelay(attempt, error, config) {
+  if (error?.retryDelayMs) {
+    return error.retryDelayMs;
+  }
+  const baseDelay = config.initialDelayMs * Math.pow(config.backoffFactor, attempt - 1);
+  const cappedDelay = Math.min(baseDelay, config.maxDelayMs);
+  if (config.jitter) {
+    const jitterRange = cappedDelay * 0.25;
+    const jitter = (Math.random() - 0.5) * 2 * jitterRange;
+    return Math.max(0, Math.round(cappedDelay + jitter));
+  }
+  return Math.round(cappedDelay);
+}
+async function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new DOMException("Aborted", "AbortError"));
+      return;
+    }
+    const timeoutId = setTimeout(() => {
+      cleanup();
+      resolve();
+    }, ms);
+    const abortHandler = () => {
+      clearTimeout(timeoutId);
+      cleanup();
+      reject(new DOMException("Aborted", "AbortError"));
+    };
+    const cleanup = () => {
+      signal?.removeEventListener("abort", abortHandler);
+    };
+    signal?.addEventListener("abort", abortHandler, { once: true });
+  });
+}
+async function withRetry(fn, config, signal) {
+  const mergedConfig = { ...DEFAULT_RETRY_CONFIG, ...config };
+  const state = createRetryState();
+  while (true) {
+    state.attempt++;
+    try {
+      return await fn(state.attempt);
+    } catch (error) {
+      const llmError = LLMError.from(error);
+      state.errors.push(llmError);
+      const shouldRetry2 = state.attempt < mergedConfig.maxAttempts && isRetryable(llmError) && !signal?.aborted;
+      if (!shouldRetry2) {
+        throw new LLMError({
+          message: `Failed after ${state.attempt} attempt(s): ${llmError.message}`,
+          category: llmError.category,
+          status: llmError.status,
+          headers: llmError.headers,
+          provider: llmError.provider,
+          model: llmError.model,
+          cause: llmError
+        });
+      }
+      const delayMs = calculateDelay(state.attempt, llmError, mergedConfig);
+      state.nextDelayMs = delayMs;
+      config?.onRetry?.(state.attempt, delayMs, llmError);
+      await sleep(delayMs, signal);
+    }
+  }
+}
+function createRetryHandler(options) {
+  const config = options ?? {};
+  const signal = options?.signal;
+  return async (createStream) => {
+    return withRetry(createStream, config, signal);
+  };
+}
+function shouldRetry(error, attempt, maxAttempts = DEFAULT_RETRY_CONFIG.maxAttempts) {
+  if (attempt >= maxAttempts) return false;
+  return isRetryable(error);
+}
+
+// src/inference/types.ts
+var DEFAULT_MAX_OUTPUT_TOKENS = 32e3;
+var OUTPUT_TOKEN_MAX = DEFAULT_MAX_OUTPUT_TOKENS;
+
+// src/inference/stream.ts
+function buildModelCallContext(input) {
+  return {
+    sessionID: input.sessionID,
+    step: input.step ?? 1,
+    cwd: input.cwd,
+    abort: input.abort,
+    model: input.model,
+    toolNames: Object.keys(input.tools),
+    mcpToolNames: Object.keys(input.mcpTools ?? {}),
+    scope: snapshotScope()
+  };
+}
+function buildModelCallInput(input) {
+  return {
+    model: input.model,
+    system: [...input.system],
+    messages: [...input.messages],
+    temperature: input.temperature,
+    topP: input.topP,
+    maxOutputTokens: input.maxOutputTokens,
+    maxSteps: input.maxSteps,
+    reasoningLevel: input.reasoningLevel,
+    telemetry: input.telemetry,
+    customStreamProvider: input.customStreamProvider,
+    toolExecutionMode: input.toolExecutionMode,
+    providerOptions: void 0,
+    systemMessages: void 0
+  };
+}
+function applyModelCallInput(target, modelCall) {
+  target.model = modelCall.model;
+  target.system = [...modelCall.system];
+  target.messages = [...modelCall.messages];
+  target.temperature = modelCall.temperature;
+  target.topP = modelCall.topP;
+  target.maxOutputTokens = modelCall.maxOutputTokens;
+  target.maxSteps = modelCall.maxSteps;
+  target.reasoningLevel = modelCall.reasoningLevel;
+  target.telemetry = modelCall.telemetry;
+  target.customStreamProvider = modelCall.customStreamProvider;
+  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;
+}
+async function resolveModelCallInput(input) {
+  if (!input.middleware?.hasMiddleware) {
+    const current = buildModelCallInput(input);
+    input.activeModelCall = current;
+    return current;
+  }
+  const next = await input.middleware.runModelInput(
+    buildModelCallInput(input),
+    buildModelCallContext(input)
+  );
+  if (isBlockedModelCall(next)) {
+    return next;
+  }
+  applyModelCallInput(input, next);
+  return next;
+}
+function wrapModelStream(stream2, input) {
+  const normalizedText = Promise.resolve(stream2.text);
+  const normalizedUsage = Promise.resolve(stream2.usage).then((usage) => ({
+    inputTokens: usage.inputTokens ?? 0,
+    outputTokens: usage.outputTokens ?? 0,
+    totalTokens: usage.totalTokens ?? 0
+  }));
+  const normalizedFinishReason = Promise.resolve(stream2.finishReason).then(
+    (reason) => String(reason)
+  );
+  if (!input.middleware?.hasMiddleware) {
+    return {
+      fullStream: stream2.fullStream,
+      text: normalizedText,
+      usage: normalizedUsage,
+      finishReason: normalizedFinishReason
+    };
+  }
+  return {
+    fullStream: (async function* () {
+      const ctx = buildModelCallContext(input);
+      for await (const rawChunk of stream2.fullStream) {
+        const chunk = await input.middleware.runModelChunk(
+          rawChunk,
+          ctx
+        );
+        if (chunk) {
+          yield chunk;
+        }
+      }
+    })(),
+    text: normalizedText,
+    usage: normalizedUsage,
+    finishReason: normalizedFinishReason
+  };
+}
+async function createCustomStream(input) {
+  const system = input.system.filter(Boolean).join("\n");
+  return input.customStreamProvider({
+    system,
+    messages: input.messages,
+    abortSignal: input.abort,
+    maxSteps: input.maxSteps
+  });
+}
+function getModelInfo(input) {
+  return {
+    provider: typeof input.model === "object" && "provider" in input.model ? String(input.model.provider) : void 0,
+    model: typeof input.model === "object" && "modelId" in input.model ? String(input.model.modelId) : String(input.model)
+  };
+}
+async function callStreamTextWithOtelContext(options) {
+  const { input, allTools, system, providerOptions } = options;
+  const systemParam = input.activeModelCall?.systemMessages?.length ? input.activeModelCall.systemMessages : system;
+  const mergedProviderOptions = mergeProviderOptions(
+    providerOptions,
+    input.activeModelCall?.providerOptions
+  );
+  const callStreamText = () => streamText({
+    model: input.model,
+    system: systemParam,
+    messages: input.messages,
+    tools: allTools,
+    stopWhen: stepCountIs(input.maxSteps ?? 50),
+    maxOutputTokens: input.maxOutputTokens ?? DEFAULT_MAX_OUTPUT_TOKENS,
+    temperature: input.temperature,
+    topP: input.topP,
+    abortSignal: input.abort,
+    providerOptions: mergedProviderOptions,
+    experimental_telemetry: input.telemetry,
+    prepareStep: input.intervention ? async ({ messages }) => {
+      const pending = input.intervention.drainImmediate();
+      if (pending.length === 0) {
+        return void 0;
+      }
+      const injected = pending.map((item) => ({
+        role: "user",
+        content: item.message
+      }));
+      for (const item of pending) {
+        input.intervention.onApplied?.(item);
+      }
+      return { messages: [...messages, ...injected] };
+    } : void 0,
+    onStepFinish: async (step) => {
+      if (!input.onStepFinish) {
+        return;
+      }
+      await input.onStepFinish({
+        toolResults: step.toolResults?.map((toolResult) => ({
+          toolName: toolResult.toolName,
+          toolCallId: toolResult.toolCallId,
+          output: toolResult.output
+        })),
+        usage: step.usage,
+        finishReason: step.finishReason
+      });
+    }
+  });
+  const otelCtx = input.middleware?.getOtelContext(input.sessionID);
+  if (!otelCtx) {
+    return callStreamText();
+  }
+  try {
+    const otelApi = await import("@opentelemetry/api");
+    return otelApi.context.with(
+      otelCtx,
+      callStreamText
+    );
+  } catch {
+    return callStreamText();
+  }
+}
+async function stream(input) {
+  const messageID = crypto.randomUUID();
+  const resolvedInput = await resolveModelCallInput(input);
+  const modelInfo = getModelInfo(input);
+  if (isBlockedModelCall(resolvedInput)) {
+    throw new LLMError({
+      message: resolvedInput.reason,
+      category: "invalid_request",
+      provider: modelInfo.provider,
+      model: modelInfo.model
+    });
+  }
+  const system = input.system.filter(Boolean).join("\n");
+  if (input.customStreamProvider) {
+    const runCustomStream = async () => await createCustomStream(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);
+  }
+  const toolSet = await buildToolSet({
+    tools: input.tools,
+    cwd: input.cwd,
+    sessionID: input.sessionID,
+    messageID,
+    abort: input.abort,
+    turnTracker: input.turnTracker,
+    host: input.host,
+    middleware: input.middleware,
+    executionMode: input.toolExecutionMode
+  });
+  const allTools = {
+    ...toolSet,
+    ...input.mcpTools ?? {}
+  };
+  const providerOptions = input.reasoningLevel ? buildReasoningOptionsSync(input.model, input.reasoningLevel) : void 0;
+  const createStream = async () => {
+    try {
+      return await callStreamTextWithOtelContext({
+        input,
+        allTools,
+        system,
+        providerOptions
+      });
+    } catch (error) {
+      throw LLMError.from(error, modelInfo);
+    }
+  };
+  if (!input.retry || input.retry.maxAttempts === 0) {
+    return wrapModelStream(await createStream(), input);
+  }
+  return wrapModelStream(await withRetry(
+    async () => await createStream(),
+    input.retry,
+    input.abort
+  ), input);
+}
+async function streamOnce(input) {
+  return await stream({ ...input, retry: void 0 });
+}
+async function streamStep(input) {
+  return await stream({
+    ...input,
+    maxSteps: 1
+  });
+}
+
+// src/inference/index.ts
+var Inference = {
+  buildToolSet,
+  stream,
+  streamOnce,
+  streamStep
+};
+var LLM = Inference;
+
+export {
+  buildToolSet,
+  isRetryableCategory,
+  parseRetryDelay,
+  LLMError,
+  isRetryable,
+  getRetryDelay,
+  getErrorCategory,
+  DEFAULT_RETRY_CONFIG,
+  createRetryState,
+  calculateDelay,
+  sleep,
+  withRetry,
+  createRetryHandler,
+  shouldRetry,
+  DEFAULT_MAX_OUTPUT_TOKENS,
+  OUTPUT_TOKEN_MAX,
+  stream,
+  streamOnce,
+  streamStep,
+  Inference,
+  LLM
+};

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

@@ -247,6 +247,7 @@ export {
   estimateTokens,
   estimateMessageTokens,
   estimateConversationTokens,
+  PRUNE_PROTECTED_TOOLS,
   DEFAULT_CONTEXT_LIMITS,
   isContextOverflowing,
   shouldPruneContext,