agency-lang 0.0.101 → 0.0.103

package/dist/lib/backends/typescriptBuilder.js

@@ -1641,6 +1641,12 @@ export class TypeScriptBuilder {
             })),
         ]), ts.statements([
             ts.if(ts.raw("__error instanceof RestoreSignal"), ts.statements([ts.throw("__error")])),
+            ts.consoleError(ts.template([
+                {
+                    text: "\\nAgent crashed: ",
+                    expr: $(ts.id("__error")).prop("message").done(),
+                },
+            ])),
             ts.return(ts.obj({
                 messages: ts.runtime.threads,
                 data: ts.raw(`failure(__error instanceof Error ? __error.message : String(__error), { functionName: ${JSON.stringify(nodeName)} })`),
@@ -2436,7 +2442,16 @@ export class TypeScriptBuilder {
             ts.constDecl("graph", $(ts.runtime.globalCtx).prop("graph").done()),
         ];
         if (this.agencyConfig.mcpServers) {
-            runtimeCtxStatements.push(ts.raw(`__globalCtx.createMcpManager(${JSON.stringify(this.agencyConfig.mcpServers)});`));
+            // Strip secrets from the config before embedding in generated code.
+            // clientId and clientSecret are resolved at runtime from env vars.
+            const sanitizedServers = Object.fromEntries(Object.entries(this.agencyConfig.mcpServers).map(([name, cfg]) => {
+                if ("type" in cfg && cfg.type === "http") {
+                    const { clientSecret, clientId, ...rest } = cfg;
+                    return [name, rest];
+                }
+                return [name, cfg];
+            }));
+            runtimeCtxStatements.push(ts.raw(`__globalCtx.createMcpManager(${JSON.stringify(sanitizedServers)});`));
         }
         let runtimeCtx = ts.statements(runtimeCtxStatements);
         return renderImports.default({

package/dist/lib/cli/auth.d.ts

@@ -0,0 +1,4 @@
+import type { AgencyConfig } from "../config.js";
+export declare function authServer(serverName: string, config: AgencyConfig): Promise<void>;
+export declare function listAuth(): Promise<void>;
+export declare function revokeAuth(serverName: string): Promise<void>;

package/dist/lib/cli/auth.js

@@ -0,0 +1,60 @@
+import { TokenStore } from "../runtime/mcp/tokenStore.js";
+import { OAuthConnector } from "../runtime/mcp/oauthConnector.js";
+import { isOAuthServer } from "../runtime/mcp/types.js";
+const store = new TokenStore();
+export async function authServer(serverName, config) {
+    const mcpServers = config.mcpServers;
+    if (!mcpServers || !mcpServers[serverName]) {
+        console.error(`MCP server "${serverName}" not found in agency.json. Available servers: ${mcpServers ? Object.keys(mcpServers).join(", ") : "(none)"}`);
+        process.exit(1);
+    }
+    const serverConfig = mcpServers[serverName];
+    if (!isOAuthServer(serverConfig)) {
+        console.error(`MCP server "${serverName}" is not configured with auth: "oauth".`);
+        process.exit(1);
+    }
+    const httpConfig = serverConfig;
+    const existing = await store.loadTokens(serverName);
+    if (existing) {
+        console.log(`Token already exists for "${serverName}". Use --revoke to remove it first.`);
+        return;
+    }
+    console.log(`Starting OAuth authorization for "${serverName}"...`);
+    const connector = new OAuthConnector(serverName, httpConfig.url, store, {
+        timeoutMs: httpConfig.authTimeout,
+        clientId: httpConfig.clientId,
+        clientSecret: httpConfig.clientSecret,
+    });
+    try {
+        const { client } = await connector.connect();
+        console.log(`Successfully authorized "${serverName}". Token stored.`);
+        await client.close();
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(`Authorization failed for "${serverName}": ${msg}`);
+        process.exit(1);
+    }
+}
+export async function listAuth() {
+    const servers = await store.listServers();
+    if (servers.length === 0) {
+        console.log("No stored OAuth tokens.");
+        return;
+    }
+    console.log("Stored OAuth tokens:");
+    for (const name of servers) {
+        const tokens = await store.loadTokens(name);
+        const hasRefresh = tokens?.refresh_token ? "yes" : "no";
+        console.log(`  ${name} (refresh token: ${hasRefresh})`);
+    }
+}
+export async function revokeAuth(serverName) {
+    const tokens = await store.loadTokens(serverName);
+    if (!tokens) {
+        console.log(`No stored token for "${serverName}".`);
+        return;
+    }
+    await store.deleteTokens(serverName);
+    console.log(`Removed stored token for "${serverName}".`);
+}

package/dist/lib/cli/commands.js

@@ -89,6 +89,10 @@ export function resetCompilationCache() {
     compiledFiles.clear();
 }
 export function compile(config, inputFile, _outputFile, options) {
+    if (!fs.existsSync(inputFile)) {
+        console.error(`Error: Input file '${inputFile}' not found`);
+        process.exit(1);
+    }
     // Check if the input is a directory
     const stats = fs.statSync(inputFile);
     const verbose = config.verbose ?? false;

package/dist/lib/config.d.ts

@@ -180,5 +180,10 @@ export declare const AgencyConfigSchema: z.ZodObject<{
     }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"http">;
         url: z.ZodString;
+        auth: z.ZodOptional<z.ZodLiteral<"oauth">>;
+        authTimeout: z.ZodOptional<z.ZodNumber>;
+        clientId: z.ZodOptional<z.ZodString>;
+        clientSecret: z.ZodOptional<z.ZodString>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     }, z.core.$strict>]>>>;
 }, z.core.$loose>;

package/dist/lib/config.js

@@ -26,6 +26,11 @@ const McpStdioServerSchema = z.object({
 const McpHttpServerSchema = z.object({
     type: z.literal("http"),
     url: z.string(),
+    auth: z.literal("oauth").optional(),
+    authTimeout: z.number().optional(),
+    clientId: z.string().optional(),
+    clientSecret: z.string().optional(),
+    headers: z.record(z.string(), z.string()).optional(),
 }).strict();
 const McpServerSchema = z.union([McpStdioServerSchema, McpHttpServerSchema]);
 export const AgencyConfigSchema = z.object({
@@ -58,5 +63,61 @@ export const AgencyConfigSchema = z.object({
     distDir: z.string(),
     test: z.object({ parallel: z.number() }).partial(),
     doc: z.object({ outDir: z.string(), baseUrl: z.string() }).partial(),
-    mcpServers: z.record(z.string(), McpServerSchema),
-}).partial().passthrough();
+    mcpServers: z.record(z.string().regex(/^[A-Za-z0-9_-]+$/, "MCP server names must contain only letters, numbers, hyphens, and underscores"), McpServerSchema),
+}).partial().passthrough().superRefine((data, ctx) => {
+    if (!data.mcpServers)
+        return;
+    for (const [name, server] of Object.entries(data.mcpServers)) {
+        if ("type" in server && server.type === "http") {
+            const httpServer = server;
+            if (httpServer.auth && httpServer.headers) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: `MCP server "${name}": cannot specify both 'auth' and 'headers'`,
+                    path: ["mcpServers", name],
+                });
+            }
+            if (httpServer.authTimeout && httpServer.auth !== "oauth") {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: `MCP server "${name}": 'authTimeout' requires 'auth: "oauth"'`,
+                    path: ["mcpServers", name],
+                });
+            }
+            if (httpServer.clientId && httpServer.auth !== "oauth") {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: `MCP server "${name}": 'clientId' requires 'auth: "oauth"'`,
+                    path: ["mcpServers", name],
+                });
+            }
+            if (httpServer.clientSecret && httpServer.auth !== "oauth") {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: `MCP server "${name}": 'clientSecret' requires 'auth: "oauth"'`,
+                    path: ["mcpServers", name],
+                });
+            }
+            if (httpServer.auth === "oauth") {
+                try {
+                    const parsed = new URL(httpServer.url);
+                    const isLocalhost = ["127.0.0.1", "localhost"].includes(parsed.hostname);
+                    if (parsed.protocol !== "https:" && !isLocalhost) {
+                        ctx.addIssue({
+                            code: z.ZodIssueCode.custom,
+                            message: `MCP server "${name}": OAuth requires HTTPS (or localhost for development)`,
+                            path: ["mcpServers", name, "url"],
+                        });
+                    }
+                }
+                catch {
+                    ctx.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        message: `MCP server "${name}": invalid URL "${httpServer.url}"`,
+                        path: ["mcpServers", name, "url"],
+                    });
+                }
+            }
+        }
+    }
+});

