@cuylabs/agent-core 0.5.0 → 0.7.0

package/dist/{chunk-OTUGSCED.js → chunk-CDTV2UYU.js}

@@ -1,4 +1,7 @@
 // src/middleware/runner.ts
+function isBlockedModelCall(value) {
+  return "block" in value && value.block === true;
+}
 var MiddlewareRunner = class {
   stack;
   constructor(middleware = []) {
@@ -17,6 +20,76 @@ var MiddlewareRunner = class {
     return this.stack;
   }
   // --------------------------------------------------------------------------
+  // model.input — array order, first block wins
+  // --------------------------------------------------------------------------
+  async runModelInput(input, ctx) {
+    let current = input;
+    for (const mw of this.stack) {
+      if (!mw.model?.input) continue;
+      try {
+        const next = await mw.model.input(current, ctx);
+        if (!next) continue;
+        if (isBlockedModelCall(next)) {
+          return next;
+        }
+        current = next;
+      } catch (err) {
+        return {
+          block: true,
+          reason: `Middleware "${mw.name}" model input error: ${err instanceof Error ? err.message : String(err)}`
+        };
+      }
+    }
+    return current;
+  }
+  // --------------------------------------------------------------------------
+  // model.chunk — array order, streamed transformation
+  // --------------------------------------------------------------------------
+  async runModelChunk(chunk, ctx) {
+    let current = chunk;
+    for (const mw of this.stack) {
+      if (!mw.model?.chunk || current === null) continue;
+      try {
+        const next = await mw.model.chunk(current, ctx);
+        if (next === null) {
+          current = null;
+          continue;
+        }
+        if (next !== void 0) {
+          current = next;
+        }
+      } catch (err) {
+        console.warn(
+          `[middleware] "${mw.name}" model.chunk error:`,
+          err instanceof Error ? err.message : String(err)
+        );
+      }
+    }
+    return current ?? void 0;
+  }
+  // --------------------------------------------------------------------------
+  // model.output — reverse order (innermost first)
+  // --------------------------------------------------------------------------
+  async runModelOutput(output, ctx) {
+    let current = output;
+    for (let i = this.stack.length - 1; i >= 0; i--) {
+      const mw = this.stack[i];
+      if (!mw.model?.output) continue;
+      try {
+        const next = await mw.model.output(current, ctx);
+        if (next) {
+          current = next;
+        }
+      } catch (err) {
+        console.warn(
+          `[middleware] "${mw.name}" model.output error:`,
+          err instanceof Error ? err.message : String(err)
+        );
+      }
+    }
+    return current;
+  }
+  // --------------------------------------------------------------------------
   // beforeToolCall — array order, first "deny" wins
   // --------------------------------------------------------------------------
   /**
@@ -679,6 +752,90 @@ async function createAndRegisterProvider(spanProcessor, serviceName) {
   return provider;
 }
 
+// src/middleware/prompt-cache/cache.ts
+var MAX_ANTHROPIC_BREAKPOINTS = 4;
+var DEFAULT_TTL = "5m";
+var DEFAULT_MESSAGE_BREAKPOINTS = 1;
+function isAnthropicModel(model) {
+  if (typeof model === "object" && model !== null) {
+    if ("provider" in model && typeof model.provider === "string") {
+      if (model.provider.toLowerCase().startsWith("anthropic")) return true;
+    }
+    if ("modelId" in model && typeof model.modelId === "string") {
+      if (/claude/i.test(model.modelId)) return true;
+    }
+  }
+  return false;
+}
+function buildCacheControl(ttl) {
+  return {
+    anthropic: {
+      cacheControl: { type: "ephemeral", ttl }
+    }
+  };
+}
+function buildCachedSystemMessages(system, ttl) {
+  const filtered = system.filter(Boolean);
+  if (filtered.length === 0) return [];
+  return filtered.map((content, i) => {
+    const isLast = i === filtered.length - 1;
+    const msg = {
+      role: "system",
+      content
+    };
+    if (isLast) {
+      msg.providerOptions = buildCacheControl(ttl);
+    }
+    return msg;
+  });
+}
+function findMessageBreakpointIndices(messages, count) {
+  if (count <= 0 || messages.length < 2) return [];
+  const indices = [];
+  for (let i = messages.length - 2; i >= 0 && indices.length < count; i--) {
+    const msg = messages[i];
+    if (msg.role === "user" || msg.role === "assistant") {
+      indices.push(i);
+    }
+  }
+  return indices;
+}
+function promptCacheMiddleware(config) {
+  const ttl = config?.ttl ?? DEFAULT_TTL;
+  const maxMsgBreakpoints = Math.min(
+    config?.messageBreakpoints ?? DEFAULT_MESSAGE_BREAKPOINTS,
+    MAX_ANTHROPIC_BREAKPOINTS - 1
+    // Reserve 1 for system
+  );
+  return {
+    name: "prompt-cache",
+    model: {
+      async input(input, _ctx) {
+        if (!isAnthropicModel(input.model)) return;
+        const hasSystem = input.system.some((s) => s.length > 0);
+        if (hasSystem) {
+          input.systemMessages = buildCachedSystemMessages(input.system, ttl);
+        }
+        if (maxMsgBreakpoints > 0) {
+          const breakpointIndices = findMessageBreakpointIndices(
+            input.messages,
+            maxMsgBreakpoints
+          );
+          const cacheControl = buildCacheControl(ttl);
+          for (const idx of breakpointIndices) {
+            const msg = input.messages[idx];
+            msg.providerOptions = {
+              ...msg.providerOptions,
+              ...cacheControl
+            };
+          }
+        }
+        return input;
+      }
+    }
+  };
+}
+
 export {
   MiddlewareRunner,
   otelMiddleware,
@@ -687,5 +844,6 @@ export {
   ApprovalDeniedError,
   ApprovalTimeoutError,
   createApprovalHandler,
-  approvalMiddleware
+  approvalMiddleware,
+  promptCacheMiddleware
 };

package/dist/chunk-IEFIQENH.js

@@ -0,0 +1,73 @@
+import {
+  snapshotScope,
+  withinScope
+} from "./chunk-N7P4PN3O.js";
+import {
+  extractFilePathsFromArgs,
+  shouldCaptureBaseline
+} from "./chunk-VEKUXUVF.js";
+
+// src/tool/executor.ts
+async function executeAgentToolCall(options) {
+  return withinScope(
+    {
+      kind: "tool",
+      name: "tool-call",
+      sessionId: options.sessionID,
+      attributes: {
+        toolName: options.toolName,
+        messageId: options.messageID,
+        agent: options.agent ?? "default"
+      }
+    },
+    async () => {
+      const initialized = await options.tool.init({ cwd: options.cwd });
+      const ctx = {
+        cwd: options.cwd,
+        abort: options.abort,
+        sessionID: options.sessionID,
+        messageID: options.messageID,
+        agent: options.agent ?? "default",
+        scope: snapshotScope(),
+        ...options.host ? { host: options.host } : {},
+        ...options.turnTracker ? { turnTracker: options.turnTracker } : {}
+      };
+      if (options.middleware?.hasMiddleware) {
+        const decision = await options.middleware.runBeforeToolCall(
+          options.toolName,
+          options.params,
+          ctx
+        );
+        if (decision.action === "deny") {
+          return {
+            output: decision.reason ?? `Tool call denied: ${options.toolName}`
+          };
+        }
+      }
+      if (options.turnTracker && initialized.fileOps && shouldCaptureBaseline(initialized.fileOps)) {
+        const paths = extractFilePathsFromArgs(
+          options.params,
+          initialized.fileOps
+        );
+        for (const path of paths) {
+          await options.turnTracker.beforeWrite(path);
+        }
+      }
+      const result = await initialized.execute(options.params, ctx);
+      if (options.middleware?.hasMiddleware) {
+        const transformed = await options.middleware.runAfterToolCall(
+          options.toolName,
+          options.params,
+          result,
+          ctx
+        );
+        return { output: transformed.output };
+      }
+      return { output: result.output };
+    }
+  );
+}
+
+export {
+  executeAgentToolCall
+};

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
+};

package/dist/{chunk-QWFMX226.js → chunk-QGOGIP7T.js}

@@ -1,9 +1,139 @@
-import {
-  getModelId,
-  getProviderId
-} from "./chunk-DWYX7ASF.js";
+// src/models/identifiers.ts
+function getModelId(model) {
+  if (typeof model === "string") return model;
+  if (typeof model === "object" && model !== null && "modelId" in model) {
+    return String(model.modelId);
+  }
+  return String(model);
+}
+function getProviderId(model) {
+  if (typeof model === "string") {
+    if (model.includes("/")) {
+      return model.split("/")[0];
+    }
+    return void 0;
+  }
+  if (typeof model === "object" && model !== null && "provider" in model) {
+    const provider = String(model.provider);
+    return provider.split(".")[0];
+  }
+  return void 0;
+}
+
+// src/models/resolver.ts
+function parseKey(input) {
+  const [engineId, ...rest] = input.split("/");
+  if (!engineId || rest.length === 0) return null;
+  return { engineId, modelId: rest.join("/") };
+}
+function mergeSettings(base, override) {
+  return {
+    apiKey: override?.apiKey ?? base?.apiKey,
+    baseUrl: override?.baseUrl ?? base?.baseUrl,
+    headers: {
+      ...base?.headers ?? {},
+      ...override?.headers ?? {}
+    },
+    extra: {
+      ...base?.extra ?? {},
+      ...override?.extra ?? {}
+    }
+  };
+}
+function settingsKey(settings, adapter, engineId) {
+  return JSON.stringify({
+    engineId,
+    adapter,
+    apiKey: settings.apiKey ?? "",
+    baseUrl: settings.baseUrl ?? "",
+    headers: settings.headers ?? {},
+    extra: settings.extra ?? {}
+  });
+}
+function buildOptions(settings) {
+  const opts = { ...settings.extra ?? {} };
+  if (settings.apiKey) opts.apiKey = settings.apiKey;
+  if (settings.baseUrl) opts.baseURL = settings.baseUrl;
+  if (settings.headers && Object.keys(settings.headers).length > 0) opts.headers = settings.headers;
+  return opts;
+}
+async function createFactory(adapter, settings) {
+  const asModel = (m) => m;
+  const opts = buildOptions(settings);
+  switch (adapter) {
+    case "openai": {
+      const { createOpenAI } = await import("@ai-sdk/openai").catch(() => {
+        throw new Error(
+          `Provider "@ai-sdk/openai" is required for the "openai" adapter. Install it with: pnpm add @ai-sdk/openai`
+        );
+      });
+      const provider = createOpenAI(opts);
+      return (modelId) => provider.languageModel(modelId);
+    }
+    case "anthropic": {
+      const { createAnthropic } = await import("@ai-sdk/anthropic").catch(() => {
+        throw new Error(
+          `Provider "@ai-sdk/anthropic" is required for the "anthropic" adapter. Install it with: pnpm add @ai-sdk/anthropic`
+        );
+      });
+      const provider = createAnthropic(opts);
+      return (modelId) => provider.languageModel(modelId);
+    }
+    case "google": {
+      const { createGoogleGenerativeAI } = await import("@ai-sdk/google").catch(() => {
+        throw new Error(
+          `Provider "@ai-sdk/google" is required for the "google" adapter. Install it with: pnpm add @ai-sdk/google`
+        );
+      });
+      const provider = createGoogleGenerativeAI(opts);
+      return (modelId) => asModel(provider.languageModel(modelId));
+    }
+    case "openai-compatible": {
+      const { createOpenAICompatible } = await import("@ai-sdk/openai-compatible").catch(() => {
+        throw new Error(
+          `Provider "@ai-sdk/openai-compatible" is required for the "openai-compatible" adapter. Install it with: pnpm add @ai-sdk/openai-compatible`
+        );
+      });
+      const provider = createOpenAICompatible({
+        name: opts.name ?? "custom",
+        baseURL: opts.baseURL ?? "",
+        ...opts.apiKey ? { apiKey: opts.apiKey } : {},
+        ...opts.headers ? { headers: opts.headers } : {}
+      });
+      return (modelId) => provider.languageModel(modelId);
+    }
+    default:
+      throw new Error(`No factory registered for adapter: ${adapter}`);
+  }
+}
+function createResolver(directory) {
+  const factoryCache = /* @__PURE__ */ new Map();
+  return async (key) => {
+    const parsed = parseKey(key);
+    const entry = parsed ? void 0 : directory.entries?.[key];
+    const engineId = parsed?.engineId ?? entry?.engine;
+    const modelId = parsed?.modelId ?? entry?.id;
+    if (!engineId || !modelId) {
+      throw new Error(`Unknown model reference: ${key}`);
+    }
+    const engine = directory.engines[engineId];
+    if (!engine) {
+      throw new Error(`Unknown engine: ${engineId}`);
+    }
+    const settings = mergeSettings(engine.settings, entry?.settings);
+    if (engine.build) {
+      return engine.build(modelId, settings);
+    }
+    const cacheKey2 = settingsKey(settings, engine.adapter, engineId);
+    const cached = factoryCache.get(cacheKey2);
+    if (cached) return cached(modelId);
+    const factory = await createFactory(engine.adapter, settings);
+    factoryCache.set(cacheKey2, factory);
+    return factory(modelId);
+  };
+}
 
-// src/capabilities/types.ts
+// src/models/types.ts
 var SourcePriority = /* @__PURE__ */ ((SourcePriority3) => {
   SourcePriority3[SourcePriority3["UserConfig"] = 0] = "UserConfig";
   SourcePriority3[SourcePriority3["LocalCache"] = 1] = "LocalCache";
@@ -23,7 +153,7 @@ var DEFAULT_RESOLVER_OPTIONS = {
   modelOverrides: {}
 };
 
-// src/capabilities/patterns.ts
+// src/models/profiles.ts
 var REASONING_PATTERNS = [
   // OpenAI o-series
   {
@@ -194,7 +324,7 @@ function getProviderCompatibility(modelId, provider) {
   return match?.rule.compatibility;
 }
 
-// src/capabilities/overrides.ts
+// src/models/overrides.ts
 function normalizeKey(value) {
   const trimmed = value?.trim();
   return trimmed && trimmed.length > 0 ? trimmed : void 0;
@@ -228,7 +358,7 @@ function applyCapabilityOverride(entry, override) {
   };
 }
 
-// src/capabilities/cache/adapters.ts
+// src/models/cache/adapters.ts
 function isNodeEnvironment() {
   return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
 }
@@ -325,7 +455,7 @@ function createCapabilityCacheAdapter(cachePath) {
   return new MemoryAdapter();
 }
 
-// src/capabilities/cache/types.ts
+// src/models/cache/types.ts
 var CACHE_VERSION = 1;
 function cacheKey(modelId, provider) {
   return provider ? `${provider}:${modelId}` : modelId;
@@ -334,7 +464,7 @@ function isExpired(data) {
   return Date.now() > new Date(data.expiresAt).getTime();
 }
 
-// src/capabilities/cache/manager.ts
+// src/models/cache/manager.ts
 var CapabilityCache = class {
   adapter;
   memoryCache = /* @__PURE__ */ new Map();
@@ -436,7 +566,7 @@ var CacheCapabilitySource = class {
   }
 };
 
-// src/capabilities/remote/network.ts
+// src/models/remote/network.ts
 function hasBrowserNetworkAPI() {
   return typeof globalThis.navigator !== "undefined" && "onLine" in globalThis.navigator;
 }
@@ -509,7 +639,7 @@ async function fetchWithTimeout(url, timeoutMs) {
   }
 }
 
-// src/capabilities/remote/transform.ts
+// src/models/remote/transform.ts
 function transformModelsDevEntry(raw) {
   const capabilities = {
     reasoning: raw.reasoning ?? false,
@@ -533,7 +663,7 @@ function transformModelsDevEntry(raw) {
   };
 }
 
-// src/capabilities/remote/fetcher.ts
+// src/models/remote/fetcher.ts
 var RemoteCapabilityFetcher = class {
   apiUrl;
   timeoutMs;
@@ -592,7 +722,7 @@ var RemoteCapabilityFetcher = class {
   }
 };
 
-// src/capabilities/remote/source.ts
+// src/models/remote/source.ts
 var RemoteCapabilitySource = class {
   priority = 4 /* RemoteAPI */;
   name = "Remote API (models.dev)";
@@ -659,7 +789,7 @@ var RemoteCapabilitySource = class {
   }
 };
 
-// src/capabilities/resolver.ts
+// src/models/capability-resolver.ts
 function extractModelId(model) {
   return getModelId(model);
 }
@@ -858,6 +988,9 @@ function configureResolver(options) {
 }
 
 export {
+  getModelId,
+  getProviderId,
+  createResolver,
   SourcePriority,
   DEFAULT_RESOLVER_OPTIONS,
   inferProvider,