@cuylabs/agent-core 0.8.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-CAA7FHIH.js → chunk-6HZBHFOL.js}

@@ -1,100 +1,4 @@
-// src/presets/patterns.ts
-function globToRegex(pattern) {
-  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
-  return new RegExp(`^${escaped}$`, "i");
-}
-function matchesPatterns(id, patterns) {
-  return patterns.some((pattern) => globToRegex(pattern).test(id));
-}
-function filterTools(tools, options) {
-  const allowPatterns = options.allow ?? [];
-  const denyPatterns = options.deny ?? [];
-  return tools.filter((tool) => {
-    const matchesAllow = allowPatterns.length === 0 || matchesPatterns(tool.id, allowPatterns);
-    if (!matchesAllow) {
-      return false;
-    }
-    const matchesDeny = denyPatterns.length > 0 && matchesPatterns(tool.id, denyPatterns);
-    if (matchesDeny && allowPatterns.length === 0) {
-      return false;
-    }
-    return true;
-  });
-}
-
-// src/presets/apply.ts
-function applyPreset(preset, availableTools, baseSystemPrompt) {
-  const tools = filterTools(availableTools, {
-    allow: preset.allowTools,
-    deny: preset.denyTools
-  });
-  let systemPrompt = preset.systemPrompt;
-  if (systemPrompt && baseSystemPrompt) {
-    systemPrompt = systemPrompt.replace("{basePrompt}", baseSystemPrompt);
-  }
-  return {
-    name: preset.name,
-    systemPrompt,
-    tools: tools.length > 0 ? tools : void 0,
-    temperature: preset.temperature,
-    maxSteps: preset.maxSteps,
-    reasoningLevel: preset.reasoningLevel,
-    model: preset.model
-  };
-}
-function mergePresets(...presets) {
-  if (presets.length === 0) {
-    throw new Error("mergePresets requires at least one preset");
-  }
-  if (presets.length === 1) {
-    return presets[0];
-  }
-  const [first, ...rest] = presets;
-  const allAllow = [];
-  const allDeny = [];
-  for (const preset of presets) {
-    if (preset.allowTools?.length) {
-      allAllow.push(preset.allowTools);
-    }
-    if (preset.denyTools?.length) {
-      allDeny.push(...preset.denyTools);
-    }
-  }
-  const combinedAllow = allAllow.length > 0 ? allAllow.reduce(
-    (left, right) => left.length <= right.length ? left : right
-  ) : void 0;
-  return {
-    name: presets.map((preset) => preset.name).join("+"),
-    description: presets.map((preset) => preset.description).join(" | "),
-    allowTools: combinedAllow,
-    denyTools: allDeny.length > 0 ? [...new Set(allDeny)] : void 0,
-    systemPrompt: rest.reduce(
-      (value, preset) => preset.systemPrompt ?? value,
-      first.systemPrompt
-    ),
-    temperature: rest.reduce(
-      (value, preset) => preset.temperature ?? value,
-      first.temperature
-    ),
-    maxSteps: rest.reduce(
-      (value, preset) => preset.maxSteps ?? value,
-      first.maxSteps
-    ),
-    reasoningLevel: rest.reduce(
-      (value, preset) => preset.reasoningLevel ?? value,
-      first.reasoningLevel
-    ),
-    model: rest.reduce((value, preset) => preset.model ?? value, first.model)
-  };
-}
-function createPreset(options) {
-  return {
-    description: options.description ?? `Custom preset: ${options.name}`,
-    ...options
-  };
-}
-
-// src/presets/builtins.ts
+// src/profiles/builtins.ts
 var explore = {
   name: "explore",
   description: "Read-only exploration mode for understanding content",
@@ -254,7 +158,7 @@ Guidelines:
   maxSteps: 10,
   reasoningLevel: "low"
 };
-var Presets = {
+var Profiles = {
   explore,
   plan,
   review,
@@ -265,10 +169,6 @@ var Presets = {
 };
 
 export {
-  filterTools,
-  applyPreset,
-  mergePresets,
-  createPreset,
   explore,
   plan,
   review,
@@ -276,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
+};