package/dist/lib/config.test.js

@@ -61,4 +61,118 @@ describe("AgencyConfigSchema", () => {
         });
         expect(result.success).toBe(false);
     });
+    it("should accept HTTP server with auth: oauth", () => {
+        const result = AgencyConfigSchema.safeParse({
+            mcpServers: {
+                github: { type: "http", url: "https://github-mcp.example.com/mcp", auth: "oauth" },
+            },
+        });
+        expect(result.success).toBe(true);
+    });
+    it("should accept HTTP server with headers", () => {
+        const result = AgencyConfigSchema.safeParse({
+            mcpServers: {
+                weather: {
+                    type: "http",
+                    url: "https://weather.example.com/mcp",
+                    headers: { "Authorization": "Bearer ${WEATHER_KEY}" },
+                },
+            },
+        });
+        expect(result.success).toBe(true);
+    });
+    it("should accept HTTP server with authTimeout", () => {
+        const result = AgencyConfigSchema.safeParse({
+            mcpServers: {
+                github: {
+                    type: "http",
+                    url: "https://github-mcp.example.com/mcp",
+                    auth: "oauth",
+                    authTimeout: 120000,
+                },
+            },
+        });
+        expect(result.success).toBe(true);
+    });
+    it("should reject HTTP server with both auth and headers", () => {
+        const result = AgencyConfigSchema.safeParse({
+            mcpServers: {
+                github: {
+                    type: "http",
+                    url: "https://example.com/mcp",
+                    auth: "oauth",
+                    headers: { "Authorization": "Bearer token" },
+                },
+            },
+        });
+        expect(result.success).toBe(false);
+    });
+    it("should reject authTimeout without auth: oauth", () => {
+        const result = AgencyConfigSchema.safeParse({
+            mcpServers: {
+                github: {
+                    type: "http",
+                    url: "https://example.com/mcp",
+                    authTimeout: 120000,
+                },
+            },
+        });
+        expect(result.success).toBe(false);
+    });
+    it("should reject clientSecret without auth: oauth", () => {
+        const result = AgencyConfigSchema.safeParse({
+            mcpServers: {
+                github: {
+                    type: "http",
+                    url: "https://example.com/mcp",
+                    clientSecret: "secret",
+                },
+            },
+        });
+        expect(result.success).toBe(false);
+    });
+    it("should reject OAuth over plain HTTP (non-localhost)", () => {
+        const result = AgencyConfigSchema.safeParse({
+            mcpServers: {
+                github: {
+                    type: "http",
+                    url: "http://evil.com/mcp",
+                    auth: "oauth",
+                },
+            },
+        });
+        expect(result.success).toBe(false);
+    });
+    it("should allow OAuth over HTTP on localhost", () => {
+        const result = AgencyConfigSchema.safeParse({
+            mcpServers: {
+                local: {
+                    type: "http",
+                    url: "http://localhost:3000/mcp",
+                    auth: "oauth",
+                },
+            },
+        });
+        expect(result.success).toBe(true);
+    });
+    it("should reject server names with invalid characters", () => {
+        const result = AgencyConfigSchema.safeParse({
+            mcpServers: {
+                "../evil": { command: "npx", args: ["server"] },
+            },
+        });
+        expect(result.success).toBe(false);
+    });
+    it("should reject auth on stdio server", () => {
+        const result = AgencyConfigSchema.safeParse({
+            mcpServers: {
+                local: {
+                    command: "npx",
+                    args: ["some-server"],
+                    auth: "oauth",
+                },
+            },
+        });
+        expect(result.success).toBe(false);
+    });
 });

