@goke/mcp 0.0.13 → 0.1.1

package/src/__test__/create-mcp-action.test.ts

@@ -292,6 +292,153 @@ describe("createMcpAction", () => {
     }
   });
 
+  it("keeps --flag <value> in properties but not in required", async () => {
+    const cli = goke("strada");
+
+    cli
+      .command("projects create <slug>", "Create a project")
+      .option("--traces-days <days>", z.string().optional().describe("Traces retention days"))
+      .option("--logs-days <days>", z.string().optional().describe("Logs retention days"))
+      .option("--errors-days <days>", z.string().optional().describe("Errors retention days"))
+      .option("--metrics-days <days>", z.string().optional().describe("Metrics retention days"))
+      .option("--all-days <days>", z.string().optional().describe("Retention for all signals"))
+      .action((slug, options) => ({ slug, ...options }));
+
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+
+    cli.command("mcp", "Start MCP server").action(
+      createMcpAction({
+        cli,
+        createTransport: () => serverTransport,
+      }),
+    );
+
+    cli.matchedCommandName = "mcp";
+    const mcpCommand = cli.commands.find((c) => c.name === "mcp")!;
+    await mcpCommand.commandAction!({});
+
+    const client = new Client({ name: "test-client", version: "1.0.0" }, { capabilities: {} });
+    await client.connect(clientTransport);
+
+    try {
+      const tools = await client.listTools();
+      const createTool = tools.tools.find((t) => t.name === "projects_create")!;
+      expect(createTool.inputSchema.properties).toHaveProperty("slug");
+      expect(createTool.inputSchema.properties).toHaveProperty("tracesDays");
+      expect(createTool.inputSchema.properties).toHaveProperty("logsDays");
+      expect(createTool.inputSchema.properties).toHaveProperty("allDays");
+      expect(createTool.inputSchema.required).toEqual(["slug"]);
+
+      const result = await client.callTool({
+        name: "projects_create",
+        arguments: { slug: "my-app" },
+      });
+      expect(firstTextContent(result)).toBe('{\n  "slug": "my-app"\n}');
+
+      await expect(
+        client.callTool({
+          name: "projects_create",
+          arguments: {},
+        }),
+      ).rejects.toThrow("Missing required argument: slug");
+    } finally {
+      await client.close();
+    }
+  });
+
+  it("puts schema-required --flag <value> in inputSchema.required", async () => {
+    const cli = goke("checks");
+
+    cli
+      .command("checks create", "Create a check")
+      .option("--url <url>", z.string().describe("URL to check"))
+      .option("--name <name>", z.string().describe("Check name"))
+      .option("--timeout [ms]", z.number().optional().describe("Timeout"))
+      .action((options) => options);
+
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+
+    cli.command("mcp", "Start MCP server").action(
+      createMcpAction({
+        cli,
+        createTransport: () => serverTransport,
+      }),
+    );
+
+    cli.matchedCommandName = "mcp";
+    const mcpCommand = cli.commands.find((c) => c.name === "mcp")!;
+    await mcpCommand.commandAction!({});
+
+    const client = new Client({ name: "test-client", version: "1.0.0" }, { capabilities: {} });
+    await client.connect(clientTransport);
+
+    try {
+      const tools = await client.listTools();
+      const createTool = tools.tools.find((t) => t.name === "checks_create")!;
+      expect(createTool.inputSchema.properties).toHaveProperty("url");
+      expect(createTool.inputSchema.properties).toHaveProperty("name");
+      expect(createTool.inputSchema.properties).toHaveProperty("timeout");
+      expect(createTool.inputSchema.required).toEqual(["url", "name"]);
+
+      const result = await client.callTool({
+        name: "checks_create",
+        arguments: { url: "https://example.com", name: "home" },
+      });
+      expect(firstTextContent(result)).toContain("https://example.com");
+
+      await expect(
+        client.callTool({
+          name: "checks_create",
+          arguments: { name: "home" },
+        }),
+      ).rejects.toThrow("Missing required argument: url");
+    } finally {
+      await client.close();
+    }
+  });
+
+  it("does not put wrapJsonSchema flags in required", async () => {
+    const cli = goke("wrapped");
+
+    cli
+      .command("config set", "Set a config value")
+      .option("--key <key>", wrapJsonSchema({ type: "string", description: "Config key" }))
+      .option("--value <value>", wrapJsonSchema({ type: "string", description: "Config value" }))
+      .action((options) => options);
+
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+
+    cli.command("mcp", "Start MCP server").action(
+      createMcpAction({
+        cli,
+        createTransport: () => serverTransport,
+      }),
+    );
+
+    cli.matchedCommandName = "mcp";
+    const mcpCommand = cli.commands.find((c) => c.name === "mcp")!;
+    await mcpCommand.commandAction!({});
+
+    const client = new Client({ name: "test-client", version: "1.0.0" }, { capabilities: {} });
+    await client.connect(clientTransport);
+
+    try {
+      const tools = await client.listTools();
+      const setTool = tools.tools.find((t) => t.name === "config_set")!;
+      expect(setTool.inputSchema.properties).toHaveProperty("key");
+      expect(setTool.inputSchema.properties).toHaveProperty("value");
+      expect(setTool.inputSchema.required).toBeUndefined();
+
+      const result = await client.callTool({
+        name: "config_set",
+        arguments: {},
+      });
+      expect(firstTextContent(result)).toBe("{}");
+    } finally {
+      await client.close();
+    }
+  });
+
   it("returns empty tool list when only the mcp command exists", async () => {
     const cli = goke("empty-app");
 

package/src/__test__/http-multi-tenant.test.ts

@@ -1,10 +1,11 @@
 /**
  * Multi-tenant remote-MCP test.
  *
- * Proves that one goke cli exposed over the MCP streamable-HTTP
- * transport can serve multiple concurrent users with fully isolated
- * state (in-memory fs + cwd + env) — no shared host process stdio,
- * no cross-tenant leaks.
+ * Proves that one goke cli exposed over stateless MCP streamable HTTP
+ * can serve multiple concurrent users with fully isolated state
+ * (in-memory fs + cwd + env) — no shared host process stdio, no
+ * cross-tenant leaks, no mcp-session-id map. Isolation comes from
+ * the `x-tenant-id` header on each POST, not from `Mcp-Session-Id`.
  *
  * Wiring choices worth calling out:
  *
@@ -14,19 +15,21 @@
  *     transport's `fetch` hook without ever binding a TCP socket
  *     or spinning up `node:http` / Express. Same wire protocol,
  *     zero sockets.
- *   - `enableJsonResponse: true` switches the transport off SSE and
- *     into pure request/response JSON. GET SSE opens are answered
- *     with `405`, which the client treats as "server does not offer
- *     SSE" and moves on (see `_startOrAuthSse` in the SDK client).
- *   - Each session gets its own cli **clone** via
+ *   - `sessionIdGenerator: undefined` is stateless mode. The
+ *     transport does not emit or expect `mcp-session-id`. Each
+ *     POST builds a fresh Server + transport, then closes them.
+ *   - `enableJsonResponse: true` switches the transport off SSE
+ *     and into pure request/response JSON. GET SSE opens are
+ *     answered with `405`, which the client treats as "server
+ *     does not offer SSE" and moves on (see `_startOrAuthSse`
+ *     in the SDK client).
+ *   - Each request gets its own cli **clone** via
  *     `baseCli.clone({ cwd, env, fs })`. The clone inherits the
  *     command tree but owns its own `{ cwd, env, fs }`, which is
  *     what `runCliTool` forwards into every action through
  *     `ctx.process.*` / `ctx.fs`.
  */
 
-import { randomUUID } from "node:crypto";
-import { Buffer } from "node:buffer";
 import path from "node:path";
 
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
@@ -34,7 +37,6 @@ import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/
 import { Server as McpLowLevelServer } from "@modelcontextprotocol/sdk/server/index.js";
 import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
 import type { FetchLike } from "@modelcontextprotocol/sdk/shared/transport.js";
-import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
 import { goke, type Goke, type GokeFs } from "goke";
 import { describe, expect, it } from "vitest";
 import { z } from "zod";
@@ -94,7 +96,7 @@ class InMemoryFs implements GokeFs {
  * One cli definition, reused across tenants. Commands read / write
  * through `ctx.fs` and resolve paths against `ctx.process.cwd`, so
  * the *same* code runs per tenant but talks to a tenant-specific
- * filesystem when invoked via the session-scoped clone below.
+ * filesystem when invoked via the per-request clone below.
  */
 function buildBaseCli(): Goke {
   const cli = goke("notes-app");
@@ -122,9 +124,8 @@ function buildBaseCli(): Goke {
 // ─── In-process multi-tenant fetch ────────────────────────────────
 
 /**
- * Per-tenant state resolved from the `x-tenant-id` header on a
- * session-initialization request. Each tenant gets its own cwd,
- * env, and in-memory fs.
+ * Per-tenant state resolved from the `x-tenant-id` header on every
+ * POST. Each tenant gets its own cwd, env, and in-memory fs.
  */
 interface TenantState {
   cwd: string;
@@ -133,41 +134,40 @@ interface TenantState {
 }
 
 /**
- * Build a `FetchLike` that routes MCP streamable-HTTP traffic into
- * in-process session-scoped `WebStandardStreamableHTTPServerTransport`
- * instances. One transport + one cli clone per session. Each session
- * is keyed by `mcp-session-id`; initialization requests pick a tenant
- * via the `x-tenant-id` header.
- *
- * Returns both the custom fetch and the transports map so tests can
- * inspect session state if needed.
+ * Build a `FetchLike` that handles each MCP POST with a fresh
+ * `WebStandardStreamableHTTPServerTransport` and cli clone.
+ * Tenant identity comes from `x-tenant-id` on every request.
+ * Nothing is keyed by `mcp-session-id`.
  */
 function createMultiTenantFetch(options: {
   baseCli: Goke;
   resolveTenant: (tenantId: string) => TenantState;
 }): {
   fetch: FetchLike;
-  transports: Map<string, WebStandardStreamableHTTPServerTransport>;
+  sessionHeaders: string[];
 } {
   const { baseCli, resolveTenant } = options;
-  const transports = new Map<string, WebStandardStreamableHTTPServerTransport>();
+  const sessionHeaders: string[] = [];
 
   const customFetch: FetchLike = async (url, init) => {
     const method = (init?.method ?? "GET").toUpperCase();
     const headers = new Headers(init?.headers);
+    const sessionHeader = headers.get("mcp-session-id");
+    if (sessionHeader) {
+      sessionHeaders.push(sessionHeader);
+    }
+
+    const origin = headers.get("origin");
+    if (origin && origin !== "http://in-memory-mcp.test") {
+      return new Response(null, { status: 403 });
+    }
 
-    // Pure request/response mode: tell the client there's no SSE
-    // available on GET. `_startOrAuthSse` in the SDK client treats
-    // 405 as "server does not offer SSE" and moves on gracefully.
-    if (method === "GET") {
-      return new Response(null, { status: 405 });
+    if (method !== "POST") {
+      return new Response(null, { status: 405, headers: { Allow: "POST" } });
     }
 
-    // Parse POST body once and hand it to the transport via
-    // `parsedBody` in `HandleRequestOptions` so we don't have to
-    // worry about Request body streams being single-use.
     let parsedBody: unknown = undefined;
-    if (method === "POST" && init?.body != null) {
+    if (init?.body != null) {
       const rawBody = init.body;
       const bodyText = typeof rawBody === "string"
         ? rawBody
@@ -177,35 +177,11 @@ function createMultiTenantFetch(options: {
       }
     }
 
-    // Rebuild a plain Request with the same method + headers. The
-    // transport reads accept/content-type from here and uses
-    // `parsedBody` for the actual JSON-RPC payload.
     const request = new Request(url.toString(), {
       method,
       headers,
     });
 
-    const sessionId = headers.get("mcp-session-id");
-
-    // Existing session: route to its transport.
-    if (sessionId && transports.has(sessionId)) {
-      return transports.get(sessionId)!.handleRequest(request, { parsedBody });
-    }
-
-    // New session: must be an initialize POST.
-    if (method !== "POST" || !isInitializeRequest(parsedBody)) {
-      return new Response(
-        JSON.stringify({
-          jsonrpc: "2.0",
-          error: { code: -32000, message: "Bad Request: No valid session ID provided" },
-          id: null,
-        }),
-        { status: 400, headers: { "content-type": "application/json" } },
-      );
-    }
-
-    // Resolve the tenant from the custom header, build a cli clone
-    // with its cwd/env/fs, and spin up a session-scoped MCP server.
     const tenantId = headers.get("x-tenant-id");
     if (!tenantId) {
       return new Response("missing x-tenant-id header", { status: 401 });
@@ -225,29 +201,20 @@ function createMultiTenantFetch(options: {
     addCliToolsToMcp({ cli: tenantCli, server: mcpServer });
 
     const transport = new WebStandardStreamableHTTPServerTransport({
-      sessionIdGenerator: () => randomUUID(),
-      // Pure request/response — no SSE streaming to clean up.
+      sessionIdGenerator: undefined,
       enableJsonResponse: true,
-      onsessioninitialized: (sid) => {
-        transports.set(sid, transport);
-      },
-      onsessionclosed: (sid) => {
-        transports.delete(sid);
-      },
     });
 
-    transport.onclose = () => {
-      const sid = transport.sessionId;
-      if (sid) {
-        transports.delete(sid);
-      }
-    };
-
     await mcpServer.connect(transport);
-    return transport.handleRequest(request, { parsedBody });
+    try {
+      return await transport.handleRequest(request, { parsedBody });
+    } finally {
+      await transport.close();
+      await mcpServer.close();
+    }
   };
 
-  return { fetch: customFetch, transports };
+  return { fetch: customFetch, sessionHeaders };
 }
 
 // ─── Tests ────────────────────────────────────────────────────────
@@ -267,7 +234,7 @@ describe("remote MCP over streamable HTTP with multi-tenant in-memory fs", () =>
       fs: new InMemoryFs(),
     });
 
-    const { fetch: tenantFetch } = createMultiTenantFetch({
+    const { fetch: tenantFetch, sessionHeaders } = createMultiTenantFetch({
       baseCli,
       resolveTenant: (id) => {
         const tenant = tenants.get(id);
@@ -276,8 +243,6 @@ describe("remote MCP over streamable HTTP with multi-tenant in-memory fs", () =>
       },
     });
 
-    // The URL is a placeholder — the in-process fetch never looks
-    // at the host, just the method/headers/body.
     const endpoint = new URL("http://in-memory-mcp.test/mcp");
 
     async function connectTenant(tenantId: string): Promise<Client> {
@@ -297,7 +262,7 @@ describe("remote MCP over streamable HTTP with multi-tenant in-memory fs", () =>
       return client;
     }
 
-    return { tenants, connectTenant };
+    return { tenants, connectTenant, sessionHeaders };
   }
 
   function firstTextBlock(result: Awaited<ReturnType<Client["callTool"]>>): string {
@@ -305,23 +270,18 @@ describe("remote MCP over streamable HTTP with multi-tenant in-memory fs", () =>
     return content.find((block) => block.type === "text")?.text ?? "";
   }
 
-  it("routes each session to its own cli clone with tenant-specific cwd/env/fs", async () => {
-    const { tenants, connectTenant } = setupScenario();
+  it("routes each request to its own cli clone with tenant-specific cwd/env/fs", async () => {
+    const { tenants, connectTenant, sessionHeaders } = setupScenario();
 
     const aliceClient = await connectTenant("tenant-a");
     const bobClient = await connectTenant("tenant-b");
 
     try {
-      // Each client sees the same tool catalog — it comes from the
-      // shared cli definition.
       const aliceTools = (await aliceClient.listTools()).tools.map((t) => t.name).sort();
       const bobTools = (await bobClient.listTools()).tools.map((t) => t.name).sort();
       expect(aliceTools).toEqual(["load", "save"]);
       expect(bobTools).toEqual(["load", "save"]);
 
-      // Both tenants write a file called `notes.txt` with different
-      // content. Since each session uses its own cli clone (with
-      // its own cwd + fs), the writes land in separate Maps.
       const aliceSave = await aliceClient.callTool({
         name: "save",
         arguments: { filename: "notes.txt", content: "alice-secret" },
@@ -336,7 +296,6 @@ describe("remote MCP over streamable HTTP with multi-tenant in-memory fs", () =>
       expect(firstTextBlock(bobSave)).toContain("/workspace-b/notes.txt");
       expect(firstTextBlock(bobSave)).toContain("tenant-b");
 
-      // Each tenant reads back what it wrote.
       const aliceLoad = await aliceClient.callTool({
         name: "load",
         arguments: { filename: "notes.txt" },
@@ -351,14 +310,13 @@ describe("remote MCP over streamable HTTP with multi-tenant in-memory fs", () =>
       expect(firstTextBlock(bobLoad)).toContain("bob-secret");
       expect(firstTextBlock(bobLoad)).not.toContain("alice-secret");
 
-      // Sanity check: the underlying in-memory maps really are
-      // disjoint. Tenant A's fs only has tenant A's file.
       const tenantAFs = tenants.get("tenant-a")!.fs;
       const tenantBFs = tenants.get("tenant-b")!.fs;
       expect([...tenantAFs.files.keys()]).toEqual(["/workspace-a/notes.txt"]);
       expect([...tenantBFs.files.keys()]).toEqual(["/workspace-b/notes.txt"]);
       expect(tenantAFs.files.get("/workspace-a/notes.txt")).toBe("alice-secret");
       expect(tenantBFs.files.get("/workspace-b/notes.txt")).toBe("bob-secret");
+      expect(sessionHeaders).toEqual([]);
     } finally {
       await aliceClient.close();
       await bobClient.close();
@@ -380,4 +338,25 @@ describe("remote MCP over streamable HTTP with multi-tenant in-memory fs", () =>
       await bobClient.close();
     }
   });
+
+  it("rejects a present Origin that is not allowed", async () => {
+    const { fetch } = createMultiTenantFetch({
+      baseCli: buildBaseCli(),
+      resolveTenant: () => {
+        throw new Error("tenant must not be resolved for a forbidden origin");
+      },
+    });
+
+    const response = await fetch("http://in-memory-mcp.test/mcp", {
+      method: "POST",
+      headers: {
+        origin: "https://evil.example",
+        "x-tenant-id": "tenant-a",
+        "content-type": "application/json",
+      },
+      body: "{}",
+    });
+
+    expect(response.status).toBe(403);
+  });
 });

package/src/auth.ts

@@ -29,8 +29,10 @@ async function openBrowser(url: string): Promise<void> {
 
 /**
  * Start the OAuth flow for an MCP server.
- * This is an internal function - consumers should not call this directly.
- * It is automatically triggered by addMcpCommands when a 401 error occurs.
+ *
+ * Used internally by addMcpCommands on 401 errors, but also available
+ * for CLIs that need explicit control over the auth flow (e.g. a login
+ * command that runs the flow in a background daemon).
  *
  * This function:
  * 1. Starts a local callback server on a random port

package/src/cli-to-mcp.ts

@@ -20,6 +20,7 @@ import {
   coerceBySchema,
   extractJsonSchema,
   GokeProcessExit,
+  schemaAcceptsOmittedValue,
   type Command,
   type Goke,
   type GokeExecutionContext,
@@ -503,11 +504,18 @@ function createBinding(cli: Goke, command: Command, toolName: string): CliToolBi
     }
   }
 
+  // `--days <days>` means "value required if the flag is present". The flag
+  // itself is required only when a non-optional schema rejects `undefined`.
   for (const option of options) {
     const normalized = normalizeOptionSchema(option);
     properties[option.name] = normalized.schema;
 
-    if (option.required) {
+    if (
+      option.required
+      && option.default === undefined
+      && option.schema
+      && !schemaAcceptsOmittedValue(option.schema)
+    ) {
       requiredNames.push(option.name);
     }
 

package/src/index.ts

@@ -9,7 +9,6 @@
  *
  * - **Auto-discovery**: Fetches all tools from the MCP server and creates CLI commands
  * - **Caching**: Tools are cached for 1 hour to avoid reconnecting on every invocation
- * - **Session reuse**: MCP session IDs are cached to skip initialization handshake
  * - **Type-aware parsing**: Handles string, number, boolean, object, and array arguments
  * - **JSON schema support**: Generates CLI options from tool input schemas
  * - **OAuth support**: Automatic OAuth authentication on 401 errors (lazy auth)
@@ -48,13 +47,14 @@ import { wrapJsonSchema } from "goke";
 import yaml from "js-yaml";
 import { FileOAuthProvider } from "./oauth-provider.js";
 import { startOAuthFlow, isAuthRequiredError } from "./auth.js";
+export { startOAuthFlow } from "./auth.js";
 import type { McpOAuthConfig, McpOAuthState } from "./types.js";
 export { addCliToolsToMcp, createMcpAction } from "./cli-to-mcp.js";
 export type { AddCliToolsToMcpOptions, CreateMcpActionOptions } from "./cli-to-mcp.js";
 
-// Public exports - only types that consumers need
+// Public exports
 export type { Transport };
-export type { McpOAuthConfig, McpOAuthState } from "./types.js";
+export type { McpOAuthConfig, McpOAuthState, StartOAuthFlowOptions, OAuthFlowResult } from "./types.js";
 
 export interface CachedMcpTools {
   tools: Array<{
@@ -63,7 +63,6 @@ export interface CachedMcpTools {
     inputSchema?: unknown;
   }>;
   timestamp: number;
-  sessionId?: string;
 }
 
 const CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
@@ -91,9 +90,8 @@ export interface AddMcpCommandsOptions {
   /**
    * Returns a transport to connect to the MCP server, or null if not configured.
    * Use this for stdio servers or any setup `getMcpUrl` cannot express.
-   * @param sessionId - Optional session ID from a still-valid cache
    */
-  getMcpTransport?: (sessionId?: string) => Transport | null | Promise<Transport | null>;
+  getMcpTransport?: () => Transport | null | Promise<Transport | null>;
 
   /**
    * Argv used to decide whether to skip live discovery.
@@ -251,13 +249,11 @@ function matchesRegisteredCommand({ argv, cli }: { argv: string[]; cli: Goke })
 
 function createTransportWithAuth({
   url,
-  sessionId,
   oauthState,
   oauth,
   headers,
 }: {
   url: URL
-  sessionId?: string
   oauthState?: McpOAuthState
   oauth?: McpOAuthConfig
   headers?: Record<string, string>
@@ -280,7 +276,6 @@ function createTransportWithAuth({
 
   const hasHeaders = headers && Object.keys(headers).length > 0;
   return new StreamableHTTPClientTransport(url, {
-    sessionId,
     authProvider,
     requestInit: hasHeaders ? { headers } : undefined,
   });
@@ -292,7 +287,6 @@ function createTransportWithAuth({
  * Adds MCP tool commands to a goke CLI instance.
  *
  * Tools are cached for 1 hour to avoid connecting on every CLI invocation.
- * Session ID is also cached to skip MCP initialization handshake.
  *
  * OAuth is lazy - authentication only happens when a 401 error occurs.
  * After successful auth, the operation is automatically retried.
@@ -311,9 +305,7 @@ export async function addMcpCommands(options: AddMcpCommandsOptions): Promise<vo
     argv = process.argv.slice(2),
   } = options;
 
-  // Helper to get transport - supports both old and new API
-  const getTransport = async (sessionId?: string): Promise<Transport | null> => {
-    // New API: getMcpUrl + oauth
+  const getTransport = async (): Promise<Transport | null> => {
     if (getMcpUrl) {
       const mcpUrl = getMcpUrl();
       if (!mcpUrl) {
@@ -325,16 +317,14 @@ export async function addMcpCommands(options: AddMcpCommandsOptions): Promise<vo
 
       return createTransportWithAuth({
         url,
-        sessionId,
         oauthState,
         oauth,
         headers: getHeaders?.(),
       });
     }
 
-    // Custom / stdio transport
     if (getMcpTransport) {
-      return getMcpTransport(sessionId);
+      return getMcpTransport();
     }
 
     return null;
@@ -376,11 +366,9 @@ export async function addMcpCommands(options: AddMcpCommandsOptions): Promise<vo
     isHelpOrMetaArgv(argv) || matchesRegisteredCommand({ argv, cli });
 
   let tools: CachedMcpTools["tools"] | undefined;
-  let cachedSessionId: string | undefined;
 
   if (isCacheValid && cachedTools) {
     tools = cachedTools.tools;
-    cachedSessionId = cachedTools.sessionId;
   } else if (skipLiveDiscovery) {
     if (cachedTools) {
       tools = cachedTools.tools;
@@ -394,8 +382,6 @@ export async function addMcpCommands(options: AddMcpCommandsOptions): Promise<vo
         const result = await client.listTools();
         tools = result.tools;
 
-        const sessionId = (transport as { sessionId?: string }).sessionId;
-
         saveCache({
           tools: tools.map((t) => ({
             name: t.name,
@@ -403,9 +389,7 @@ export async function addMcpCommands(options: AddMcpCommandsOptions): Promise<vo
             inputSchema: t.inputSchema,
           })),
           timestamp: Date.now(),
-          sessionId,
         });
-        cachedSessionId = sessionId;
       } catch (err) {
         const shouldAuth = isAuthRequiredError(err) && oauth && getMcpUrl && !skipLiveDiscovery;
         if (shouldAuth) {
@@ -480,7 +464,7 @@ export async function addMcpCommands(options: AddMcpCommandsOptions): Promise<vo
       const parsedArgs = extractToolArguments(cliOptions, inputSchema);
 
       const executeWithRetry = async (isRetry = false): Promise<void> => {
-        const transport = await getTransport(isRetry ? undefined : cachedSessionId);
+        const transport = await getTransport();
         if (!transport) {
           console.error("MCP transport not available. Run login command first.");
           process.exit(1);