@slashfi/agents-sdk 0.41.7 → 0.41.9

package/src/config-store.ts

@@ -24,6 +24,7 @@ import type {
   RefEntry,
   RegistryEntry,
   ResolvedRef,
+  ResolvedRegistry,
 } from "./define-config.js";
 import { normalizeRef } from "./define-config.js";
 import { createRegistryConsumer } from "./registry-consumer.js";
@@ -211,6 +212,28 @@ function refName(entry: RefEntry): string {
   return normalizeRef(entry).name;
 }
 
+/**
+ * Find a ref by name, trying both with and without `@` prefix.
+ * Refs may be stored as `@foo` or `foo` depending on how they were added;
+ * this ensures lookups work regardless of which form the caller uses.
+ */
+function findRef(refs: RefEntry[], name: string): RefEntry | undefined {
+  const match = refs.find((r) => refName(r) === name);
+  if (match) return match;
+  const alt = name.startsWith("@") ? name.slice(1) : `@${name}`;
+  return refs.find((r) => refName(r) === alt);
+}
+
+/**
+ * Match a ref name with @ normalization (for filter/map operations).
+ */
+function refNameMatches(entry: RefEntry, name: string): boolean {
+  const n = refName(entry);
+  if (n === name) return true;
+  const alt = name.startsWith("@") ? name.slice(1) : `@${name}`;
+  return n === alt;
+}
+
 function registryDisplayName(r: string | RegistryEntry): string {
   return typeof r === "string" ? r : (r.name ?? r.url);
 }
