@decocms/mesh-sdk 1.2.1 → 1.2.2

package/src/hooks/use-mcp-client.ts

@@ -21,6 +21,12 @@ export interface CreateMcpClientOptions {
 
 export type UseMcpClientOptions = CreateMcpClientOptions;
 
+export interface UseMcpClientOptionalOptions
+  extends Omit<CreateMcpClientOptions, "connectionId"> {
+  /** Connection ID - string for connection MCP, null for default/self, undefined to skip (returns null) */
+  connectionId: string | null | undefined;
+}
+
 /**
  * Build the MCP URL from connectionId and optional meshUrl
  * Uses /mcp/:connectionId for all servers
@@ -89,6 +95,7 @@ export async function createMCPClient({
     token ?? "",
     meshUrl ?? "",
   );
+
   (client as Client & { toJSON: () => string }).toJSON = () =>
     `mcp-client:${queryKey.join(":")}`;
 
@@ -110,7 +117,7 @@ export function useMCPClient({
 }: UseMcpClientOptions): Client {
   const queryKey = KEYS.mcpClient(
     orgId,
-    connectionId ?? "",
+    connectionId ?? "self",
     token ?? "",
     meshUrl ?? "",
   );
@@ -122,6 +129,52 @@ export function useMCPClient({
     gcTime: 0, // Clean up immediately when query is inactive
   });
 
-  // useSuspenseQuery guarantees data is available (suspends until ready)
   return client!;
 }
+
+/**
+ * Optional MCP client - returns null when connectionId is undefined (skip creating client).
+ * Use when the connection may not be selected yet (e.g. model picker with no connections).
+ *
+ * - connectionId: string → connection-specific MCP
+ * - connectionId: null → default/self MCP
+ * - connectionId: undefined → skip (returns null, no MCP call)
+ *
+ * @param options - Configuration for the MCP client
+ * @returns The MCP client instance, or null when connectionId is undefined
+ */
+export function useMCPClientOptional({
+  connectionId,
+  orgId,
+  token,
+  meshUrl,
+}: UseMcpClientOptionalOptions): Client | null {
+  const queryKey =
+    connectionId !== undefined
+      ? KEYS.mcpClient(
+          orgId,
+          connectionId ?? "self",
+          token ?? "",
+          meshUrl ?? "",
+        )
+      : (["mcp", "client", "skip", orgId] as const);
+
+  const { data: client } = useSuspenseQuery({
+    queryKey,
+    queryFn: async () => {
+      if (connectionId === undefined) {
+        return null;
+      }
+      return createMCPClient({
+        connectionId: connectionId as string | null,
+        orgId,
+        token,
+        meshUrl,
+      });
+    },
+    staleTime: Infinity,
+    gcTime: 0,
+  });
+
+  return client ?? null;
+}

package/src/hooks/use-mcp-prompts.ts

@@ -1,4 +1,11 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import {
+  ErrorCode,
+  McpError,
+  type GetPromptRequest,
+  type GetPromptResult,
+  type ListPromptsResult,
+} from "@modelcontextprotocol/sdk/types.js";
 import {
   useQuery,
   UseQueryResult,
@@ -7,11 +14,6 @@ import {
   type UseQueryOptions,
   type UseSuspenseQueryOptions,
 } from "@tanstack/react-query";
-import type {
-  GetPromptRequest,
-  GetPromptResult,
-  ListPromptsResult,
-} from "@modelcontextprotocol/sdk/types.js";
 import { KEYS } from "../lib/query-keys";
 
 /**
@@ -23,7 +25,15 @@ export async function listPrompts(client: Client): Promise<ListPromptsResult> {
   if (!capabilities?.prompts) {
     return { prompts: [] };
   }
-  return await client.listPrompts();
+
+  try {
+    return await client.listPrompts();
+  } catch (error) {
+    if (error instanceof McpError && error.code === ErrorCode.MethodNotFound) {
+      return { prompts: [] };
+    }
+    throw error;
+  }
 }
 
 /**

package/src/hooks/use-mcp-resources.ts

@@ -1,4 +1,10 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import {
+  ErrorCode,
+  McpError,
+  type ListResourcesResult,
+  type ReadResourceResult,
+} from "@modelcontextprotocol/sdk/types.js";
 import {
   useQuery,
   useSuspenseQuery,
@@ -7,10 +13,6 @@ import {
   type UseSuspenseQueryOptions,
   type UseSuspenseQueryResult,
 } from "@tanstack/react-query";
-import type {
-  ListResourcesResult,
-  ReadResourceResult,
-} from "@modelcontextprotocol/sdk/types.js";
 import { KEYS } from "../lib/query-keys";
 
 /**
@@ -24,7 +26,15 @@ export async function listResources(
   if (!capabilities?.resources) {
     return { resources: [] };
   }
-  return await client.listResources();
+
+  try {
+    return await client.listResources();
+  } catch (error) {
+    if (error instanceof McpError && error.code === ErrorCode.MethodNotFound) {
+      return { resources: [] };
+    }
+    throw error;
+  }
 }
 
 /**

package/src/index.ts

@@ -2,11 +2,16 @@
 export {
   ProjectContextProvider,
   useProjectContext,
+  useOrg,
+  useCurrentProject,
+  useIsOrgAdmin,
   Locator,
-  ORG_ADMIN_PROJECT_SLUG,
   type ProjectContextProviderProps,
   type ProjectLocator,
   type LocatorStructured,
+  type OrganizationData,
+  type ProjectData,
+  type ProjectUI,
 } from "./context";
 
 // Hooks
@@ -15,9 +20,14 @@ export {
   useCollectionItem,
   useCollectionList,
   useCollectionActions,
+  buildWhereExpression,
+  buildOrderByExpression,
+  buildCollectionQueryKey,
+  EMPTY_COLLECTION_LIST_RESULT,
   type CollectionEntity,
   type CollectionFilter,
   type UseCollectionListOptions,
+  type CollectionQueryKey,
   // Connection hooks
   useConnections,
   useConnection,
@@ -27,8 +37,10 @@ export {
   // MCP client hook and factory
   createMCPClient,
   useMCPClient,
+  useMCPClientOptional,
   type CreateMcpClientOptions,
   type UseMcpClientOptions,
+  type UseMcpClientOptionalOptions,
   // MCP tools hooks
   useMCPToolsList,
   useMCPToolsListQuery,
@@ -68,6 +80,17 @@ export {
 
 // Types
 export {
+  // AI Provider types
+  PROVIDER_IDS,
+  MODEL_CAPABILITIES,
+  type ProviderId,
+  type ModelCapability,
+  type AiProviderModel,
+  type AiProviderModelLimits,
+  type AiProviderModelCosts,
+  type AiProviderKey,
+  type AiProviderInfo,
+  // Connection types
   ConnectionEntitySchema,
   ConnectionCreateDataSchema,
   ConnectionUpdateDataSchema,
@@ -90,20 +113,58 @@ export {
   type VirtualMCPCreateData,
   type VirtualMCPUpdateData,
   type VirtualMCPConnection,
-  type ToolSelectionMode,
+  // Decopilot event types
+  THREAD_STATUSES,
+  THREAD_DISPLAY_STATUSES,
+  DECOPILOT_EVENTS,
+  ALL_DECOPILOT_EVENT_TYPES,
+  createDecopilotStepEvent,
+  createDecopilotFinishEvent,
+  createDecopilotThreadStatusEvent,
+  type ThreadStatus,
+  type ThreadDisplayStatus,
+  type DecopilotEventType,
+  type DecopilotStepEvent,
+  type DecopilotFinishEvent,
+  type DecopilotThreadStatusEvent,
+  type DecopilotSSEEvent,
+  type DecopilotEventMap,
 } from "./types";
 
 // Streamable HTTP transport
 export { StreamableHTTPClientTransport } from "./lib/streamable-http-client-transport";
 
+// Bridge transport
+export {
+  createBridgeTransportPair,
+  BridgeClientTransport,
+  BridgeServerTransport,
+  type BridgeTransportPair,
+} from "./lib/bridge-transport";
+
+// Server-client bridge
+export {
+  createServerFromClient,
+  type ServerFromClientOptions,
+} from "./lib/server-client-bridge";
+
 // Query keys
 export { KEYS } from "./lib/query-keys";
 
+// Default model selection
+export {
+  DEFAULT_MODEL_PREFERENCES,
+  FAST_MODEL_PREFERENCES,
+  selectDefaultModel,
+  getFastModel,
+} from "./lib/default-model";
+
 // MCP OAuth utilities
 export {
   authenticateMcp,
   handleOAuthCallback,
   isConnectionAuthenticated,
+  setOAuthRedirectOrigin,
   type McpOAuthProviderOptions,
   type OAuthTokenInfo,
   type AuthenticateMcpResult,
@@ -111,18 +172,36 @@ export {
   type OAuthWindowMode,
 } from "./lib/mcp-oauth";
 
+// Usage utilities
+export {
+  getCostFromUsage,
+  emptyUsageStats,
+  addUsage,
+  calculateUsageStats,
+  sanitizeProviderMetadata,
+  type UsageData,
+  type UsageStats,
+} from "./lib/usage";
+
 // Constants and well-known MCP definitions
 export {
   // Frontend self MCP ID
   SELF_MCP_ALIAS_ID,
+  // Frontend dev-assets MCP ID
+  DEV_ASSETS_MCP_ALIAS_ID,
   // Org-scoped MCP ID generators
   WellKnownOrgMCPId,
   // Connection factory functions
   getWellKnownRegistryConnection,
   getWellKnownCommunityRegistryConnection,
   getWellKnownSelfConnection,
+  getWellKnownDevAssetsConnection,
   getWellKnownOpenRouterConnection,
   getWellKnownMcpStudioConnection,
   // Virtual MCP factory functions
-  getWellKnownDecopilotAgent,
+  getWellKnownDecopilotVirtualMCP,
+  getWellKnownDecopilotConnection,
+  // Decopilot utilities
+  isDecopilot,
+  getDecopilotId,
 } from "./lib/constants";

package/src/lib/bridge-transport.test.ts

@@ -0,0 +1,368 @@
+import { describe, expect, it } from "bun:test";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import type { JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
+import {
+  createBridgeTransportPair,
+  BridgeClientTransport,
+  BridgeServerTransport,
+} from "./bridge-transport";
+
+/** Poll until `condition` returns true, checking every 5ms up to `timeoutMs`. */
+async function waitFor(
+  condition: () => boolean,
+  timeoutMs = 200,
+): Promise<void> {
+  const start = Date.now();
+  while (!condition()) {
+    if (Date.now() - start > timeoutMs) return;
+    await new Promise((resolve) => setTimeout(resolve, 5));
+  }
+}
+
+describe("BridgeTransport", () => {
+  describe("createBridgeTransportPair", () => {
+    it("should create a pair of transports", () => {
+      const { client, server, channel } = createBridgeTransportPair();
+
+      expect(client).toBeInstanceOf(BridgeClientTransport);
+      expect(server).toBeInstanceOf(BridgeServerTransport);
+      expect(channel).toBeDefined();
+    });
+
+    it("should create transports with microtask scheduling", () => {
+      const { client, server } = createBridgeTransportPair();
+      expect(client).toBeDefined();
+      expect(server).toBeDefined();
+    });
+  });
+
+  describe("message delivery", () => {
+    it("should deliver messages in order client->server", async () => {
+      const { client, server } = createBridgeTransportPair();
+
+      const receivedMessages: JSONRPCMessage[] = [];
+
+      await server.start();
+      server.onmessage = (message) => {
+        receivedMessages.push(message);
+      };
+
+      await client.start();
+
+      const msg1: JSONRPCMessage = {
+        jsonrpc: "2.0",
+        id: 1,
+        method: "test",
+        params: { foo: "bar" },
+      };
+      const msg2: JSONRPCMessage = {
+        jsonrpc: "2.0",
+        id: 2,
+        method: "test2",
+        params: { baz: "qux" },
+      };
+
+      await client.send(msg1);
+      await client.send(msg2);
+
+      // Wait for microtask to process (or sync mode processes immediately)
+      await new Promise((resolve) => queueMicrotask(resolve));
+
+      expect(receivedMessages).toHaveLength(2);
+      expect(receivedMessages[0]).toEqual(msg1);
+      expect(receivedMessages[1]).toEqual(msg2);
+    });
+
+    it("should deliver messages in order server->client", async () => {
+      const { client, server } = createBridgeTransportPair();
+
+      const receivedMessages: JSONRPCMessage[] = [];
+
+      await client.start();
+      client.onmessage = (message) => {
+        receivedMessages.push(message);
+      };
+
+      await server.start();
+
+      const msg1: JSONRPCMessage = {
+        jsonrpc: "2.0",
+        id: 1,
+        method: "test",
+        params: { foo: "bar" },
+      };
+      const msg2: JSONRPCMessage = {
+        jsonrpc: "2.0",
+        id: 2,
+        method: "test2",
+        params: { baz: "qux" },
+      };
+
+      await server.send(msg1);
+      await server.send(msg2);
+
+      // Wait for microtask to process (or sync mode processes immediately)
+      await new Promise((resolve) => queueMicrotask(resolve));
+
+      expect(receivedMessages).toHaveLength(2);
+      expect(receivedMessages[0]).toEqual(msg1);
+      expect(receivedMessages[1]).toEqual(msg2);
+    });
+
+    it("should batch multiple messages in a single microtask", async () => {
+      const { client, server } = createBridgeTransportPair();
+
+      const receivedMessages: JSONRPCMessage[] = [];
+      let flushCount = 0;
+
+      await server.start();
+      server.onmessage = (message) => {
+        receivedMessages.push(message);
+        flushCount++;
+      };
+
+      await client.start();
+
+      // Send multiple messages synchronously
+      await client.send({ jsonrpc: "2.0", id: 1, method: "test1" });
+      await client.send({ jsonrpc: "2.0", id: 2, method: "test2" });
+      await client.send({ jsonrpc: "2.0", id: 3, method: "test3" });
+
+      // Wait for microtask to process
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      expect(receivedMessages).toHaveLength(3);
+      // All messages should be delivered in a single flush
+      expect(flushCount).toBeGreaterThanOrEqual(1);
+    });
+  });
+
+  describe("start()", () => {
+    it("should allow starting client transport", async () => {
+      const { client } = createBridgeTransportPair();
+      await expect(client.start()).resolves.toBeUndefined();
+    });
+
+    it("should allow starting server transport", async () => {
+      const { server } = createBridgeTransportPair();
+      await expect(server.start()).resolves.toBeUndefined();
+    });
+
+    it("should throw if started twice", async () => {
+      const { client } = createBridgeTransportPair();
+      await client.start();
+      await expect(client.start()).rejects.toThrow("already started");
+    });
+  });
+
+  describe("close()", () => {
+    it("should close client transport and notify server", async () => {
+      const { client, server } = createBridgeTransportPair();
+
+      await client.start();
+      await server.start();
+
+      let serverClosed = false;
+      server.onclose = () => {
+        serverClosed = true;
+      };
+
+      await client.close();
+
+      expect(serverClosed).toBe(true);
+    });
+
+    it("should close server transport and notify client", async () => {
+      const { client, server } = createBridgeTransportPair();
+
+      await client.start();
+      await server.start();
+
+      let clientClosed = false;
+      client.onclose = () => {
+        clientClosed = true;
+      };
+
+      await server.close();
+
+      expect(clientClosed).toBe(true);
+    });
+
+    it("should prevent sending messages after close", async () => {
+      const { client, server } = createBridgeTransportPair();
+
+      await client.start();
+      await server.start();
+
+      const receivedMessages: JSONRPCMessage[] = [];
+      server.onmessage = (msg) => receivedMessages.push(msg);
+
+      // Send first message and wait for delivery
+      await client.send({ jsonrpc: "2.0", id: 1, method: "test" });
+      await waitFor(() => receivedMessages.length >= 1);
+
+      expect(receivedMessages.length).toBeGreaterThanOrEqual(1);
+      const initialCount = receivedMessages.length;
+
+      // Close client
+      await client.close();
+
+      // Try to send after close (should be silent no-op)
+      await client.send({ jsonrpc: "2.0", id: 2, method: "test2" });
+
+      // Wait a bit to ensure no delivery
+      await new Promise((resolve) => setTimeout(resolve, 50));
+
+      // Should not receive new messages after close
+      expect(receivedMessages.length).toBe(initialCount);
+    });
+
+    it("should fire onclose exactly once", async () => {
+      const { client } = createBridgeTransportPair();
+
+      await client.start();
+
+      let closeCount = 0;
+      client.onclose = () => {
+        closeCount++;
+      };
+
+      await client.close();
+      await client.close(); // Try closing again
+
+      expect(closeCount).toBe(1);
+    });
+  });
+
+  describe("error handling", () => {
+    it("should catch and forward errors from onmessage handler", async () => {
+      const { client, server } = createBridgeTransportPair();
+
+      await server.start();
+      await client.start();
+
+      const errors: Error[] = [];
+      server.onerror = (error) => {
+        errors.push(error);
+      };
+
+      server.onmessage = () => {
+        throw new Error("Test error");
+      };
+
+      await client.send({ jsonrpc: "2.0", id: 1, method: "test" });
+
+      // Wait for microtask to process and error to be forwarded
+      await waitFor(() => errors.length >= 1);
+
+      expect(errors).toHaveLength(1);
+      expect(errors[0].message).toBe("Test error");
+    });
+
+    it("should continue processing messages after error", async () => {
+      const { client, server } = createBridgeTransportPair();
+
+      await server.start();
+      await client.start();
+
+      const receivedMessages: JSONRPCMessage[] = [];
+      const errors: Error[] = [];
+
+      let callCount = 0;
+      server.onmessage = (msg) => {
+        callCount++;
+        if (callCount === 1) {
+          throw new Error("First message error");
+        }
+        receivedMessages.push(msg);
+      };
+
+      server.onerror = (error) => {
+        errors.push(error);
+      };
+
+      await client.send({ jsonrpc: "2.0", id: 1, method: "test1" });
+      await client.send({ jsonrpc: "2.0", id: 2, method: "test2" });
+
+      // Wait for microtask to process
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      expect(errors).toHaveLength(1);
+      expect(receivedMessages).toHaveLength(1);
+      expect(receivedMessages[0].id).toBe(2);
+    });
+  });
+
+  describe("integration with MCP SDK", () => {
+    it("should work with MCP Client and Server", async () => {
+      const { client: clientTransport, server: serverTransport } =
+        createBridgeTransportPair();
+
+      const client = new Client({ name: "test-client", version: "1.0.0" });
+      const server = new Server({ name: "test-server", version: "1.0.0" });
+
+      // Connect server first
+      await server.connect(serverTransport);
+
+      // Connect client
+      await client.connect(clientTransport);
+
+      // Verify connection is established
+      expect(clientTransport.started).toBe(true);
+      expect(serverTransport.started).toBe(true);
+
+      // Clean up
+      await client.close();
+      await server.close();
+    });
+
+    it("should handle initialize handshake", async () => {
+      const { client: clientTransport, server: serverTransport } =
+        createBridgeTransportPair();
+
+      const client = new Client({ name: "test-client", version: "1.0.0" });
+      const server = new Server({ name: "test-server", version: "1.0.0" });
+
+      await server.connect(serverTransport);
+      await client.connect(clientTransport);
+
+      // Wait for initialization
+      await new Promise((resolve) => setTimeout(resolve, 100));
+
+      // Verify connection is established (client should have received initialize response)
+      expect(clientTransport.started).toBe(true);
+      expect(serverTransport.started).toBe(true);
+
+      await client.close();
+      await server.close();
+    });
+  });
+
+  describe("send() before start()", () => {
+    it("should allow sending messages before start (messages may be queued)", async () => {
+      const { client, server } = createBridgeTransportPair();
+
+      // Send message before starting - should not throw
+      await expect(
+        client.send({ jsonrpc: "2.0", id: 1, method: "test1" }),
+      ).resolves.toBeUndefined();
+
+      // Set handler and start
+      const receivedMessages: JSONRPCMessage[] = [];
+      server.onmessage = (msg) => receivedMessages.push(msg);
+      await server.start();
+      await client.start();
+
+      // Send another message after start to verify normal operation
+      await client.send({ jsonrpc: "2.0", id: 2, method: "test2" });
+
+      // Wait for delivery
+      await new Promise((resolve) => setTimeout(resolve, 20));
+
+      // At least the message sent after start should be delivered
+      // (messages sent before start may or may not be delivered depending on timing)
+      expect(receivedMessages.length).toBeGreaterThanOrEqual(1);
+    });
+  });
+});