@slashfi/agents-sdk 0.81.0 → 0.83.0

package/src/materialize.ts

@@ -57,11 +57,24 @@ function ensureWrite(path: string, content: string): void {
   writeFileSync(path, content, "utf-8");
 }
 
-function toKebabCase(name: string): string {
-  return name
-    .replace(/[^a-zA-Z0-9]+/g, "-")
-    .replace(/^-|-$/g, "")
-    .toLowerCase();
+/**
+ * Sanitize a tool name for use as a filename — strictly conservative.
+ * Replaces only characters that would break filesystems (`/`, `\`, NUL)
+ * with `_`. Camel case, dashes, underscores, dots, and the actual tool
+ * name are preserved verbatim so:
+ *
+ *   - `find ~/.adk/refs/<ref>/tools` shows the canonical tool names
+ *     (e.g. `listMessages.tool.md`, not `listmessages.tool.md`).
+ *   - Agents copying a slug from the filename can paste it into
+ *     `adk ref call <ref> <tool>` without round-tripping through a
+ *     case-folding step.
+ *
+ * Registries already mint tool names that are valid identifiers
+ * (camelCase, snake_case, kebab-case), so this rarely substitutes
+ * anything in practice — it's a safety net for malformed names.
+ */
+function toFilenameSlug(name: string): string {
+  return name.replace(/[/\\\0]/g, "_");
 }
 
 function pascalCase(s: string): string {
@@ -257,9 +270,12 @@ export async function materializeRef(
 
       // Write .tool.md files (primary output — readable by LLMs)
       for (const tool of tools) {
-        const safeName = toKebabCase(tool.name);
-        ensureWrite(join(toolsDir, `${safeName}.tool.md`), generateToolMd(tool));
-        ensureWrite(join(toolsDir, `${safeName}.tool.json`), JSON.stringify(tool, null, 2));
+        const slug = toFilenameSlug(tool.name);
+        ensureWrite(join(toolsDir, `${slug}.tool.md`), generateToolMd(tool));
+        ensureWrite(
+          join(toolsDir, `${slug}.tool.json`),
+          JSON.stringify(tool, null, 2),
+        );
       }
       toolCount = tools.length;
 
@@ -294,10 +310,9 @@ export async function materializeRef(
   // to actually fetch the body. Then the per-resource field is `content`,
   // not `text` (per `CallAgentReadResourcesResponse`).
   //
-  // Response shape varies depending on the call path: direct calls return
-  // `{success, agentPath, resources}` while proxied calls return
-  // `{success, result: {success, agentPath, resources}}` (the proxy wraps
-  // the inner registry response). Unwrap both shapes the same way.
+  // The unwrap below tolerates both `{success, resources}` (direct) and
+  // `{success, result: {resources}}` (registries that wrap responses
+  // through their MCP `tools/call` envelope) without caring which.
   try {
     type ResourceListEntry = {
       uri?: string;
@@ -479,11 +494,20 @@ export function generateRootTypes(
   lines.push(`  T extends _AdkToolsOf<A>,`);
   lines.push(`> = AdkAgentRegistry[A][T] extends { params: infer P } ? P : Record<string, unknown>;`);
   lines.push(``);
+  // adk.ref.call resolves to a discriminated success/error envelope.
+  // Typing this here (instead of as `Promise<unknown>`) lets scripts do
+  // `if (res.success) { res.result… }` without casting to `any`. The
+  // success.result stays `unknown` since registries don't publish output
+  // schemas — narrowing it is the script's responsibility.
+  lines.push(`type _AdkCallResult =`);
+  lines.push(`  | { success: true; result: unknown }`);
+  lines.push(`  | { success: false; error: string };`);
+  lines.push(``);
   lines.push(`declare const adk: {`);
   lines.push(`  ref: {`);
   lines.push(`    call<A extends _AdkAgentPath, T extends _AdkToolsOf<A>>(`);
   lines.push(`      name: A, tool: T, params: _AdkParamsOf<A, T>`);
-  lines.push(`    ): Promise<unknown>;`);
+  lines.push(`    ): Promise<_AdkCallResult>;`);
   lines.push(`  };`);
   lines.push(`};`);
   lines.push(``);

package/src/registry-consumer.ts

@@ -209,16 +209,6 @@ export interface RegistryConfiguration {
   jwks_uri?: string;
   token_endpoint?: string;
   supported_grant_types?: string[];
-  /**
-   * When the registry advertises proxy support in its `initialize` response,
-   * consumers can auto-populate `RegistryEntry.proxy` at add time so ref ops
-   * forward to the server-side adk-tools agent automatically.
-   */
-  proxy?: {
-    mode: "required" | "optional";
-    /** Agent path to forward to. Defaults to '@config'. */
-    agent?: string;
-  };
 }
 
 /** Fields common to every agent reference a registry can return. */
@@ -498,34 +488,17 @@ async function discoverRegistryViaMcp(
     clientInfo: { name: "agents-sdk-consumer", version: "1.0.0" },
   })) as {
     serverInfo?: { name?: string; version?: string };
-    capabilities?: {
-      registry?: {
-        proxy?: {
-          mode?: "required" | "optional";
-          agent?: string;
-        };
-      };
-    };
   };
 
   await rpc("notifications/initialized").catch(() => {});
 
   const issuer = issuerFromMcpUrlAndServerInfo(serverUrl, initResult?.serverInfo);
 
-  const advertisedProxy = initResult?.capabilities?.registry?.proxy;
-  const proxy = advertisedProxy?.mode
-    ? {
-        mode: advertisedProxy.mode,
-        ...(advertisedProxy.agent && { agent: advertisedProxy.agent }),
-      }
-    : undefined;
-
   return {
     issuer,
     jwks_uri: `${issuer}/.well-known/jwks.json`,
     token_endpoint: `${issuer}/oauth/token`,
     supported_grant_types: ["client_credentials", "jwt_exchange"],
-    ...(proxy && { proxy }),
   };
 }
 

package/src/server.ts

@@ -206,17 +206,6 @@ export interface AgentServerOptions {
     features?: string[];
     /** OAuth callback URL for shared OAuth flows */
     oauthCallbackUrl?: string;
-    /**
-     * Announce that ref operations for agents sourced from this registry
-     * should be forwarded to a server-side adk-tools agent instead of
-     * running locally. Consumers pick this up during `registry.add` and
-     * auto-populate `RegistryEntry.proxy` — no user flag needed.
-     */
-    proxy?: {
-      mode: "required" | "optional";
-      /** Agent path to forward to. Defaults to '@config'. */
-      agent?: string;
-    };
   };
   /**
    * Structured logger for server-side errors (tool-call failures, JWT
@@ -602,14 +591,6 @@ export function createAgentServer(
                 ...(options.registry.oauthCallbackUrl && {
                   oauthCallbackUrl: options.registry.oauthCallbackUrl,
                 }),
-                ...(options.registry.proxy && {
-                  proxy: {
-                    mode: options.registry.proxy.mode,
-                    ...(options.registry.proxy.agent && {
-                      agent: options.registry.proxy.agent,
-                    }),
-                  },
-                }),
               },
             }),
           },