@@ -287,7 +310,7 @@ export function createAdk(fs: FsStore, options: AdkOptions = {}): Adk {
 
   async function readRefSecret(name: string, key: string): Promise<string | null> {
     const config = await readConfig();
-    const entry = (config.refs ?? []).find((r) => refName(r) === name);
+    const entry = findRef(config.refs ?? [], name);
     const value = entry?.config?.[key];
     if (typeof value !== "string") return null;
     if (value.startsWith(SECRET_PREFIX) && options.encryptionKey) {
@@ -481,6 +504,59 @@ export function createAdk(fs: FsStore, options: AdkOptions = {}): Adk {
     );
   }
 
+  /**
+   * Build a consumer that includes the ref's sourceRegistry if present.
+   * This ensures calls/inspect route to the correct registry endpoint.
+   */
+  async function buildConsumerForRef(entry: RefEntry): Promise<RegistryConsumer> {
+    const config = await readConfig();
+    let registries = config.registries ?? [];
+
+    // If the ref has a sourceRegistry, ensure it's included in the consumer's registries
+    if (entry.sourceRegistry?.url) {
+      const sourceUrl = entry.sourceRegistry.url;
+      const alreadyIncluded = registries.some((r) =>
+        typeof r === "string" ? r === sourceUrl : r.url === sourceUrl,
+      );
+      if (!alreadyIncluded) {
+        registries = [...registries, { url: sourceUrl, name: sourceUrl }];
+      }
+    }
+
+    const resolved = options.encryptionKey
+      ? await Promise.all(
+          registries.map(async (r) => {
+            if (typeof r === "string") return r;
+            const decrypted = await decryptConfigSecrets(
+              r as unknown as Record<string, unknown>,
+              options.encryptionKey!,
+            );
+            return decrypted as unknown as RegistryEntry;
+          }),
+        )
+      : registries;
+
+    return createRegistryConsumer(
+      { registries: resolved, refs: config.refs ?? [] },
+      { token: options.token },
+    );
+  }
+
+  /**
+   * Resolve the correct registry for a ref.
+   * If the ref has a sourceRegistry, use that; otherwise fall back to the first registry.
+   */
+  function resolveRegistryForRef(consumer: RegistryConsumer, entry: RefEntry): ResolvedRegistry {
+    const regs = consumer.registries();
+    if (entry.sourceRegistry?.url) {
+      const match = regs.find((r) => r.url === entry.sourceRegistry!.url);
+      if (match) return match;
+    }
+    const fallback = regs[0];
+    if (!fallback) throw new Error("No registry available");
+    return fallback;
+  }
+
   // ==========================================
   // Registry API
   // ==========================================
@@ -599,9 +675,38 @@ export function createAdk(fs: FsStore, options: AdkOptions = {}): Adk {
       const config = await readConfig();
       const hasRegistries = (config.registries ?? []).length > 0;
 
-      if (hasRegistries) {
+      // Validate scheme is always specified
+      if (!entry.scheme) {
+        throw new AdkError({
+          code: "REF_INVALID",
+          message: `Cannot add ref "${entry.ref}": scheme is required`,
+          hint: "Specify scheme: 'registry' (with sourceRegistry), 'mcp' (with url), or 'https' (with url)",
+          details: { ref: entry.ref },
+        });
+      }
+
+      // Validate scheme-specific requirements
+      if (entry.scheme === "registry" && !entry.sourceRegistry?.url) {
+        throw new AdkError({
+          code: "REF_INVALID",
+          message: `Cannot add ref "${entry.ref}": scheme 'registry' requires sourceRegistry`,
+          hint: "Provide sourceRegistry: { url: '...', agentPath: '...' }",
+          details: { ref: entry.ref, scheme: entry.scheme },
+        });
+      }
+
+      if ((entry.scheme === "mcp" || entry.scheme === "https") && !entry.url) {
+        throw new AdkError({
+          code: "REF_INVALID",
+          message: `Cannot add ref "${entry.ref}": scheme '${entry.scheme}' requires url`,
+          hint: "Provide the direct agent URL with: url: 'https://...'",
+          details: { ref: entry.ref, scheme: entry.scheme },
+        });
+      }
+
+      if (hasRegistries || entry.sourceRegistry?.url) {
         try {
-          const consumer = await buildConsumer();
+          const consumer = await buildConsumerForRef(entry);
           const agentToInspect = entry.sourceRegistry?.agentPath ?? entry.ref;
           const info = await consumer.inspect(agentToInspect);
 
@@ -669,7 +774,7 @@ export function createAdk(fs: FsStore, options: AdkOptions = {}): Adk {
       const config = await readConfig();
       if (!config.refs?.length) return false;
       const before = config.refs.length;
-      const refs = config.refs.filter((r) => refName(r) !== name);
+      const refs = config.refs.filter((r) => !refNameMatches(r, name));
       if (refs.length === before) return false;
       await writeConfig({ ...config, refs });
       return true;
@@ -682,7 +787,7 @@ export function createAdk(fs: FsStore, options: AdkOptions = {}): Adk {
 
     async get(name: string): Promise<RefEntry | null> {
       const config = await readConfig();
-      return (config.refs ?? []).find((r) => refName(r) === name) ?? null;
+      return findRef(config.refs ?? [], name) ?? null;
     },
 
     async update(name: string, updates: Partial<RefEntry>): Promise<boolean> {
@@ -690,7 +795,7 @@ export function createAdk(fs: FsStore, options: AdkOptions = {}): Adk {
       if (!config.refs?.length) return false;
       let found = false;
       const refs = config.refs.map((r): RefEntry => {
-        if (refName(r) !== name) return r;
+        if (!refNameMatches(r, name)) return r;
         found = true;
         const updated = { ...r };
         if (updates.url) updated.url = updates.url;
@@ -707,16 +812,20 @@ export function createAdk(fs: FsStore, options: AdkOptions = {}): Adk {
 
     async inspect(name: string, opts?: { full?: boolean }): Promise<AgentListing | null> {
       const config = await readConfig();
-      const entry = (config.refs ?? []).find((r) => refName(r) === name);
+      const entry = findRef(config.refs ?? [], name);
       if (!entry) throw new Error(`Ref "${name}" not found`);
 
-      const consumer = await buildConsumer();
-      return consumer.inspect(entry.ref, undefined, opts);
+      const consumer = await buildConsumerForRef(entry);
+      return consumer.inspect(
+        entry.sourceRegistry?.agentPath ?? entry.ref,
+        entry.sourceRegistry?.url,
+        opts,
+      );
     },
 
     async call(name: string, tool: string, params?: Record<string, unknown>): Promise<CallAgentResponse> {
       const config = await readConfig();
-      const entry = (config.refs ?? []).find((r) => refName(r) === name);
+      const entry = findRef(config.refs ?? [], name);
       if (!entry) throw new Error(`Ref "${name}" not found`);
 
       const accessToken = await readRefSecret(name, "access_token");
@@ -727,13 +836,12 @@ export function createAdk(fs: FsStore, options: AdkOptions = {}): Adk {
         return callMcpDirect(entry.url, tool, params ?? {}, accessToken);
       }
 
-      const consumer = await buildConsumer();
-      const reg = consumer.registries()[0];
-      if (!reg) throw new Error("No registry available");
+      const consumer = await buildConsumerForRef(entry);
+      const reg = resolveRegistryForRef(consumer, entry);
 
       return consumer.callRegistry(reg, {
         action: "execute_tool",
-        path: entry.ref,
+        path: entry.sourceRegistry?.agentPath ?? entry.ref,
         tool,
         params: params ?? {},
       });
@@ -741,44 +849,42 @@ export function createAdk(fs: FsStore, options: AdkOptions = {}): Adk {
 
     async resources(name: string): Promise<CallAgentResponse> {
       const config = await readConfig();
-      const entry = (config.refs ?? []).find((r) => refName(r) === name);
+      const entry = findRef(config.refs ?? [], name);
       if (!entry) throw new Error(`Ref "${name}" not found`);
 
-      const consumer = await buildConsumer();
-      const reg = consumer.registries()[0];
-      if (!reg) throw new Error("No registry available");
+      const consumer = await buildConsumerForRef(entry);
+      const reg = resolveRegistryForRef(consumer, entry);
 
       return consumer.callRegistry(reg, {
         action: "list_resources",
-        path: entry.ref,
+        path: entry.sourceRegistry?.agentPath ?? entry.ref,
       });
     },
 
     async read(name: string, uris: string[]): Promise<CallAgentResponse> {
       const config = await readConfig();
-      const entry = (config.refs ?? []).find((r) => refName(r) === name);
+      const entry = findRef(config.refs ?? [], name);
       if (!entry) throw new Error(`Ref "${name}" not found`);
 
-      const consumer = await buildConsumer();
-      const reg = consumer.registries()[0];
-      if (!reg) throw new Error("No registry available");
+      const consumer = await buildConsumerForRef(entry);
+      const reg = resolveRegistryForRef(consumer, entry);
 
       return consumer.callRegistry(reg, {
         action: "read_resources",
-        path: entry.ref,
+        path: entry.sourceRegistry?.agentPath ?? entry.ref,
         uris,
       });
     },
 
     async authStatus(name: string): Promise<RefAuthStatus> {
       const config = await readConfig();
-      const entry = (config.refs ?? []).find((r) => refName(r) === name);
+      const entry = findRef(config.refs ?? [], name);
       if (!entry) throw new Error(`Ref "${name}" not found`);
 
       let security: SecuritySchemeSummary | null = null;
       try {
-        const consumer = await buildConsumer();
-        const info = await consumer.inspect(entry.ref);
+        const consumer = await buildConsumerForRef(entry);
+        const info = await consumer.inspect(entry.sourceRegistry?.agentPath ?? entry.ref);
         if (info?.security) security = info.security;
       } catch {
         // Can't reach registry
@@ -863,7 +969,7 @@ export function createAdk(fs: FsStore, options: AdkOptions = {}): Adk {
       apiKey?: string;
     }): Promise<AuthStartResult> {
       const config = await readConfig();
-      const entry = (config.refs ?? []).find((r) => refName(r) === name);
+      const entry = findRef(config.refs ?? [], name);
       if (!entry) throw new Error(`Ref "${name}" not found`);
 
       const status = await ref.authStatus(name);