@cuylabs/agent-core 0.6.0 → 0.8.0

package/dist/chunk-N6HWIEEA.js

@@ -0,0 +1,423 @@
+import {
+  executeAgentToolCall
+} from "./chunk-7VKQ4WPB.js";
+import {
+  buildReasoningOptionsSync
+} from "./chunk-SQU2AJHO.js";
+import {
+  snapshotScope
+} from "./chunk-N7P4PN3O.js";
+import {
+  LLMError,
+  isRetryable
+} from "./chunk-RZITT45F.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/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,
+  DEFAULT_RETRY_CONFIG,
+  createRetryState,
+  calculateDelay,
+  sleep,
+  withRetry,
+  createRetryHandler,
+  shouldRetry,
+  DEFAULT_MAX_OUTPUT_TOKENS,
+  OUTPUT_TOKEN_MAX,
+  stream,
+  streamOnce,
+  streamStep,
+  Inference,
+  LLM
+};

package/dist/chunk-N7P4PN3O.js

@@ -0,0 +1,84 @@
+// src/scope/store.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { randomUUID } from "crypto";
+var scopeStore = new AsyncLocalStorage();
+function cloneAttributes(attributes) {
+  return { ...attributes };
+}
+function cloneScope(scope) {
+  return {
+    ...scope,
+    attributes: cloneAttributes(scope.attributes)
+  };
+}
+function getStoredScope() {
+  return scopeStore.getStore();
+}
+function buildScope(options, current) {
+  const parent = options.parent === void 0 ? current : options.parent ?? void 0;
+  const id = options.id ?? randomUUID();
+  return {
+    id,
+    rootId: parent?.rootId ?? id,
+    kind: options.kind,
+    name: options.name,
+    parentId: parent?.id,
+    depth: (parent?.depth ?? -1) + 1,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    sessionId: options.sessionId ?? parent?.sessionId,
+    taskId: options.taskId ?? parent?.taskId,
+    step: options.step ?? parent?.step,
+    attributes: cloneAttributes(options.attributes ?? {})
+  };
+}
+function runWithScope(scope, fn) {
+  return Promise.resolve(scopeStore.run(scope, fn));
+}
+
+// src/scope/run.ts
+function currentScope() {
+  const scope = getStoredScope();
+  return scope ? cloneScope(scope) : void 0;
+}
+function snapshotScope(scope = getStoredScope()) {
+  return scope ? cloneScope(scope) : void 0;
+}
+function createScope(options) {
+  return buildScope(options, getStoredScope());
+}
+function withinScope(options, fn) {
+  return runWithScope(buildScope(options, getStoredScope()), fn);
+}
+function restoreScope(snapshot, fn) {
+  if (!snapshot) {
+    return Promise.resolve(fn());
+  }
+  return runWithScope(cloneScope(snapshot), fn);
+}
+async function* streamWithinScope(options, iterable) {
+  const scope = buildScope(options, getStoredScope());
+  const iterator = await runWithScope(scope, () => iterable[Symbol.asyncIterator]());
+  try {
+    while (true) {
+      const next = await runWithScope(scope, () => iterator.next());
+      if (next.done) {
+        return next.value;
+      }
+      yield next.value;
+    }
+  } finally {
+    const returnFn = iterator.return?.bind(iterator);
+    if (returnFn) {
+      await runWithScope(scope, () => returnFn(void 0));
+    }
+  }
+}
+
+export {
+  currentScope,
+  snapshotScope,
+  createScope,
+  withinScope,
+  restoreScope,
+  streamWithinScope
+};