@cuylabs/agent-core 0.9.0 → 0.10.0

package/dist/chunk-5NVVNXPQ.js

@@ -0,0 +1,288 @@
+import {
+  formatApprovalDeniedReason
+} from "./chunk-V4RFNEET.js";
+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/types/compaction.ts
+var PRUNE_PROTECTED_TOOLS = ["skill"];
+
+// src/tracking/file-tracking.ts
+function extractFilePathsFromArgs(args, meta) {
+  if (!meta.pathArgs || meta.pathArgs.length === 0) {
+    return [];
+  }
+  const paths = [];
+  for (const argName of meta.pathArgs) {
+    const value = args[argName];
+    if (typeof value === "string") {
+      paths.push(value);
+    } else if (Array.isArray(value)) {
+      for (const item of value) {
+        if (typeof item === "string") {
+          paths.push(item);
+        }
+      }
+    }
+  }
+  return paths;
+}
+function shouldCaptureBaseline(meta) {
+  return meta.operationType !== "read";
+}
+
+// src/types/messages.ts
+function accumulateUsage(current, next) {
+  if (!next) return current;
+  if (!current) {
+    return {
+      inputTokens: next.inputTokens ?? 0,
+      outputTokens: next.outputTokens ?? 0,
+      totalTokens: next.totalTokens ?? 0,
+      cacheReadTokens: (next.cacheReadTokens ?? 0) || void 0,
+      cacheWriteTokens: (next.cacheWriteTokens ?? 0) || void 0
+    };
+  }
+  const cacheRead = (current.cacheReadTokens ?? 0) + (next.cacheReadTokens ?? 0);
+  const cacheWrite = (current.cacheWriteTokens ?? 0) + (next.cacheWriteTokens ?? 0);
+  return {
+    inputTokens: (current.inputTokens ?? 0) + (next.inputTokens ?? 0),
+    outputTokens: (current.outputTokens ?? 0) + (next.outputTokens ?? 0),
+    totalTokens: (current.totalTokens ?? 0) + (next.totalTokens ?? 0),
+    cacheReadTokens: cacheRead || void 0,
+    cacheWriteTokens: cacheWrite || void 0
+  };
+}
+
+// src/tool/executor.ts
+import { z } from "zod";
+function parseToolParams(toolName, initialized, params) {
+  try {
+    return initialized.parameters.parse(params);
+  } catch (error) {
+    if (error instanceof z.ZodError && initialized.formatValidationError) {
+      throw new Error(initialized.formatValidationError(error), {
+        cause: error
+      });
+    }
+    throw new Error(
+      `The ${toolName} tool was called with invalid arguments: ${error}.
+Please rewrite the input so it satisfies the expected schema.`,
+      { cause: error }
+    );
+  }
+}
+async function executeAgentToolCall(options) {
+  const toolCallId = options.toolCallId ?? options.messageID;
+  return withinScope(
+    {
+      kind: "tool",
+      name: "tool-call",
+      sessionId: options.sessionID,
+      attributes: {
+        toolName: options.toolName,
+        messageId: options.messageID,
+        toolCallId,
+        agent: options.agent ?? "default"
+      }
+    },
+    async () => {
+      const initialized = options.initialized ?? await options.tool.init({ cwd: options.cwd });
+      const ctx = {
+        cwd: options.cwd,
+        abort: options.abort,
+        sessionID: options.sessionID,
+        ...options.turnID ? { turnID: options.turnID } : {},
+        messageID: options.messageID,
+        agent: options.agent ?? "default",
+        scope: snapshotScope(),
+        ...options.host ? { host: options.host } : {},
+        ...options.humanInputController ? { humanInputController: options.humanInputController } : {},
+        ...options.turnTracker ? { turnTracker: options.turnTracker } : {},
+        ...options.onEvent ? { emitEvent: options.onEvent } : {},
+        ...initialized.capabilities ? { toolCapabilities: initialized.capabilities } : {},
+        ...initialized.hostRequirements ? { hostRequirements: initialized.hostRequirements } : {},
+        ...initialized.permissionPatterns ? { permissionPatterns: initialized.permissionPatterns } : {},
+        extra: {
+          toolCallId
+        }
+      };
+      if (requiresToolHost(initialized.hostRequirements) && !options.host) {
+        return {
+          output: `Tool "${options.toolName}" requires an execution host, but none was configured.`,
+          capabilities: initialized.capabilities
+        };
+      }
+      const parsedParams = parseToolParams(
+        options.toolName,
+        initialized,
+        options.params
+      );
+      if (initialized.validate) {
+        const check = await initialized.validate(parsedParams, ctx);
+        if (!check.ok) {
+          return {
+            output: `Input validation failed for ${options.toolName}: ${check.reason}`,
+            capabilities: initialized.capabilities
+          };
+        }
+      }
+      let effectiveParams = parsedParams;
+      if (options.middleware?.hasMiddleware) {
+        const decision = await options.middleware.runBeforeToolCall(
+          options.toolName,
+          parsedParams,
+          ctx
+        );
+        if (decision.action === "deny") {
+          return {
+            output: decision.reason ?? formatApprovalDeniedReason(options.toolName),
+            ...decision.correction ? {
+              metadata: {
+                approvalCorrection: decision.correction
+              }
+            } : {},
+            capabilities: initialized.capabilities
+          };
+        }
+        if (decision.args !== void 0) {
+          effectiveParams = parseToolParams(
+            options.toolName,
+            initialized,
+            decision.args
+          );
+          if (initialized.validate) {
+            const check = await initialized.validate(effectiveParams, ctx);
+            if (!check.ok) {
+              return {
+                output: `Input validation failed for ${options.toolName}: ${check.reason}`,
+                capabilities: initialized.capabilities
+              };
+            }
+          }
+        }
+      }
+      if (options.turnTracker && initialized.fileOps && shouldCaptureBaseline(initialized.fileOps)) {
+        const paths = extractFilePathsFromArgs(
+          effectiveParams,
+          initialized.fileOps
+        );
+        for (const path of paths) {
+          await options.turnTracker.beforeWrite(path);
+        }
+      }
+      const result = await initialized.execute(effectiveParams, ctx);
+      const metadata = result.metadata ?? {};
+      if (options.middleware?.hasMiddleware) {
+        const transformed = await options.middleware.runAfterToolCall(
+          options.toolName,
+          effectiveParams,
+          { ...result, metadata },
+          ctx
+        );
+        const finalOutput = transformed.supplement ? `${transformed.output}
+
+${transformed.supplement}` : transformed.output;
+        return {
+          output: finalOutput,
+          title: transformed.title,
+          metadata: transformed.metadata ?? {},
+          capabilities: initialized.capabilities
+        };
+      }
+      return {
+        output: result.output,
+        title: result.title,
+        metadata,
+        capabilities: initialized.capabilities
+      };
+    }
+  );
+}
+
+export {
+  currentScope,
+  snapshotScope,
+  withinScope,
+  restoreScope,
+  streamWithinScope,
+  PRUNE_PROTECTED_TOOLS,
+  extractFilePathsFromArgs,
+  shouldCaptureBaseline,
+  accumulateUsage,
+  executeAgentToolCall
+};

