@cuylabs/agent-core 0.9.0 → 0.11.0

package/dist/{chunk-WGZAPU6N.js → chunk-QAL3OMI3.js}

@@ -871,7 +871,9 @@ function mergePluginManifest(manifest, definition) {
     name: definition.name ?? manifest.name,
     description: definition.description ?? manifest.description,
     version: definition.version ?? manifest.version,
-    compatibility: mergeCompatibility(manifest.compatibility, definition.compatibility) ?? manifest.compatibility
+    compatibility: mergeCompatibility(manifest.compatibility, definition.compatibility) ?? manifest.compatibility,
+    capabilities: mergeCapabilityTags(manifest.capabilities, definition.capabilities),
+    surfaces: mergeSurfaceContract(manifest.surfaces, definition.surfaces)
   };
 }
 function mergeCompatibility(manifest, definition) {
@@ -879,6 +881,18 @@ function mergeCompatibility(manifest, definition) {
   if (!definition) return manifest;
   return { ...manifest, ...definition };
 }
+function mergeCapabilityTags(manifest, definition) {
+  const merged = [...manifest ?? [], ...definition ?? []].map((tag) => tag.trim()).filter(Boolean);
+  if (merged.length === 0) {
+    return void 0;
+  }
+  return [...new Set(merged)];
+}
+function mergeSurfaceContract(manifest, definition) {
+  if (!manifest) return definition;
+  if (!definition) return manifest;
+  return { ...manifest, ...definition };
+}
 function normalizeCommandToken(token) {
   return token.trim().replace(/^\//, "").toLowerCase();
 }

package/dist/{chunk-UDCZ673N.js → chunk-RN6WZEUF.js}

@@ -5,6 +5,9 @@ import {
   extractProvider,
   likelySupportsReasoning
 } from "./chunk-I6PKJ7XQ.js";
+import {
+  silentLogger
+} from "./chunk-T4UIX5D7.js";
 
 // src/models/resolver.ts
 function parseKey(input) {
@@ -217,9 +220,6 @@ function applyCapabilityOverride(entry, override) {
 }
 
 // src/models/cache/adapters.ts
-function logLocalStorageWarning(error) {
-  console.warn("[agent-core] Failed to write to localStorage:", error);
-}
 function isNodeEnvironment() {
   return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
 }
@@ -271,6 +271,10 @@ var FileSystemAdapter = class {
 };
 var LocalStorageAdapter = class {
   key = "agent-core:model-capabilities";
+  log;
+  constructor(logger) {
+    this.log = logger;
+  }
   async read() {
     try {
       const content = localStorage.getItem(this.key);
@@ -284,7 +288,9 @@ var LocalStorageAdapter = class {
     try {
       localStorage.setItem(this.key, JSON.stringify(data));
     } catch (error) {
-      logLocalStorageWarning(error);
+      this.log.warn("Failed to write to localStorage", {
+        error: error instanceof Error ? error.message : String(error)
+      });
     }
   }
   async clear() {
@@ -306,12 +312,12 @@ var MemoryAdapter = class {
     this.data = void 0;
   }
 };
-function createCapabilityCacheAdapter(cachePath) {
+function createCapabilityCacheAdapter(cachePath, logger) {
   if (isNodeEnvironment()) {
     return new FileSystemAdapter(cachePath);
   }
   if (hasLocalStorage()) {
-    return new LocalStorageAdapter();
+    return new LocalStorageAdapter(logger ?? silentLogger);
   }
   return new MemoryAdapter();
 }
@@ -326,18 +332,17 @@ function isExpired(data) {
 }
 
 // src/models/cache/manager.ts
-function logCapabilityCacheWarning(error) {
-  console.warn("[agent-core] Failed to load capability cache:", error);
-}
 var CapabilityCache = class {
   adapter;
   memoryCache = /* @__PURE__ */ new Map();
   ttlMs;
   loaded = false;
-  constructor(options = {}) {
+  log;
+  constructor(options = {}, logger) {
     const opts = { ...DEFAULT_RESOLVER_OPTIONS, ...options };
     this.ttlMs = opts.cacheTtlMs;
     this.adapter = createCapabilityCacheAdapter(opts.cachePath);
+    this.log = logger?.child("cache") ?? silentLogger;
   }
   async load() {
     if (this.loaded) return;
@@ -349,7 +354,9 @@ var CapabilityCache = class {
         }
       }
     } catch (error) {
-      logCapabilityCacheWarning(error);
+      this.log.warn("Failed to load capability cache", {
+        error: error instanceof Error ? error.message : String(error)
+      });
     }
     this.loaded = true;
   }
@@ -654,18 +661,17 @@ var RemoteCapabilitySource = class {
 };
 
 // src/models/capability-resolver.ts
-function logCapabilityResolverWarning(message, error) {
-  console.warn(message, error);
-}
 var ModelCapabilityResolver = class {
   options;
   cache;
   sources;
   initialized = false;
   initPromise;
-  constructor(options = {}) {
+  log;
+  constructor(options = {}, logger) {
     this.options = { ...DEFAULT_RESOLVER_OPTIONS, ...options };
     this.cache = new CapabilityCache(this.options);
+    this.log = logger?.child("models") ?? silentLogger;
     this.sources = [
       new CacheCapabilitySource(this.cache),
       new PatternCapabilitySource()
@@ -688,10 +694,9 @@ var ModelCapabilityResolver = class {
         );
         if (remoteSource) {
           remoteSource.refresh().catch((err) => {
-            logCapabilityResolverWarning(
-              "[agent-core] Background refresh failed:",
-              err
-            );
+            this.log.warn("Background refresh failed", {
+              error: err instanceof Error ? err.message : String(err)
+            });
           });
         }
       }
@@ -722,10 +727,9 @@ var ModelCapabilityResolver = class {
           }
         }
       } catch (error) {
-        logCapabilityResolverWarning(
-          `[agent-core] Source ${source.name} failed:`,
-          error
-        );
+        this.log.warn(`Source ${source.name} failed`, {
+          error: error instanceof Error ? error.message : String(error)
+        });
       }
     }
     if (!bestResult?.entry) {

package/dist/{chunk-ZXAKHMWH.js → chunk-ROTGCYDW.js}

@@ -1,3 +1,7 @@
+import {
+  silentLogger
+} from "./chunk-T4UIX5D7.js";
+
 // src/mcp/modules.ts
 var mcpModule;
 var stdioModule;
@@ -30,9 +34,11 @@ async function getStdioClientModule() {
 var DefaultMCPManager = class {
   config;
   connections = /* @__PURE__ */ new Map();
+  log;
   toolCache;
-  constructor(config) {
+  constructor(config, logger) {
     this.config = config;
+    this.log = logger?.child("mcp") ?? silentLogger;
   }
   async connect() {
     const results = /* @__PURE__ */ new Map();
@@ -80,7 +86,7 @@ var DefaultMCPManager = class {
     const allTools = {};
     const toolPromises = Array.from(this.connections.entries()).map(
       async ([serverName, connection]) => {
-        if (connection.status.status !== "connected") {
+        if (connection.status.status !== "connected" || !connection.client) {
           return;
         }
         try {
@@ -89,7 +95,9 @@ var DefaultMCPManager = class {
             allTools[`${serverName}__${toolName}`] = tool;
           }
         } catch (error) {
-          console.warn(`[mcp] Failed to get tools from ${serverName}:`, error);
+          this.log.warn(`Failed to get tools from ${serverName}`, {
+            error: error instanceof Error ? error.message : String(error)
+          });
         }
       }
     );
@@ -108,77 +116,6 @@ var DefaultMCPManager = class {
     }
     return status;
   }
-  async listResources() {
-    const resources = [];
-    const promises = Array.from(this.connections.entries()).map(
-      async ([serverName, connection]) => {
-        if (connection.status.status !== "connected") {
-          return;
-        }
-        try {
-          const result = await connection.client.listResources();
-          for (const resource of result.resources) {
-            resources.push({
-              uri: resource.uri,
-              name: resource.name,
-              description: resource.description,
-              mimeType: resource.mimeType,
-              server: serverName
-            });
-          }
-        } catch {
-        }
-      }
-    );
-    await Promise.all(promises);
-    return resources;
-  }
-  async readResource(uri) {
-    for (const [, connection] of this.connections) {
-      if (connection.status.status !== "connected") {
-        continue;
-      }
-      try {
-        return await connection.client.readResource({ uri });
-      } catch {
-      }
-    }
-    throw new Error(`Resource not found: ${uri}`);
-  }
-  async listPrompts() {
-    const prompts = [];
-    const promises = Array.from(this.connections.entries()).map(
-      async ([serverName, connection]) => {
-        if (connection.status.status !== "connected") {
-          return;
-        }
-        try {
-          const result = await connection.client.experimental_listPrompts();
-          for (const prompt of result.prompts) {
-            prompts.push({
-              name: prompt.name,
-              description: prompt.description,
-              arguments: prompt.arguments,
-              server: serverName
-            });
-          }
-        } catch {
-        }
-      }
-    );
-    await Promise.all(promises);
-    return prompts;
-  }
-  async getPrompt(serverName, promptName, args) {
-    const connection = this.connections.get(serverName);
-    if (!connection || connection.status.status !== "connected") {
-      throw new Error(`Server not connected: ${serverName}`);
-    }
-    return await connection.client.experimental_getPrompt({
-      name: promptName,
-      arguments: args
-    });
-  }
   async close() {
     const closePromises = Array.from(this.connections.values()).map(
       async (connection) => {
@@ -216,6 +153,11 @@ var DefaultMCPManager = class {
         )
       ]);
     };
+    const clientOptions = {
+      name: config.name ?? name,
+      ...config.onUncaughtError ? { onUncaughtError: config.onUncaughtError } : {},
+      ...config.capabilities ? { capabilities: config.capabilities } : {}
+    };
     if (config.transport === "stdio") {
       const { StdioClientTransport } = await getStdioClientModule();
       const transport = new StdioClientTransport({
@@ -224,10 +166,7 @@ var DefaultMCPManager = class {
         env: config.env,
         cwd: config.cwd
       });
-      const client2 = await createMCPClient({
-        transport,
-        name: config.name ?? name
-      });
+      const client2 = await createMCPClient({ transport, ...clientOptions });
       const tools2 = await withTimeout(client2.tools(), timeout);
       return { client: client2, toolCount: Object.keys(tools2).length };
     }
@@ -235,9 +174,12 @@ var DefaultMCPManager = class {
       transport: {
         type: config.transport,
         url: config.url,
-        headers: config.headers
+        headers: config.headers,
+        ...config.authProvider ? { authProvider: config.authProvider } : {},
+        ...config.redirect ? { redirect: config.redirect } : {},
+        ...config.fetch ? { fetch: config.fetch } : {}
       },
-      name: config.name ?? name
+      ...clientOptions
     });
     const tools = await withTimeout(client.tools(), timeout);
     return { client, toolCount: Object.keys(tools).length };
@@ -248,9 +190,6 @@ var DefaultMCPManager = class {
 function createMCPManager(config) {
   return new DefaultMCPManager(config);
 }
-function defineServer(config) {
-  return config;
-}
 function stdioServer(command, args, options) {
   return {
     transport: "stdio",
@@ -276,7 +215,6 @@ function sseServer(url, options) {
 
 export {
   createMCPManager,
-  defineServer,
   stdioServer,
   httpServer,
   sseServer