package/dist/lib/importPaths.js

@@ -229,14 +229,7 @@ export function resolveAgencyImportPath(importPath, fromFile) {
  */
 export function toCompiledImportPath(importPath, fromFile) {
     if (isStdlibImport(importPath)) {
-        const absTarget = path.join(STDLIB_DIR, normalizeStdlibPath(importPath) + ".js");
-        if (fromFile) {
-            let rel = path.relative(path.dirname(fromFile), absTarget).replace(/\\/g, "/");
-            if (!rel.startsWith("."))
-                rel = "./" + rel;
-            return rel;
-        }
-        return absTarget;
+        return "agency-lang/stdlib/" + normalizeStdlibPath(importPath) + ".js";
     }
     if (isPkgImport(importPath)) {
         // Emit bare specifier — Node resolves it at runtime via node_modules

package/dist/lib/importPaths.test.js

@@ -35,9 +35,9 @@ describe("resolveAgencyImportPath", () => {
     });
 });
 describe("toCompiledImportPath", () => {
-    it("should convert std:: paths to absolute .js paths in stdlib dir", () => {
+    it("should convert std:: paths to package-absolute paths", () => {
         const result = toCompiledImportPath("std::math");
-        expect(result).toBe(path.join(getStdlibDir(), "math.js"));
+        expect(result).toBe("agency-lang/stdlib/math.js");
     });
     it("should convert relative .agency paths to .js", () => {
         const result = toCompiledImportPath("./utils.agency");
@@ -45,17 +45,7 @@ describe("toCompiledImportPath", () => {
     });
     it("should handle std:: paths with subdirectories", () => {
         const result = toCompiledImportPath("std::collections/queue");
-        expect(result).toBe(path.join(getStdlibDir(), "collections", "queue.js"));
-    });
-});
-describe("std:: import code generation", () => {
-    it("generated import path should point to a .js file inside the stdlib dir", () => {
-        const result = toCompiledImportPath("std::math");
-        // Must be an absolute path ending with stdlib/math.js
-        expect(path.isAbsolute(result)).toBe(true);
-        expect(result).toMatch(/stdlib[/\\]math\.js$/);
-        // The stdlib dir should exist
-        expect(fs.existsSync(path.dirname(result))).toBe(true);
+        expect(result).toBe("agency-lang/stdlib/collections/queue.js");
     });
 });
 describe("isPkgImport", () => {

package/dist/lib/runtime/hooks.d.ts

@@ -70,6 +70,12 @@ export type CallbackMap = {
         error: any;
     };
     onTrace: TraceEvent;
+    onOAuthRequired: {
+        serverName: string;
+        authUrl: string;
+        complete: Promise<void>;
+        cancel: () => void;
+    };
 };
 export type CallbackReturn<K extends keyof CallbackMap> = K extends "onLLMCallStart" | "onLLMCallEnd" ? MessageJSON[] | void : void;
 export type AgencyCallbacks = {

package/dist/lib/runtime/mcp/callbackServer.d.ts

@@ -0,0 +1,20 @@
+export type CallbackServerOptions = {
+    port?: number;
+    timeoutMs?: number;
+};
+export declare class CallbackServer {
+    private server;
+    private port;
+    private _state;
+    private timeoutMs;
+    private codePromise;
+    private resolveCode;
+    private rejectCode;
+    private timeoutHandle;
+    constructor(opts?: CallbackServerOptions);
+    get state(): string;
+    get callbackUrl(): string;
+    start(): Promise<string>;
+    waitForCode(): Promise<string>;
+    stop(): Promise<void>;
+}

package/dist/lib/runtime/mcp/callbackServer.js

@@ -0,0 +1,86 @@
+import http from "http";
+import { randomBytes } from "crypto";
+const SUCCESS_HTML = `<!DOCTYPE html><html><body><h1>Authorization successful</h1><p>You can close this tab and return to your terminal.</p></body></html>`;
+const ERROR_HTML = `<!DOCTYPE html><html><body><h1>Authorization failed</h1><p>Please try again.</p></body></html>`;
+const DEFAULT_PORT = 19876;
+export class CallbackServer {
+    server = null;
+    port;
+    _state;
+    timeoutMs;
+    codePromise;
+    resolveCode;
+    rejectCode;
+    timeoutHandle = null;
+    constructor(opts = {}) {
+        this.port = opts.port ?? DEFAULT_PORT;
+        this.timeoutMs = opts.timeoutMs ?? 300_000;
+        this._state = randomBytes(32).toString("hex");
+        this.codePromise = new Promise((resolve, reject) => {
+            this.resolveCode = resolve;
+            this.rejectCode = reject;
+        });
+    }
+    get state() {
+        return this._state;
+    }
+    get callbackUrl() {
+        return `http://127.0.0.1:${this.port}/oauth/callback`;
+    }
+    async start() {
+        return new Promise((resolve, reject) => {
+            this.server = http.createServer((req, res) => {
+                const url = new URL(req.url || "/", `http://127.0.0.1:${this.port}`);
+                if (url.pathname !== "/oauth/callback") {
+                    res.writeHead(404);
+                    res.end("Not found");
+                    return;
+                }
+                const code = url.searchParams.get("code");
+                const state = url.searchParams.get("state");
+                if (state !== this._state) {
+                    res.writeHead(403, { "Content-Type": "text/html" });
+                    res.end(ERROR_HTML);
+                    return;
+                }
+                if (!code) {
+                    res.writeHead(400, { "Content-Type": "text/html" });
+                    res.end(ERROR_HTML);
+                    return;
+                }
+                res.writeHead(200, { "Content-Type": "text/html" });
+                res.end(SUCCESS_HTML);
+                this.resolveCode(code);
+                this.stop();
+            });
+            this.server.listen(this.port, "127.0.0.1", () => {
+                // When port is 0, the OS assigns a random port — read it back.
+                const addr = this.server.address();
+                if (addr && typeof addr === "object") {
+                    this.port = addr.port;
+                }
+                resolve(this.callbackUrl);
+            });
+            this.server.on("error", reject);
+            this.timeoutHandle = setTimeout(() => {
+                this.rejectCode(new Error("OAuth callback timed out"));
+                this.stop();
+            }, this.timeoutMs);
+        });
+    }
+    async waitForCode() {
+        return this.codePromise;
+    }
+    async stop() {
+        if (this.timeoutHandle) {
+            clearTimeout(this.timeoutHandle);
+            this.timeoutHandle = null;
+        }
+        if (this.server) {
+            return new Promise((resolve) => {
+                this.server.close(() => resolve());
+                this.server = null;
+            });
+        }
+    }
+}

package/dist/lib/runtime/mcp/callbackServer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/runtime/mcp/callbackServer.test.js

@@ -0,0 +1,57 @@
+import { describe, it, expect } from "vitest";
+import { CallbackServer } from "./callbackServer.js";
+// Use port 0 in tests so the OS assigns a random available port,
+// avoiding collisions with other tests or the default port.
+const testOpts = { port: 0 };
+describe("CallbackServer", () => {
+    it("should start and return a URL with the correct port", async () => {
+        const server = new CallbackServer(testOpts);
+        const url = await server.start();
+        expect(url).toMatch(/^http:\/\/127\.0\.0\.1:\d+\/oauth\/callback$/);
+        await server.stop();
+    });
+    it("should use the default fixed port when no port is specified", () => {
+        const server = new CallbackServer();
+        // Before start(), callbackUrl reflects the configured port
+        expect(server.callbackUrl).toBe("http://127.0.0.1:19876/oauth/callback");
+    });
+    it("should resolve with the authorization code when callback is received", async () => {
+        const server = new CallbackServer(testOpts);
+        const url = await server.start();
+        const state = server.state;
+        const callbackUrl = `${url}?code=auth-code-123&state=${state}`;
+        const response = await fetch(callbackUrl);
+        expect(response.ok).toBe(true);
+        const code = await server.waitForCode();
+        expect(code).toBe("auth-code-123");
+        await server.stop();
+    });
+    it("should reject when state parameter doesn't match", async () => {
+        const server = new CallbackServer(testOpts);
+        const url = await server.start();
+        const callbackUrl = `${url}?code=auth-code-123&state=wrong-state`;
+        const response = await fetch(callbackUrl);
+        expect(response.status).toBe(403);
+        await server.stop();
+    });
+    it("should reject when code is missing", async () => {
+        const server = new CallbackServer(testOpts);
+        const url = await server.start();
+        const state = server.state;
+        const callbackUrl = `${url}?state=${state}`;
+        const response = await fetch(callbackUrl);
+        expect(response.status).toBe(400);
+        await server.stop();
+    });
+    it("should time out if no callback is received", async () => {
+        const server = new CallbackServer({ ...testOpts, timeoutMs: 200 });
+        await server.start();
+        await expect(server.waitForCode()).rejects.toThrow(/timed out/i);
+        await server.stop();
+    });
+    it("should stop cleanly even if no callback was received", async () => {
+        const server = new CallbackServer(testOpts);
+        await server.start();
+        await server.stop();
+    });
+});

package/dist/lib/runtime/mcp/mcpConnection.d.ts

@@ -1,11 +1,20 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import type { McpServerConfig, McpTool } from "./types.js";
+/** Returns a connected MCP Client. Used by OAuthConnector. */
+export type ConnectorFn = () => Promise<{
+    client: Client;
+}>;
+export type McpConnectionOptions = {
+    connector?: ConnectorFn;
+};
 export declare class McpConnection {
     private client;
     private serverName;
     private config;
     private tools;
     private connected;
-    constructor(serverName: string, config: McpServerConfig);
+    private connector;
+    constructor(serverName: string, config: McpServerConfig, options?: McpConnectionOptions);
     connect(): Promise<void>;
     getTools(): McpTool[];
     callTool(toolName: string, args: Record<string, unknown>): Promise<string>;

package/dist/lib/runtime/mcp/mcpConnection.js

@@ -1,34 +1,44 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { isHttpServer, isStdioServer } from "./types.js";
 export class McpConnection {
     client;
     serverName;
     config;
     tools = [];
     connected = false;
-    constructor(serverName, config) {
+    connector;
+    constructor(serverName, config, options = {}) {
         this.serverName = serverName;
         this.config = config;
+        this.connector = options.connector;
         this.client = new Client({
             name: "agency-lang",
             version: "1.0.0",
         });
     }
     async connect() {
-        let transport;
-        if ("type" in this.config && this.config.type === "http") {
-            transport = new StreamableHTTPClientTransport(new URL(this.config.url));
+        if (this.connector) {
+            const result = await this.connector();
+            this.client = result.client;
         }
-        else {
-            const stdio = this.config;
-            transport = new StdioClientTransport({
-                command: stdio.command,
-                args: stdio.args,
-                env: stdio.env,
+        else if (isHttpServer(this.config)) {
+            const opts = {};
+            if (this.config.headers) {
+                opts.requestInit = { headers: this.config.headers };
+            }
+            const transport = new StreamableHTTPClientTransport(new URL(this.config.url), opts);
+            await this.client.connect(transport);
+        }
+        else if (isStdioServer(this.config)) {
+            const transport = new StdioClientTransport({
+                command: this.config.command,
+                args: this.config.args,
+                env: this.config.env,
             });
+            await this.client.connect(transport);
         }
-        await this.client.connect(transport);
         this.connected = true;
         const result = await this.client.listTools();
         this.tools = (result.tools || []).map((tool) => ({

package/dist/lib/runtime/mcp/mcpConnection.test.js

@@ -33,3 +33,26 @@ describe("McpConnection", () => {
         await expect(conn.connect()).rejects.toThrow();
     });
 });
+describe("McpConnection with connector", () => {
+    it("should call the connector function when connecting", async () => {
+        let connectorCalled = false;
+        const conn = new McpConnection("test", {
+            type: "http",
+            url: "https://example.com/mcp",
+            auth: "oauth",
+        }, {
+            connector: async () => {
+                connectorCalled = true;
+                throw new Error("mock connector");
+            },
+        });
+        await expect(conn.connect()).rejects.toThrow("mock connector");
+        expect(connectorCalled).toBe(true);
+    });
+    it("should not use connector for stdio servers without one", async () => {
+        const conn = new McpConnection("bad", {
+            command: "nonexistent-command",
+        });
+        await expect(conn.connect()).rejects.toThrow();
+    });
+});