package/dist/{chunk-EKR6PKXU.js → chunk-6HZBHFOL.js}

@@ -1,4 +1,4 @@
-// src/presets/builtins.ts
+// src/profiles/builtins.ts
 var explore = {
   name: "explore",
   description: "Read-only exploration mode for understanding content",
@@ -158,7 +158,7 @@ Guidelines:
   maxSteps: 10,
   reasoningLevel: "low"
 };
-var Presets = {
+var Profiles = {
   explore,
   plan,
   review,
@@ -176,5 +176,5 @@ export {
   careful,
   code,
   watch,
-  Presets
+  Profiles
 };

package/dist/chunk-CJI7PVS2.js

@@ -0,0 +1,58 @@
+// src/middleware/types.ts
+function isBlockedModelCall(value) {
+  return "block" in value && value.block === true;
+}
+
+// src/agent/defaults.ts
+var DEFAULT_SYSTEM_PROMPT = `You are a capable AI assistant with access to tools.
+
+Think step by step about what you need to do.
+Use the available tools to accomplish tasks.
+Verify your results after each action.
+
+If a tool fails, try an alternative approach \u2014 do not give up after a single error.
+Keep working until the task is fully resolved or you have exhausted all options.`;
+var DEFAULT_AGENT_NAME = "agent";
+var DEFAULT_MAX_STEPS = 50;
+var DEFAULT_MAX_TOKENS = 32e3;
+function resolveAgentDefaults(context, providers) {
+  let merged = {
+    systemPrompt: DEFAULT_SYSTEM_PROMPT,
+    maxSteps: DEFAULT_MAX_STEPS,
+    maxOutputTokens: DEFAULT_MAX_TOKENS
+  };
+  if (providers) {
+    for (const provider of providers) {
+      const overrides = provider(context);
+      if (overrides) {
+        merged = {
+          systemPrompt: overrides.systemPrompt ?? merged.systemPrompt,
+          maxSteps: overrides.maxSteps ?? merged.maxSteps,
+          maxOutputTokens: overrides.maxOutputTokens ?? merged.maxOutputTokens
+        };
+      }
+    }
+  }
+  return merged;
+}
+function sandboxDefaultsProvider(context) {
+  const sandbox = context.sandbox;
+  if (!sandbox) {
+    return void 0;
+  }
+  const managed = sandbox.metadata?.managed === true;
+  if (managed) {
+    return { maxSteps: 100 };
+  }
+  return void 0;
+}
+
+export {
+  isBlockedModelCall,
+  DEFAULT_SYSTEM_PROMPT,
+  DEFAULT_AGENT_NAME,
+  DEFAULT_MAX_STEPS,
+  DEFAULT_MAX_TOKENS,
+  resolveAgentDefaults,
+  sandboxDefaultsProvider
+};

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

@@ -1,16 +1,23 @@
 import {
-  executeAgentToolCall
-} from "./chunk-H3FUYU52.js";
+  executeAgentToolCall,
+  snapshotScope
+} from "./chunk-5NVVNXPQ.js";
 import {
   LLMError,
   isRetryable
-} from "./chunk-4QFNWPIF.js";
+} from "./chunk-N3VX7FEE.js";
 import {
-  snapshotScope
-} from "./chunk-N7P4PN3O.js";
+  buildReasoningOptionsSync,
+  supportsReasoningSync
+} from "./chunk-RN6WZEUF.js";
 import {
-  buildReasoningOptionsSync
-} from "./chunk-UDCZ673N.js";
+  DEFAULT_MAX_STEPS,
+  DEFAULT_MAX_TOKENS,
+  isBlockedModelCall
+} from "./chunk-CJI7PVS2.js";
+import {
+  formatApprovalDeniedReason
+} from "./chunk-V4RFNEET.js";
 
 // src/inference/toolset.ts
 import { tool, zodSchema } from "ai";
