@cuylabs/agent-core 4.9.0 → 5.0.0

package/dist/chunk-JFH6HBUG.js

@@ -0,0 +1,227 @@
+import {
+  advanceAgentTurnState,
+  createAgentTurnState,
+  failAgentTurnState
+} from "./chunk-E66PKKDL.js";
+import {
+  currentScope,
+  snapshotScope,
+  withinScope
+} from "./chunk-AHDCR7SX.js";
+import {
+  silentLogger
+} from "./chunk-S6AKEPAX.js";
+
+// src/execution/task/observer.ts
+function defaultAgentTaskCheckpointStrategy(input) {
+  switch (input.event.type) {
+    case "step-finish":
+      return "step-finish";
+    case "tool-result":
+      return "tool-result";
+    case "tool-error":
+      return "tool-error";
+    case "turn-boundary":
+      return input.event.boundary;
+    case "complete":
+      return "task-complete";
+    default:
+      return void 0;
+  }
+}
+
+// src/execution/task/runner.ts
+import { randomUUID } from "crypto";
+function normalizeNonEmpty(value, label) {
+  const normalized = value.trim();
+  if (!normalized) {
+    throw new Error(`${label} must not be empty`);
+  }
+  return normalized;
+}
+function sanitizeSegment(input) {
+  return input.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function buildRuntimeSessionId(prefix, key) {
+  const timestamp = Date.now().toString(36);
+  const suffix = randomUUID().slice(0, 8);
+  const normalizedPrefix = sanitizeSegment(prefix) || "runtime";
+  const normalizedKey = key ? sanitizeSegment(key) : "";
+  if (normalizedKey) {
+    return `${normalizedPrefix}:${normalizedKey}:${timestamp}:${suffix}`;
+  }
+  return `${normalizedPrefix}:${timestamp}:${suffix}`;
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+async function notifyObservers(observers, invoke, logger) {
+  for (const observer of observers) {
+    try {
+      await invoke(observer);
+    } catch (error) {
+      logger.warn("observer error", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+}
+function createAgentTaskRunner(agent, options = {}) {
+  const prefix = options.sessionPrefix ?? "runtime";
+  const baseObservers = options.observers ?? [];
+  const checkpointStrategy = options.checkpointStrategy ?? defaultAgentTaskCheckpointStrategy;
+  const log = options.logger?.child("task-runner") ?? silentLogger;
+  return async (payload, context = {}) => {
+    const message = normalizeNonEmpty(payload.message, "payload.message");
+    const resolvedSessionId = payload.sessionId?.trim() || options.resolveSessionId?.(payload, context)?.trim() || buildRuntimeSessionId(prefix, context.fallbackSessionKey);
+    const sessionId = normalizeNonEmpty(resolvedSessionId, "sessionId");
+    const startedAt = nowIso();
+    const executionId = context.executionId?.trim() || `${sessionId}:${startedAt}`;
+    return withinScope(
+      {
+        kind: "task",
+        name: "agent-task",
+        sessionId,
+        taskId: context.fallbackSessionKey ?? sessionId,
+        attributes: {
+          ...context.trigger ? { trigger: context.trigger } : {}
+        }
+      },
+      async () => {
+        const run = {
+          payload,
+          context,
+          sessionId,
+          executionId,
+          startedAt: context.restoreFrom?.startedAt ?? startedAt,
+          scope: snapshotScope()
+        };
+        const toolCalls = context.restoreFrom?.toolCalls.map((tc) => ({ ...tc })) ?? [];
+        let turnState = createAgentTurnState({
+          sessionId,
+          startedAt: context.restoreFrom?.startedAt ?? startedAt,
+          restoreFrom: context.restoreFrom ? {
+            response: context.restoreFrom.response,
+            usage: { ...context.restoreFrom.usage },
+            step: context.restoreFrom.step,
+            eventCount: context.restoreFrom.eventCount
+          } : void 0
+        });
+        const createSnapshot = () => ({
+          sessionId,
+          response: turnState.response,
+          usage: { ...turnState.usage },
+          toolCalls: toolCalls.map((toolCall) => ({ ...toolCall })),
+          eventCount: turnState.eventCount,
+          activeStep: turnState.step > 0 ? turnState.step : void 0,
+          lastEvent: turnState.lastEvent,
+          error: turnState.error,
+          startedAt: turnState.startedAt,
+          updatedAt: turnState.updatedAt,
+          turnState,
+          scope: currentScope() ?? run.scope
+        });
+        const emitCheckpoint = async (reason, event) => {
+          if (baseObservers.length === 0) {
+            return;
+          }
+          const checkpoint = {
+            run,
+            reason,
+            snapshot: createSnapshot(),
+            event,
+            createdAt: turnState.updatedAt
+          };
+          await notifyObservers(
+            baseObservers,
+            async (observer) => {
+              await observer.onCheckpoint?.(checkpoint);
+            },
+            log
+          );
+        };
+        await notifyObservers(
+          baseObservers,
+          async (observer) => {
+            await observer.onTaskStart?.(run, createSnapshot());
+          },
+          log
+        );
+        await emitCheckpoint("task-start");
+        const activateCtx = baseObservers.find((o) => o.activateContext)?.activateContext?.bind(void 0, sessionId, executionId);
+        try {
+          const processChatStream = async () => {
+            for await (const event of agent.chat(sessionId, message, {
+              abort: context.signal,
+              system: payload.system
+            })) {
+              turnState = advanceAgentTurnState(turnState, event, nowIso());
+              if (event.type === "tool-result") {
+                toolCalls.push({ name: event.toolName, result: event.result });
+              }
+              const snapshot = createSnapshot();
+              await notifyObservers(
+                baseObservers,
+                async (observer) => {
+                  await observer.onTaskEvent?.(run, event, snapshot);
+                },
+                log
+              );
+              const checkpointReason = checkpointStrategy({
+                run,
+                event,
+                snapshot
+              });
+              if (checkpointReason) {
+                await emitCheckpoint(checkpointReason, event);
+              }
+              if (event.type === "error") {
+                throw event.error;
+              }
+            }
+          };
+          if (activateCtx) {
+            await activateCtx(processChatStream);
+          } else {
+            await processChatStream();
+          }
+          const result = {
+            response: turnState.response,
+            sessionId,
+            usage: { ...turnState.usage },
+            toolCalls
+          };
+          await notifyObservers(
+            baseObservers,
+            async (observer) => {
+              await observer.onTaskComplete?.(run, result, createSnapshot());
+            },
+            log
+          );
+          return result;
+        } catch (error) {
+          const normalizedError = error instanceof Error ? error : new Error(String(error));
+          turnState = failAgentTurnState(turnState, normalizedError, nowIso());
+          await notifyObservers(
+            baseObservers,
+            async (observer) => {
+              await observer.onTaskError?.(
+                run,
+                normalizedError,
+                createSnapshot()
+              );
+            },
+            log
+          );
+          await emitCheckpoint("task-error");
+          throw normalizedError;
+        }
+      }
+    );
+  };
+}
+
+export {
+  defaultAgentTaskCheckpointStrategy,
+  createAgentTaskRunner
+};

package/dist/{chunk-MWPU2EVV.js → chunk-JUIL2NJC.js}

@@ -1,3 +1,7 @@
+import {
+  snapshotScope,
+  withinScope
+} from "./chunk-AHDCR7SX.js";
 import {
   formatApprovalDeniedReason
 } from "./chunk-T33MQXUP.js";
@@ -5,82 +9,6 @@ import {
   requiresToolHost
 } from "./chunk-FII65CN7.js";
 
-// 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 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));
-    }
-  }
-}
-
 // src/tracking/file-tracking.ts
 function extractFilePathsFromArgs(args, meta) {
   if (!meta.pathArgs || meta.pathArgs.length === 0) {
@@ -252,11 +180,6 @@ ${transformed.supplement}` : transformed.output;
 }
 
 export {
-  currentScope,
-  snapshotScope,
-  withinScope,
-  restoreScope,
-  streamWithinScope,
   extractFilePathsFromArgs,
   shouldCaptureBaseline,
   executeAgentToolCall

package/dist/{chunk-NS7D7JJU.js → chunk-K453AFTL.js}

@@ -1,26 +1,35 @@
-import {
-  executeAgentToolCall,
-  snapshotScope
-} from "./chunk-MWPU2EVV.js";
 import {
   LLMError,
   isRetryable
 } from "./chunk-STDJYXYK.js";
 import {
-  buildReasoningOptionsSync,
-  supportsReasoningSync
-} from "./chunk-GJFP5L2V.js";
+  executeAgentToolCall
+} from "./chunk-JUIL2NJC.js";
+import {
+  snapshotScope
+} from "./chunk-AHDCR7SX.js";
 import {
-  DEFAULT_MAX_STEPS,
-  DEFAULT_MAX_TOKENS,
   isBlockedModelCall
-} from "./chunk-CJI7PVS2.js";
+} from "./chunk-W6LWIMIX.js";
+import {
+  buildReasoningOptionsSync,
+  supportsReasoningSync
+} from "./chunk-CNM6OROH.js";
 import {
   formatApprovalDeniedReason
 } from "./chunk-T33MQXUP.js";
 
 // src/inference/toolset.ts
-import { tool, zodSchema } from "ai";
+import {
+  tool,
+  zodSchema
+} from "ai";
+function defineExecutableAiSdkTool(definition) {
+  return tool(definition);
+}
+function defineDeferredAiSdkTool(definition) {
+  return tool(definition);
+}
 async function buildToolSet(options) {
   const toolSet = {};
   const executionMode = options.executionMode ?? "auto";
@@ -29,6 +38,9 @@ async function buildToolSet(options) {
     const sdkPassthrough = {};
     if (initialized.title !== void 0)
       sdkPassthrough.title = initialized.title;
+    if (initialized.providerOptions !== void 0) {
+      sdkPassthrough.providerOptions = initialized.providerOptions;
+    }
     if (initialized.strict !== void 0)
       sdkPassthrough.strict = initialized.strict;
     if (initialized.inputExamples !== void 0) {
@@ -38,7 +50,7 @@ async function buildToolSet(options) {
       sdkPassthrough.toModelOutput = initialized.toModelOutput;
     }
     if (executionMode === "auto") {
-      toolSet[id] = tool({
+      toolSet[id] = defineExecutableAiSdkTool({
         description: initialized.description,
         inputSchema: zodSchema(initialized.parameters),
         ...sdkPassthrough,
@@ -70,14 +82,12 @@ async function buildToolSet(options) {
           };
           return structured;
         }
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
       });
     } else {
-      toolSet[id] = tool({
+      toolSet[id] = defineDeferredAiSdkTool({
         description: initialized.description,
         inputSchema: zodSchema(initialized.parameters),
         ...sdkPassthrough
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
       });
     }
   }
@@ -289,6 +299,10 @@ function shouldRetry(error, attempt, maxAttempts = DEFAULT_RETRY_CONFIG.maxAttem
   return isRetryable(error);
 }
 
+// src/inference/defaults.ts
+var DEFAULT_MAX_STEPS = 50;
+var DEFAULT_MAX_OUTPUT_TOKENS = 32e3;
+
 // src/inference/stream.ts
 function buildModelCallContext(input) {
   return {
@@ -414,6 +428,9 @@ function wrapModelStream(stream2, input) {
 async function createCustomStream(input) {
   const system = input.system.filter(Boolean).join("\n");
   return input.customStreamProvider({
+    sessionID: input.sessionID,
+    turnID: input.turnID,
+    step: input.step,
     system,
     messages: input.messages,
     abortSignal: input.abort,
@@ -441,7 +458,7 @@ async function callStreamTextWithOtelContext(options) {
     ...input.toolChoice ? { toolChoice: input.toolChoice } : {},
     ...input.activeTools ? { activeTools: input.activeTools } : {},
     stopWhen: stepCountIs(input.maxSteps ?? DEFAULT_MAX_STEPS),
-    maxOutputTokens: input.maxOutputTokens ?? DEFAULT_MAX_TOKENS,
+    maxOutputTokens: input.maxOutputTokens ?? DEFAULT_MAX_OUTPUT_TOKENS,
     ...input.temperature !== void 0 && !supportsReasoningSync(input.model) ? { temperature: input.temperature } : {},
     ...input.topP !== void 0 && !supportsReasoningSync(input.model) ? { topP: input.topP } : {},
     abortSignal: input.abort,
@@ -654,6 +671,8 @@ var Inference = {
 };
 
 export {
+  DEFAULT_MAX_STEPS,
+  DEFAULT_MAX_OUTPUT_TOKENS,
   convertAgentMessagesToModelMessages,
   buildToolSet,
   DEFAULT_RETRY_CONFIG,