Resource Subscription suddenly stopped working in TypeScript client

[SohaibBelaroussi]

Hey everyone,

I'm currently developing a TypeScript AI agent client for Joinly and I've run into an issue with resource subscriptions that I'm hoping you can help me with.

I successfully implemented resource subscription, and it was working as expected for a while. However, a couple of days ago, it suddenly stopped functioning. I'm now unsure if the problem lies within my own implementation, Joinly's services, or potentially the TypeScript MCP SDK itself.

If anyone here has successfully used TypeScript for resource subscriptions and can offer some guidance, I would be extremely grateful!

I've attached a minimal code snippet that connects to the Joinly MCP. If you could take a look and point out any potential mistakes I might be making, that would be incredibly helpful.

Thank you all for your hard work!

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
import { z } from "zod";
import dotenv from "dotenv";

dotenv.config();

let client: Client | undefined = undefined;

const ResourceUpdatedNotificationSchema = z.object({
  method: z.literal("notifications/resources/updated"),
  params: z.object({
    uri: z.string(),
    updates: z.array(z.any()),
  }),
});

async function main() {
  try {
    client = new Client(
      { name: "streamable-http-client", version: "1.0.0" },
      { capabilities: { resources: { subscribe: true } } }
    );

    const transport = new StreamableHTTPClientTransport(
      new URL(process.env.JOINLY_URL!),
    );
    await client.connect(transport);

    const tools = await client.listTools();
    console.log("Available tools:", tools);

    const resources = await client.listResources();
    console.log("Available resources:", resources);

    await client.callTool({
      name: "join_meeting",
      arguments: {
        meeting_url: process.env.MEETING_URL!,
        participant_name: "Nova",
      },
    });
    console.log("✅ Joined the meeting");

    console.log("⏳ Waiting 10 seconds before reading the transcript...");
    await new Promise((resolve) => setTimeout(resolve, 10000));
    
    client.setNotificationHandler(
        ResourceUpdatedNotificationSchema,
        async (notification) => {
            console.log("🔔 Resource update notification received!");
            console.log("URI:", notification.params.uri);
            console.log("Updates:", notification.params.updates);
        }
    );
    
    await client.subscribeResource({ uri: "transcript://live" });
    console.log("✅ Subscribed to transcript://live");

    let transcript = await client.readResource({uri: "transcript://live"});
    console.log("💬 Transcript", transcript);

    // Keep process alive
    await new Promise(() => {});
  } catch (e) {
    console.error("Streamable HTTP connection failed:", e);
  }
}

process.on("SIGINT", async () => {
  console.log("\n🛑 Shutting down gracefully...");
  if (client) {
    await client.callTool({
      name: "leave_meeting",
      arguments: {},
    });
    console.log("✅ Left the meeting");

    await client.close();
    console.log("✅ Disconnected from MCP");
  }
  process.exit(0);
});

main().catch(console.error);

[dbrockmann]

Hey, that's so cool! I ran your code, and I think the issue is your notification schema which includes an additional updates. With the following, it successfully receives updates:

const ResourceUpdatedNotificationSchema = z.object({
  method: z.literal("notifications/resources/updated"),
  params: z.object({
    uri: z.string(),
  }),
});

The MCP spec:

{
  "jsonrpc": "2.0",
  "method": "notifications/resources/updated",
  "params": {
    "uri": "file:///project/src/main.rs"
  }
}

To then get the updated resource, you can make a read resource request on received update notifications.