@@ -19,26 +26,58 @@ async function buildToolSet(options) {
   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,
-        initialized,
-        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)
-    });
+    const sdkPassthrough = {};
+    if (initialized.title !== void 0) sdkPassthrough.title = initialized.title;
+    if (initialized.strict !== void 0) sdkPassthrough.strict = initialized.strict;
+    if (initialized.inputExamples !== void 0) {
+      sdkPassthrough.inputExamples = initialized.inputExamples;
+    }
+    if (initialized.toModelOutput !== void 0) {
+      sdkPassthrough.toModelOutput = initialized.toModelOutput;
+    }
+    if (executionMode === "auto") {
+      toolSet[id] = tool({
+        description: initialized.description,
+        inputSchema: zodSchema(initialized.parameters),
+        ...sdkPassthrough,
+        execute: async (params, sdkOptions) => {
+          const executed = await executeAgentToolCall({
+            toolName: id,
+            tool: info,
+            initialized,
+            params,
+            cwd: options.cwd,
+            abort: options.abort,
+            sessionID: options.sessionID,
+            turnID: options.turnID,
+            messageID: options.messageID,
+            toolCallId: sdkOptions.toolCallId,
+            ...options.host ? { host: options.host } : {},
+            ...options.humanInputController ? { humanInputController: options.humanInputController } : {},
+            ...options.turnTracker ? { turnTracker: options.turnTracker } : {},
+            ...options.middleware ? { middleware: options.middleware } : {},
+            ...options.onEvent ? { onEvent: options.onEvent } : {}
+          });
+          if (!executed.metadata?.approvalCorrection) {
+            return executed.output;
+          }
+          const structured = {
+            __cuylabsAgentToolResult: true,
+            output: executed.output,
+            metadata: executed.metadata
+          };
+          return structured;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      });
+    } else {
+      toolSet[id] = tool({
+        description: initialized.description,
+        inputSchema: zodSchema(initialized.parameters),
+        ...sdkPassthrough
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      });
+    }
   }
   return toolSet;
 }
