@copilotkit/runtime 1.9.2-next.5 → 1.9.2-next.6

package/dist/lib/integrations/node-http/index.mjs

@@ -1,8 +1,8 @@
 import {
   copilotRuntimeNodeHttpEndpoint
-} from "../../../chunk-ZVJSUAD7.mjs";
-import "../../../chunk-IIXJVVTV.mjs";
+} from "../../../chunk-RCIYK6YJ.mjs";
 import "../../../chunk-5BIEM2UU.mjs";
+import "../../../chunk-IIXJVVTV.mjs";
 import "../../../chunk-SHBDMA63.mjs";
 import "../../../chunk-2OZAGFV3.mjs";
 import "../../../chunk-FHD4JECV.mjs";

package/dist/{shared-ba062831.d.ts → shared-941d59dc.d.ts}

@@ -375,7 +375,9 @@ declare class CopilotRuntime<const T extends Parameter[] | [] = []> {
     constructor(params?: CopilotRuntimeConstructorParams<T>);
     private injectMCPToolInstructions;
     processRuntimeRequest(request: CopilotRuntimeRequest): Promise<CopilotRuntimeResponse>;
+    getAllAgents(graphqlContext: GraphQLContext): Promise<(AgentWithEndpoint | Agent)[]>;
     discoverAgentsFromEndpoints(graphqlContext: GraphQLContext): Promise<AgentWithEndpoint[]>;
+    discoverAgentsFromAgui(): Promise<AgentWithEndpoint[]>;
     loadAgentState(graphqlContext: GraphQLContext, threadId: string, agentName: string): Promise<LoadAgentStateResponse>;
     private processAgentRequest;
     private getServerSideActions;

package/package.json

@@ -9,7 +9,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.9.2-next.5",
+  "version": "1.9.2-next.6",
   "sideEffects": false,
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -66,7 +66,7 @@
     "rxjs": "7.8.1",
     "type-graphql": "2.0.0-rc.1",
     "zod": "^3.23.3",
-    "@copilotkit/shared": "1.9.2-next.5"
+    "@copilotkit/shared": "1.9.2-next.6"
   },
   "peerDependencies": {
     "@ag-ui/client": ">=0.0.28",

package/src/graphql/resolvers/state.resolver.ts

@@ -10,9 +10,9 @@ import { CopilotKitAgentDiscoveryError } from "@copilotkit/shared";
 export class StateResolver {
   @Query(() => LoadAgentStateResponse)
   async loadAgentState(@Ctx() ctx: GraphQLContext, @Arg("data") data: LoadAgentStateInput) {
-    const agents = await ctx._copilotkit.runtime.discoverAgentsFromEndpoints(ctx);
-    const agent = agents.find((agent) => agent.name === data.agentName);
-    if (!agent) {
+    const agents = await ctx._copilotkit.runtime.getAllAgents(ctx);
+    const hasAgent = agents.some((agent) => agent.name === data.agentName);
+    if (!hasAgent) {
       throw new CopilotKitAgentDiscoveryError({
         agentName: data.agentName,
         availableAgents: agents.map((a) => ({ name: a.name, id: a.name })),

package/src/lib/runtime/copilot-runtime.ts

@@ -84,6 +84,7 @@ import {
   convertMCPToolsToActions,
   generateMcpToolInstructions,
 } from "./mcp-tools-utils";
+import { LangGraphAgent } from "./langgraph/langgraph-agent";
 // Define the function type alias here or import if defined elsewhere
 type CreateMCPClientFunction = (config: MCPEndpointConfig) => Promise<MCPClient>;
 // --- MCP Imports ---
@@ -327,7 +328,21 @@ export class CopilotRuntime<const T extends Parameter[] | [] = []> {
       params?.remoteEndpoints.some((e) => e.type === EndpointType.LangGraphPlatform)
     ) {
       console.warn("Actions set in runtime instance will not be available for the agent");
+      console.warn(
+        `LangGraph Platform remote endpoints are deprecated in favor of the "agents" property`,
+      );
     }
+
+    // TODO: finalize
+    // if (
+    //   params?.agents &&
+    //   Object.values(params.agents).some((agent) => {
+    //     return agent instanceof AguiLangGraphAgent && !(agent instanceof LangGraphAgent);
+    //   })
+    // ) {
+    //   console.warn('LangGraph Agent class should be imported from @copilotkit/runtime. ')
+    // }
+
     this.actions = params?.actions || [];
     this.availableAgents = [];
 
@@ -767,6 +782,20 @@ please use an LLM adapter instead.`,
     }
   }
 
+  async getAllAgents(graphqlContext: GraphQLContext): Promise<(AgentWithEndpoint | Agent)[]> {
+    const [agentsWithEndpoints, aguiAgents] = await Promise.all([
+      this.discoverAgentsFromEndpoints(graphqlContext),
+      this.discoverAgentsFromAgui(),
+    ]);
+
+    this.availableAgents = [...agentsWithEndpoints, ...aguiAgents].map((a) => ({
+      name: a.name,
+      id: a.id,
+    }));
+
+    return [...agentsWithEndpoints, ...aguiAgents];
+  }
+
   async discoverAgentsFromEndpoints(graphqlContext: GraphQLContext): Promise<AgentWithEndpoint[]> {
     const agents: Promise<AgentWithEndpoint[]> = this.remoteEndpointDefinitions.reduce(
       async (acc: Promise<Agent[]>, endpoint) => {
@@ -848,7 +877,41 @@ please use an LLM adapter instead.`,
       },
       Promise.resolve([]),
     );
-    this.availableAgents = ((await agents) ?? []).map((a) => ({ name: a.name, id: a.id }));
+
+    return agents;
+  }
+
+  async discoverAgentsFromAgui(): Promise<AgentWithEndpoint[]> {
+    const agents: Promise<AgentWithEndpoint[]> = Object.values(this.agents ?? []).reduce(
+      async (acc: Promise<Agent[]>, agent: LangGraphAgent) => {
+        const agents = await acc;
+
+        const client = agent.client;
+        let data: Array<{ assistant_id: string; graph_id: string }> | { detail: string } = [];
+        try {
+          data = await client.assistants.search();
+
+          if (data && "detail" in data && (data.detail as string).toLowerCase() === "not found") {
+            throw new CopilotKitAgentDiscoveryError({ availableAgents: this.availableAgents });
+          }
+        } catch (e) {
+          throw new CopilotKitMisuseError({
+            message: `
+              Failed to find or contact agent ${agent.graphId}.
+              Make sure the LangGraph API is running and the agent is defined in langgraph.json
+              
+              See more: https://docs.copilotkit.ai/troubleshooting/common-issues`,
+          });
+        }
+        const endpointAgents = data.map((entry) => ({
+          name: entry.graph_id,
+          id: entry.assistant_id,
+          description: "",
+        }));
+        return [...agents, ...endpointAgents];
+      },
+      Promise.resolve([]),
+    );
 
     return agents;
   }
@@ -858,50 +921,18 @@ please use an LLM adapter instead.`,
     threadId: string,
     agentName: string,
   ): Promise<LoadAgentStateResponse> {
-    const agentsWithEndpoints = await this.discoverAgentsFromEndpoints(graphqlContext);
+    const agents = await this.getAllAgents(graphqlContext);
 
-    const agentWithEndpoint = agentsWithEndpoints.find((agent) => agent.name === agentName);
-    if (!agentWithEndpoint) {
+    const agent = agents.find((agent) => agent.name === agentName);
+    if (!agent) {
       throw new Error("Agent not found");
     }
 
-    if (agentWithEndpoint.endpoint.type === EndpointType.LangGraphPlatform) {
-      const propertyHeaders = graphqlContext.properties.authorization
-        ? { authorization: `Bearer ${graphqlContext.properties.authorization}` }
-        : null;
-
-      const client = new LangGraphClient({
-        apiUrl: agentWithEndpoint.endpoint.deploymentUrl,
-        apiKey: agentWithEndpoint.endpoint.langsmithApiKey,
-        defaultHeaders: { ...propertyHeaders },
-      });
-      let state: any = {};
-      try {
-        state = (await client.threads.getState(threadId)).values as any;
-      } catch (error) {}
-
-      if (Object.keys(state).length === 0) {
-        return {
-          threadId: threadId || "",
-          threadExists: false,
-          state: JSON.stringify({}),
-          messages: JSON.stringify([]),
-        };
-      } else {
-        const { messages, ...stateWithoutMessages } = state;
-        const copilotkitMessages = langchainMessagesToCopilotKit(messages);
-        return {
-          threadId: threadId || "",
-          threadExists: true,
-          state: JSON.stringify(stateWithoutMessages),
-          messages: JSON.stringify(copilotkitMessages),
-        };
-      }
-    } else if (
-      agentWithEndpoint.endpoint.type === EndpointType.CopilotKit ||
-      !("type" in agentWithEndpoint.endpoint)
+    if (
+      "endpoint" in agent &&
+      (agent.endpoint.type === EndpointType.CopilotKit || !("type" in agent.endpoint))
     ) {
-      const cpkEndpoint = agentWithEndpoint.endpoint as CopilotKitEndpoint;
+      const cpkEndpoint = agent.endpoint as CopilotKitEndpoint;
       const fetchUrl = `${cpkEndpoint.url}/agents/state`;
       try {
         const response = await fetchWithRetry(fetchUrl, {
@@ -937,9 +968,51 @@ please use an LLM adapter instead.`,
         }
         throw new CopilotKitLowLevelError({ error, url: fetchUrl });
       }
+    }
+
+    const propertyHeaders = graphqlContext.properties.authorization
+      ? { authorization: `Bearer ${graphqlContext.properties.authorization}` }
+      : null;
+
+    let client: LangGraphClient;
+    if ("endpoint" in agent && agent.endpoint.type === EndpointType.LangGraphPlatform) {
+      client = new LangGraphClient({
+        apiUrl: agent.endpoint.deploymentUrl,
+        apiKey: agent.endpoint.langsmithApiKey,
+        defaultHeaders: { ...propertyHeaders },
+      });
+    } else {
+      const aguiAgent = graphqlContext._copilotkit.runtime.agents[agent.name] as LangGraphAgent;
+      if (!aguiAgent) {
+        throw new Error(`Agent: ${agent.name} could not be resolved`);
+      }
+      // @ts-expect-error -- both clients are the same
+      client = aguiAgent.client;
+    }
+    let state: any = {};
+    try {
+      state = (await client.threads.getState(threadId)).values as any;
+    } catch (error) {}
+
+    if (Object.keys(state).length === 0) {
+      return {
+        threadId: threadId || "",
+        threadExists: false,
+        state: JSON.stringify({}),
+        messages: JSON.stringify([]),
+      };
     } else {
-      throw new Error(`Unknown endpoint type: ${(agentWithEndpoint.endpoint as any).type}`);
+      const { messages, ...stateWithoutMessages } = state;
+      const copilotkitMessages = langchainMessagesToCopilotKit(messages);
+      return {
+        threadId: threadId || "",
+        threadExists: true,
+        state: JSON.stringify(stateWithoutMessages),
+        messages: JSON.stringify(copilotkitMessages),
+      };
     }
+
+    throw new Error(`Agent: ${agent.name} could not be resolved`);
   }
 
   private async processAgentRequest(