@slashfi/agents-sdk 0.70.0 → 0.70.3

package/src/adk-check.ts

@@ -13,10 +13,16 @@
  *   adk run --no-check -e "code"  Execute inline without type-checking
  */
 
-import { join, dirname, basename, resolve } from "node:path";
-import { homedir } from "node:os";
-import { existsSync, writeFileSync, readFileSync, unlinkSync, copyFileSync } from "node:fs";
 import { spawnSync } from "node:child_process";
+import {
+  copyFileSync,
+  existsSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
 
 export interface CheckOptions {
   file?: string;
@@ -26,62 +32,94 @@ export interface CheckOptions {
   configDir?: string;
 }
 
-const INLINE_PREAMBLE_CHECK = (
-  `import "./.adk_types";\n` +
-  `import { createAdk, createLocalFsStore } from "@slashfi/agents-sdk";\n` +
-  `import { join } from "node:path";\n` +
-  `import { homedir } from "node:os";\n` +
-  `const adk = createAdk(\n` +
-  `  createLocalFsStore(process.env.ADK_CONFIG_DIR ?? join(homedir(), ".adk")),\n` +
-  `  { token: process.env.ATLAS_TOKEN ?? process.env.ADK_TOKEN ?? "" },\n` +
-  `);\n`
-);
-
-const INLINE_PREAMBLE_RUN = (
-  `import { createAdk, createLocalFsStore } from "@slashfi/agents-sdk";\n` +
-  `import { join } from "node:path";\n` +
-  `import { homedir } from "node:os";\n` +
-  `const adk = createAdk(\n` +
-  `  createLocalFsStore(process.env.ADK_CONFIG_DIR ?? join(homedir(), ".adk")),\n` +
-  `  { token: process.env.ATLAS_TOKEN ?? process.env.ADK_TOKEN ?? "" },\n` +
-  `);\n`
-);
-
-export async function adkCheck(opts: CheckOptions): Promise<{ ok: boolean; exitCode: number }> {
-  const configDir = opts.configDir ?? process.env.ADK_CONFIG_DIR ?? join(homedir(), ".adk");
+/**
+ * Resolve the absolute path to the @slashfi/agents-sdk package.
+ * This ensures the preamble works regardless of the script's working directory,
+ * since bare specifiers like "@slashfi/agents-sdk" may not resolve from arbitrary cwds.
+ */
+function resolveAgentsSdkPath(): string {
+  try {
+    // require.resolve gives us the main entry point, e.g.
+    // /root/.bun/install/global/node_modules/@slashfi/agents-sdk/dist/index.js
+    const resolved = require.resolve("@slashfi/agents-sdk");
+    // Extract package root path
+    const marker = "@slashfi/agents-sdk";
+    const idx = resolved.indexOf(marker);
+    if (idx !== -1) {
+      return resolved.substring(0, idx + marker.length);
+    }
+    return "@slashfi/agents-sdk";
+  } catch {
+    return "@slashfi/agents-sdk";
+  }
+}
+
+function makePreambleCheck(sdkPath: string): string {
+  return `import "./.adk_types";\nimport { createAdk, createLocalFsStore } from "${sdkPath}";\nimport { join } from "node:path";\nimport { homedir } from "node:os";\nconst adk = createAdk(\n  createLocalFsStore(process.env.ADK_CONFIG_DIR ?? join(homedir(), ".adk")),\n  { token: process.env.ATLAS_TOKEN ?? process.env.ADK_TOKEN ?? "" },\n);\n`;
+}
+
+function makePreambleRun(sdkPath: string): string {
+  return `import { createAdk, createLocalFsStore } from "${sdkPath}";\nimport { join } from "node:path";\nimport { homedir } from "node:os";\nconst adk = createAdk(\n  createLocalFsStore(process.env.ADK_CONFIG_DIR ?? join(homedir(), ".adk")),\n  { token: process.env.ATLAS_TOKEN ?? process.env.ADK_TOKEN ?? "" },\n);\n`;
+}
+
+/**
+ * Create a run wrapper file that injects the adk preamble before the user's code.
+ * Works for both inline (-e) and file mode.
+ */
+function writeRunWrapper(
+  tmpFile: string,
+  preamble: string,
+  userCode: string,
+): void {
+  writeFileSync(tmpFile, preamble + userCode);
+}
+
+export async function adkCheck(
+  opts: CheckOptions,
+): Promise<{ ok: boolean; exitCode: number }> {
+  const configDir =
+    opts.configDir ?? process.env.ADK_CONFIG_DIR ?? join(homedir(), ".adk");
   const adkTypes = join(configDir, "adk.d.ts");
   const hasTypes = existsSync(adkTypes);
   const isInline = !!opts.code;
+  const sdkPath = resolveAgentsSdkPath();
+  const PREAMBLE_RUN = makePreambleRun(sdkPath);
 
   // --no-check: skip typecheck, just run
   if (opts.noCheck && opts.run) {
-    if (isInline) {
-      const tmpFile = join(process.cwd(), ".adk_run.ts");
-      writeFileSync(tmpFile, INLINE_PREAMBLE_RUN + opts.code);
-      const r = spawnSync("bun", ["run", tmpFile], { cwd: process.cwd(), stdio: "inherit", env: process.env });
-      try { unlinkSync(tmpFile); } catch {}
-      return { ok: r.status === 0, exitCode: r.status ?? 1 };
-    } else {
-      const r = spawnSync("bun", ["run", resolve(opts.file!)], {
-        cwd: dirname(resolve(opts.file!)), stdio: "inherit", env: process.env,
-      });
-      return { ok: r.status === 0, exitCode: r.status ?? 1 };
-    }
+    const cwd = isInline ? process.cwd() : dirname(resolve(opts.file!));
+    const userCode = isInline
+      ? opts.code!
+      : readFileSync(resolve(opts.file!), "utf-8");
+    const tmpFile = join(cwd, ".adk_run.ts");
+    writeRunWrapper(tmpFile, PREAMBLE_RUN, userCode);
+    const r = spawnSync("bun", ["run", tmpFile], {
+      cwd,
+      stdio: "inherit",
+      env: process.env,
+    });
+    try {
+      unlinkSync(tmpFile);
+    } catch {}
+    return { ok: r.status === 0, exitCode: r.status ?? 1 };
   }
 
   if (!hasTypes) {
-    console.error("\x1b[33m\u26a0\x1b[0m No adk.d.ts found. Run `adk sync` first to generate agent types.");
+    console.error(
+      "\x1b[33m\u26a0\x1b[0m No adk.d.ts found. Run `adk sync` first to generate agent types.",
+    );
   }
 
   let cwd: string;
   let checkFile: string;
   let originalFile: string | undefined;
   const cleanup: string[] = [];
+  const PREAMBLE_CHECK = makePreambleCheck(sdkPath);
 
   if (isInline) {
     cwd = process.cwd();
     checkFile = join(cwd, ".adk_check.ts");
-    writeFileSync(checkFile, INLINE_PREAMBLE_CHECK + opts.code);
+    writeFileSync(checkFile, PREAMBLE_CHECK + opts.code);
     cleanup.push(checkFile);
   } else if (opts.file) {
     originalFile = resolve(opts.file);
@@ -91,8 +129,16 @@ export async function adkCheck(opts: CheckOptions): Promise<{ ok: boolean; exitC
     }
     cwd = dirname(originalFile);
     checkFile = join(cwd, `.adk_check_${basename(originalFile)}`);
+    // File mode: inject preamble so `adk` is typed and available
     const typesImport = hasTypes ? `import "./.adk_types";\n` : "";
-    writeFileSync(checkFile, typesImport + readFileSync(originalFile, "utf-8"));
+    const preambleNoTypes = PREAMBLE_CHECK.replace(
+      `import "./.adk_types";\n`,
+      "",
+    );
+    writeFileSync(
+      checkFile,
+      typesImport + preambleNoTypes + readFileSync(originalFile, "utf-8"),
+    );
     cleanup.push(checkFile);
   } else {
     console.error('Usage: adk check <file> | adk check -e "<code>"');
@@ -108,31 +154,74 @@ export async function adkCheck(opts: CheckOptions): Promise<{ ok: boolean; exitC
 
   // Write minimal tsconfig
   const tsconfigFile = join(cwd, ".adk_tsconfig.json");
-  writeFileSync(tsconfigFile, JSON.stringify({
-    compilerOptions: {
-      target: "ES2022",
-      module: "ESNext",
-      moduleResolution: "bundler",
-      esModuleInterop: true,
-      strict: true,
-      noEmit: true,
-      skipLibCheck: true,
-      types: ["node"],
-    },
-    include: [basename(checkFile)],
-  }));
+  writeFileSync(
+    tsconfigFile,
+    JSON.stringify({
+      compilerOptions: {
+        target: "ES2022",
+        module: "ESNext",
+        moduleResolution: "bundler",
+        esModuleInterop: true,
+        strict: true,
+        noEmit: true,
+        skipLibCheck: true,
+        types: ["node"],
+      },
+      include: [basename(checkFile)],
+    }),
+  );
   cleanup.push(tsconfigFile);
 
   // Find type checker
   const checker = findTypeChecker();
 
+  if (!checker) {
+    console.error(
+      "\x1b[33m\u26a0\x1b[0m No TypeScript type checker found (tsgo or tsc). Skipping type check.",
+    );
+    for (const f of cleanup) {
+      try {
+        unlinkSync(f);
+      } catch {}
+    }
+
+    // Still run if requested
+    if (opts.run) {
+      const userCode = isInline
+        ? opts.code!
+        : readFileSync(originalFile!, "utf-8");
+      const tmpFile = join(cwd, ".adk_run.ts");
+      writeRunWrapper(tmpFile, PREAMBLE_RUN, userCode);
+      const r = spawnSync("bun", ["run", tmpFile], {
+        cwd,
+        stdio: "inherit",
+        env: process.env,
+      });
+      try {
+        unlinkSync(tmpFile);
+      } catch {}
+      return { ok: r.status === 0, exitCode: r.status ?? 1 };
+    }
+    return { ok: true, exitCode: 0 };
+  }
+
   // Type-check
-  const result = spawnSync(checker.cmd, [...checker.args, "--project", tsconfigFile], {
-    cwd, stdio: "inherit", env: process.env,
-  });
+  const result = spawnSync(
+    checker.cmd,
+    [...checker.args, "--project", tsconfigFile],
+    {
+      cwd,
+      stdio: "inherit",
+      env: process.env,
+    },
+  );
 
   // Clean up
-  for (const f of cleanup) { try { unlinkSync(f); } catch {} }
+  for (const f of cleanup) {
+    try {
+      unlinkSync(f);
+    } catch {}
+  }
 
   if (result.status !== 0) {
     return { ok: false, exitCode: result.status ?? 1 };
@@ -142,25 +231,73 @@ export async function adkCheck(opts: CheckOptions): Promise<{ ok: boolean; exitC
 
   // Run
   if (opts.run) {
-    let runResult;
-    if (isInline) {
-      const tmpFile = join(cwd, ".adk_run.ts");
-      writeFileSync(tmpFile, INLINE_PREAMBLE_RUN + opts.code);
-      runResult = spawnSync("bun", ["run", tmpFile], { cwd, stdio: "inherit", env: process.env });
-      try { unlinkSync(tmpFile); } catch {}
-    } else {
-      runResult = spawnSync("bun", ["run", originalFile!], { cwd, stdio: "inherit", env: process.env });
-    }
+    const userCode = isInline
+      ? opts.code!
+      : readFileSync(originalFile!, "utf-8");
+    const tmpFile = join(cwd, ".adk_run.ts");
+    writeRunWrapper(tmpFile, PREAMBLE_RUN, userCode);
+    const runResult = spawnSync("bun", ["run", tmpFile], {
+      cwd,
+      stdio: "inherit",
+      env: process.env,
+    });
+    try {
+      unlinkSync(tmpFile);
+    } catch {}
     return { ok: runResult.status === 0, exitCode: runResult.status ?? 1 };
   }
 
   return { ok: true, exitCode: 0 };
 }
 
-function findTypeChecker(): { cmd: string; args: string[] } {
+/**
+ * Find a working TypeScript type checker.
+ * Returns null if none found — callers should skip type checking gracefully.
+ *
+ * Checks:
+ * 1. tsgo binary (fastest — native TypeScript compiler)
+ * 2. npx tsgo (if installed as a package)
+ * 3. tsc binary (standard TypeScript compiler, verified via --version)
+ * 4. npx tsc — but ONLY if it's the real TypeScript compiler, not the
+ *    unrelated `tsc` npm package that prints "This is not the tsc command
+ *    you are looking for"
+ */
+function findTypeChecker(): { cmd: string; args: string[] } | null {
+  // 1. tsgo binary
   const tsgo = spawnSync("which", ["tsgo"], { stdio: "pipe" });
   if (tsgo.status === 0) return { cmd: "tsgo", args: [] };
-  const npxTsgo = spawnSync("npx", ["tsgo", "--version"], { stdio: "pipe", timeout: 5000 });
+
+  // 2. npx tsgo
+  const npxTsgo = spawnSync("npx", ["tsgo", "--version"], {
+    stdio: "pipe",
+    timeout: 5000,
+  });
   if (npxTsgo.status === 0) return { cmd: "npx", args: ["tsgo"] };
-  return { cmd: "npx", args: ["tsc"] };
+
+  // 3. tsc binary (e.g. from `npm install -g typescript`)
+  const tscWhich = spawnSync("which", ["tsc"], { stdio: "pipe" });
+  if (tscWhich.status === 0) {
+    // Verify it's the real TypeScript compiler, not the bogus `tsc` npm package
+    const tscVersion = spawnSync("tsc", ["--version"], {
+      stdio: "pipe",
+      timeout: 5000,
+    });
+    const output = tscVersion.stdout?.toString() ?? "";
+    if (tscVersion.status === 0 && output.includes("Version")) {
+      return { cmd: "tsc", args: [] };
+    }
+  }
+
+  // 4. npx tsc — validate it's actually TypeScript
+  const npxTsc = spawnSync("npx", ["--no-install", "tsc", "--version"], {
+    stdio: "pipe",
+    timeout: 10000,
+  });
+  const npxOutput = npxTsc.stdout?.toString() ?? "";
+  if (npxTsc.status === 0 && npxOutput.includes("Version")) {
+    return { cmd: "npx", args: ["tsc"] };
+  }
+
+  // No type checker found
+  return null;
 }

package/src/config-store.ts

@@ -436,18 +436,20 @@ export function createAdk(fs: FsStore, options: AdkOptions = {}): Adk {
     return data;
   }
 
-  /** Call an MCP server directly with a bearer token (bypasses registry). */
+  /** Call an MCP server directly (bypasses registry). */
   async function callMcpDirect(
     serverUrl: string,
     toolName: string,
     params: Record<string, unknown>,
     token: string,
+    extraHeaders?: Record<string, string>,
   ): Promise<CallAgentResponse> {
     const url = serverUrl.replace(/\/$/, "");
     const headers: Record<string, string> = {
       "Content-Type": "application/json",
       Accept: "application/json, text/event-stream",
-      Authorization: `Bearer ${token}`,
+      ...(token && !extraHeaders && { Authorization: `Bearer ${token}` }),
+      ...extraHeaders,
     };
 
     let reqId = 0;
@@ -913,14 +915,31 @@ export function createAdk(fs: FsStore, options: AdkOptions = {}): Adk {
       const entry = findRef(config.refs ?? [], name);
       if (!entry) throw new Error(`Ref "${name}" not found`);
 
-      let accessToken = await readRefSecret(name, "access_token");
+      let accessToken = await readRefSecret(name, "access_token")
+        ?? await readRefSecret(name, "api_key")
+        ?? await readRefSecret(name, "token");
+
+      // Resolve custom headers from config (e.g. { "X-API-Key": "secret:..." })
+      const refConfig = (entry.config ?? {}) as Record<string, unknown>;
+      const rawHeaders = refConfig.headers as Record<string, string> | undefined;
+      let resolvedHeaders: Record<string, string> | undefined;
+      if (rawHeaders && typeof rawHeaders === 'object') {
+        resolvedHeaders = {};
+        for (const [k, v] of Object.entries(rawHeaders)) {
+          if (typeof v === 'string' && v.startsWith(SECRET_PREFIX) && options.encryptionKey) {
+            resolvedHeaders[k] = await decryptSecret(v.slice(SECRET_PREFIX.length), options.encryptionKey);
+          } else if (typeof v === 'string') {
+            resolvedHeaders[k] = v;
+          }
+        }
+      }
 
       const doCall = async (token: string | null) => {
         // Direct MCP only for redirect/proxy agents with an MCP upstream.
         // API-mode agents must go through the registry (it does REST translation).
         const agentMode = (entry as any).mode ?? 'redirect';
         if (token && entry.url && agentMode !== 'api') {
-          return callMcpDirect(entry.url, tool, params ?? {}, token);
+          return callMcpDirect(entry.url, tool, params ?? {}, token, resolvedHeaders);
         }
 
         const consumer = await buildConsumerForRef(entry);
@@ -933,6 +952,7 @@ export function createAdk(fs: FsStore, options: AdkOptions = {}): Adk {
           params: {
             ...(params ?? {}),
             ...(token && { accessToken: token }),
+            ...(resolvedHeaders && { _headers: resolvedHeaders }),
           },
         });
       };

package/src/materialize.ts

@@ -382,10 +382,10 @@ export async function syncAllRefs(
 // ============================================
 
 /**
- * Generate a root `adk.d.ts` that populates `AdkAgentRegistry` via module
- * augmentation. When the registry is populated, `adk.ref.call()` switches
- * from the loose `(string, string)` fallback to a strict typed signature
- * that rejects unknown agent paths and tool names at compile time.
+ * Generate a root `adk.d.ts` with ambient type declarations.
+ * Declares `AdkAgentRegistry` as a global interface and types the `adk` global
+ * so `adk.ref.call()` gets strict typed signatures without requiring
+ * `@slashfi/agents-sdk` to be installed locally.
  *
  * Include in tsconfig or add: /// <reference path="~/.adk/adk.d.ts" />
  */
@@ -397,14 +397,8 @@ export function generateRootTypes(
     `// Auto-generated by adk sync — do not edit`,
     `// Run \`adk sync\` to regenerate`,
     `//`,
-    `// Import in your entry file or use adk check/run:`,
-    `//   import '${configDir}/adk';`,
-    `//   adk check myfile.ts`,
-    `//`,
-    `// Then adk.ref.call() gets typed agent paths, tool names, and params.`,
-    ``,
-    `// Import the SDK to make this a module augmentation (not ambient declaration)`,
-    `import '@slashfi/agents-sdk';`,
+    `// Fully ambient — no external imports required.`,
+    `// Provides typed adk.ref.call() when used with adk check / adk run.`,
     ``,
   ];
 
@@ -430,16 +424,31 @@ export function generateRootTypes(
 
   if (typedRefs.length === 0) return;
 
-  // --- Module augmentation: populate AdkAgentRegistry ---
-  lines.push(`declare module "@slashfi/agents-sdk" {`);
-  lines.push(`  interface AdkAgentRegistry {`);
+  // --- Ambient declarations: populate AdkAgentRegistry ---
+  lines.push(`interface AdkAgentRegistry {`);
   for (const ref of typedRefs) {
     const relPath = `./refs/${ref.name}/types/${ref.name}`;
-    lines.push(`    ${JSON.stringify(ref.name)}: import(${JSON.stringify(relPath)}).${ref.interfaceName};`);
+    lines.push(`  ${JSON.stringify(ref.name)}: import(${JSON.stringify(relPath)}).${ref.interfaceName};`);
   }
-  lines.push(`  }`);
   lines.push(`}`);
   lines.push(``);
 
+  // Add ambient helper types and global `adk` declaration
+  lines.push(`type _AdkAgentPath = keyof AdkAgentRegistry;`);
+  lines.push(`type _AdkToolsOf<A extends _AdkAgentPath> = keyof AdkAgentRegistry[A] & string;`);
+  lines.push(`type _AdkParamsOf<`);
+  lines.push(`  A extends _AdkAgentPath,`);
+  lines.push(`  T extends _AdkToolsOf<A>,`);
+  lines.push(`> = AdkAgentRegistry[A][T] extends { params: infer P } ? P : Record<string, unknown>;`);
+  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(`  };`);
+  lines.push(`};`);
+  lines.push(``);
+
   ensureWrite(join(configDir, "adk.d.ts"), lines.join("\n"));
 }