@@ -95,7 +134,7 @@ function mergeProviderOptions(base, override) {
   return merged;
 }
 function wrapMcpToolsForMiddleware(options) {
-  const { tools, middleware, cwd, sessionID, abort, agent } = options;
+  const { tools, middleware, cwd, sessionID, turnID, abort, agent } = options;
   if (!middleware?.hasMiddleware) {
     return tools;
   }
@@ -112,6 +151,7 @@ function wrapMcpToolsForMiddleware(options) {
           cwd,
           abort: execOptions.abortSignal ?? abort,
           sessionID,
+          ...turnID ? { turnID } : {},
           messageID: execOptions.toolCallId,
           agent: agent ?? "default",
           scope: snapshotScope(),
@@ -127,7 +167,7 @@ function wrapMcpToolsForMiddleware(options) {
           ctx
         );
         if (decision.action === "deny") {
-          return decision.reason ?? `Tool call denied: ${toolName}`;
+          return decision.reason ?? formatApprovalDeniedReason(toolName);
         }
         const result = tool2.execute(params, execOptions);
         if (isAsyncIterable(result)) {
@@ -247,14 +287,11 @@ function shouldRetry(error, attempt, maxAttempts = DEFAULT_RETRY_CONFIG.maxAttem
   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,
+    turnID: input.turnID,
     step: input.step ?? 1,
     cwd: input.cwd,
     abort: input.abort,
@@ -295,9 +332,6 @@ function applyModelCallInput(target, modelCall) {
   target.toolExecutionMode = modelCall.toolExecutionMode;
   target.activeModelCall = modelCall;
 }
-function isBlockedModelCall(value) {
-  return "block" in value && value.block === true;
-}
 async function resolveModelCallInput(input) {
   if (!input.middleware?.hasMiddleware) {
     const current = buildModelCallInput(input);
@@ -377,10 +411,12 @@ async function callStreamTextWithOtelContext(options) {
     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,
+    ...input.toolChoice ? { toolChoice: input.toolChoice } : {},
+    ...input.activeTools ? { activeTools: input.activeTools } : {},
+    stopWhen: stepCountIs(input.maxSteps ?? DEFAULT_MAX_STEPS),
+    maxOutputTokens: input.maxOutputTokens ?? DEFAULT_MAX_TOKENS,
+    ...input.temperature !== void 0 && !supportsReasoningSync(input.model) ? { temperature: input.temperature } : {},
+    ...input.topP !== void 0 && !supportsReasoningSync(input.model) ? { topP: input.topP } : {},
     abortSignal: input.abort,
     providerOptions: mergedProviderOptions,
     experimental_telemetry: input.telemetry,
@@ -418,7 +454,10 @@ async function callStreamTextWithOtelContext(options) {
       });
     }
   });
-  const otelCtx = input.middleware?.getOtelContext(input.sessionID);
+  const otelCtx = input.middleware?.getOtelContext(input.sessionID, {
+    sessionId: input.sessionID,
+    ...input.turnID ? { turnId: input.turnID } : {}
+  });
   if (!otelCtx) {
     return callStreamText();
   }
@@ -463,11 +502,14 @@ async function stream(input) {
     tools: input.tools,
     cwd: input.cwd,
     sessionID: input.sessionID,
+    turnID: input.turnID,
     messageID,
     abort: input.abort,
     turnTracker: input.turnTracker,
     host: input.host,
+    humanInputController: input.humanInputController,
     middleware: input.middleware,
+    onEvent: input.onEvent,
     executionMode: input.toolExecutionMode
   });
   const mcpToolSet = wrapMcpToolsForMiddleware({
@@ -475,6 +517,7 @@ async function stream(input) {
     middleware: input.middleware,
     cwd: input.cwd,
     sessionID: input.sessionID,
+    turnID: input.turnID,
     abort: input.abort
   });
   const allTools = {
@@ -512,16 +555,75 @@ async function streamStep(input) {
   });
 }
 
+// src/inference/model-messages.ts
+function buildApprovalCorrectionPrompt(correction) {
+  const lines = [
+    `Human approval denied the previous ${correction.tool} tool call.`,
+    `Treat this as corrective guidance and revise the plan before attempting another action.`,
+    `Reason: ${correction.reason}`
+  ];
+  if (correction.feedback) {
+    lines.push(`Feedback: ${correction.feedback}`);
+  }
+  return {
+    role: "system",
+    content: lines.join("\n")
+  };
+}
+function convertAgentMessagesToModelMessages(messages) {
+  return messages.flatMap((message) => {
+    switch (message.role) {
+      case "user":
+        return [{ role: "user", content: message.content }];
+      case "assistant": {
+        if (message.toolCalls && message.toolCalls.length > 0) {
+          const toolCallParts = message.toolCalls.map(
+            (toolCall) => ({
+              type: "tool-call",
+              toolCallId: toolCall.toolCallId,
+              toolName: toolCall.toolName,
+              input: toolCall.args
+            })
+          );
+          return [{ role: "assistant", content: toolCallParts }];
+        }
+        return [{ role: "assistant", content: message.content }];
+      }
+      case "tool":
+        return [
+          {
+            role: "tool",
+            content: [
+              {
+                type: "tool-result",
+                toolCallId: message.toolCallId ?? "",
+                toolName: message.toolName ?? "",
+                output: {
+                  type: "text",
+                  value: typeof message.result === "string" ? message.result : JSON.stringify(message.result)
+                }
+              }
+            ]
+          },
+          ...message.metadata?.approvalCorrection ? [buildApprovalCorrectionPrompt(message.metadata.approvalCorrection)] : []
+        ];
+      case "system":
+        return [{ role: "system", content: message.content }];
+    }
+  });
+}
+
 // src/inference/index.ts
 var Inference = {
+  buildModelCallContext,
   buildToolSet,
   stream,
   streamOnce,
   streamStep
 };
-var LLM = Inference;
 
 export {
+  convertAgentMessagesToModelMessages,
   buildToolSet,
   DEFAULT_RETRY_CONFIG,
   createRetryState,
@@ -530,11 +632,9 @@ export {
   withRetry,
   createRetryHandler,
   shouldRetry,
-  DEFAULT_MAX_OUTPUT_TOKENS,
-  OUTPUT_TOKEN_MAX,
+  buildModelCallContext,
   stream,
   streamOnce,
   streamStep,
-  Inference,
-  LLM
+  Inference
 };