@copilotkit/runtime 1.5.12-next.6 → 1.5.12

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

@@ -42,7 +42,6 @@ import {
 } from "../types/converted";
 import telemetry from "../../lib/telemetry-client";
 import { randomId } from "@copilotkit/shared";
-import { EndpointType, LangGraphPlatformAgent } from "../../lib/runtime/remote-actions";
 import { AgentsResponse } from "../types/agents-response.type";
 
 const invokeGuardrails = async ({
@@ -113,12 +112,14 @@ export class CopilotResolver {
     let logger = ctx.logger.child({ component: "CopilotResolver.availableAgents" });
 
     logger.debug("Processing");
-    const agents = await ctx._copilotkit.runtime.discoverAgentsFromEndpoints(ctx);
+    const agentsWithEndpoints = await ctx._copilotkit.runtime.discoverAgentsFromEndpoints(ctx);
 
     logger.debug("Event source created, creating response");
 
     return {
-      agents,
+      agents: agentsWithEndpoints.map(
+        ({ endpoint, ...agentWithoutEndpoint }) => agentWithoutEndpoint,
+      ),
     };
   }
 
@@ -192,6 +193,7 @@ export class CopilotResolver {
       runId,
       serverSideActions,
       actionInputsWithoutAgents,
+      extensions,
     } = await copilotRuntime.processRuntimeRequest({
       serviceAdapter,
       messages: data.messages,
@@ -207,6 +209,7 @@ export class CopilotResolver {
       agentSession: data.agentSession,
       agentStates: data.agentStates,
       url: data.frontend.url,
+      extensions: data.extensions,
     });
 
     logger.debug("Event source created, creating response");
@@ -215,6 +218,7 @@ export class CopilotResolver {
       threadId,
       runId,
       status: firstValueFrom(responseStatus$),
+      extensions,
       messages: new Repeater(async (pushMessage, stopStreamingMessages) => {
         logger.debug("Messages repeater created");
 
@@ -281,6 +285,7 @@ export class CopilotResolver {
               (action) =>
                 !serverSideActions.find((serverSideAction) => serverSideAction.name == action.name),
             ),
+            threadId,
           })
           .pipe(
             // shareReplay() ensures that later subscribers will see the whole stream instead of

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

@@ -0,0 +1,23 @@
+import { Arg, Resolver } from "type-graphql";
+import { Ctx } from "type-graphql";
+import { Query } from "type-graphql";
+import { LoadAgentStateResponse } from "../types/load-agent-state-response.type";
+import type { GraphQLContext } from "../../lib/integrations";
+import { LoadAgentStateInput } from "../inputs/load-agent-state.input";
+
+@Resolver(() => LoadAgentStateResponse)
+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) {
+      throw new Error("Agent not found");
+    }
+
+    const state = await ctx._copilotkit.runtime.loadAgentState(ctx, data.threadId, data.agentName);
+
+    return state;
+  }
+}

package/src/graphql/types/agents-response.type.ts

@@ -1,7 +1,4 @@
-import { Field, InterfaceType, ObjectType } from "type-graphql";
-import { MessageRole } from "./enums";
-import { MessageStatusUnion } from "./message-status.type";
-import { ResponseStatusUnion } from "./response-status.type";
+import { Field, ObjectType } from "type-graphql";
 
 @ObjectType()
 export class Agent {

package/src/graphql/types/copilot-response.type.ts

@@ -2,6 +2,7 @@ import { Field, InterfaceType, ObjectType } from "type-graphql";
 import { MessageRole } from "./enums";
 import { MessageStatusUnion } from "./message-status.type";
 import { ResponseStatusUnion } from "./response-status.type";
+import { ExtensionsResponse } from "./extensions-response.type";
 
 @InterfaceType({
   resolveType(value) {
@@ -17,7 +18,7 @@ import { ResponseStatusUnion } from "./response-status.type";
     return undefined;
   },
 })
-abstract class BaseMessageOutput {
+export abstract class BaseMessageOutput {
   @Field(() => String)
   id: string;
 
@@ -110,4 +111,7 @@ export class CopilotResponse {
 
   @Field(() => [BaseMessageOutput])
   messages: (typeof BaseMessageOutput)[];
+
+  @Field(() => ExtensionsResponse, { nullable: true })
+  extensions?: ExtensionsResponse;
 }

package/src/graphql/types/extensions-response.type.ts

@@ -0,0 +1,23 @@
+import { Field, ObjectType } from "type-graphql";
+
+/**
+ * The extensions response is used to receive additional information from the copilot runtime, specific to a
+ * service adapter or agent framework.
+ *
+ * Next time a request to the runtime is made, the extensions response will be included in the request as input.
+ */
+
+@ObjectType()
+export class ExtensionsResponse {
+  @Field(() => OpenAIApiAssistantAPIResponse, { nullable: true })
+  openaiAssistantAPI?: OpenAIApiAssistantAPIResponse;
+}
+
+@ObjectType()
+export class OpenAIApiAssistantAPIResponse {
+  @Field(() => String, { nullable: true })
+  runId?: string;
+
+  @Field(() => String, { nullable: true })
+  threadId?: string;
+}

package/src/graphql/types/load-agent-state-response.type.ts

@@ -0,0 +1,17 @@
+import { Field, ObjectType } from "type-graphql";
+import { BaseMessageOutput } from "./copilot-response.type";
+
+@ObjectType()
+export class LoadAgentStateResponse {
+  @Field(() => String)
+  threadId: string;
+
+  @Field(() => Boolean)
+  threadExists: boolean;
+
+  @Field(() => String)
+  state: string;
+
+  @Field(() => String)
+  messages: string;
+}

package/src/lib/integrations/shared.ts

@@ -8,6 +8,7 @@ import { CopilotCloudOptions } from "../cloud";
 import { LogLevel, createLogger } from "../../lib/logger";
 import { createYoga } from "graphql-yoga";
 import telemetry from "../telemetry-client";
+import { StateResolver } from "../../graphql/resolvers/state.resolver";
 
 const logger = createLogger();
 
@@ -58,7 +59,7 @@ export function buildSchema(
 ) {
   logger.debug("Building GraphQL schema...");
   const schema = buildSchemaSync({
-    resolvers: [CopilotResolver],
+    resolvers: [CopilotResolver, StateResolver],
     emitSchemaFile: options.emitSchemaFile,
   });
   logger.debug("GraphQL schema built successfully");

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

@@ -24,19 +24,20 @@ import {
   CopilotKitAgentDiscoveryError,
   CopilotKitMisuseError,
 } from "@copilotkit/shared";
-import { Client as LangGraphClient } from "@langchain/langgraph-sdk";
 import {
   CopilotServiceAdapter,
   EmptyAdapter,
   RemoteChain,
   RemoteChainParameters,
 } from "../../service-adapters";
+
 import { MessageInput } from "../../graphql/inputs/message.input";
 import { ActionInput } from "../../graphql/inputs/action.input";
 import { RuntimeEventSource } from "../../service-adapters/events";
 import { convertGqlInputToMessages } from "../../service-adapters/conversion";
 import { Message } from "../../graphql/types/converted";
 import { ForwardedParametersInput } from "../../graphql/inputs/forwarded-parameters.input";
+
 import {
   isLangGraphAgentAction,
   LangGraphAgentAction,
@@ -46,6 +47,7 @@ import {
   CopilotKitEndpoint,
   LangGraphPlatformEndpoint,
 } from "./remote-actions";
+
 import { GraphQLContext } from "../integrations/shared";
 import { AgentSessionInput } from "../../graphql/inputs/agent-session.input";
 import { from } from "rxjs";
@@ -53,6 +55,11 @@ import { AgentStateInput } from "../../graphql/inputs/agent-state.input";
 import { ActionInputAvailability } from "../../graphql/types/enums";
 import { createHeaders } from "./remote-action-constructors";
 import { Agent } from "../../graphql/types/agents-response.type";
+import { ExtensionsInput } from "../../graphql/inputs/extensions.input";
+import { ExtensionsResponse } from "../../graphql/types/extensions-response.type";
+import { LoadAgentStateResponse } from "../../graphql/types/load-agent-state-response.type";
+import { Client as LangGraphClient } from "@langchain/langgraph-sdk";
+import { langchainMessagesToCopilotKit } from "./remote-lg-action";
 
 interface CopilotRuntimeRequest {
   serviceAdapter: CopilotServiceAdapter;
@@ -67,6 +74,7 @@ interface CopilotRuntimeRequest {
   graphqlContext: GraphQLContext;
   forwardedParameters?: ForwardedParametersInput;
   url?: string;
+  extensions?: ExtensionsInput;
 }
 
 interface CopilotRuntimeResponse {
@@ -75,6 +83,7 @@ interface CopilotRuntimeResponse {
   eventSource: RuntimeEventSource;
   serverSideActions: Action<any>[];
   actionInputsWithoutAgents: ActionInput[];
+  extensions?: ExtensionsResponse;
 }
 
 type ActionsConfiguration<T extends Parameter[] | [] = []> =
@@ -114,6 +123,8 @@ interface Middleware {
   onAfterRequest?: OnAfterRequestHandler;
 }
 
+type AgentWithEndpoint = Agent & { endpoint: EndpointDefinition };
+
 export interface CopilotRuntimeConstructorParams<T extends Parameter[] | [] = []> {
   /**
    * Middleware to be used by the runtime.
@@ -193,6 +204,7 @@ export class CopilotRuntime<const T extends Parameter[] | [] = []> {
       forwardedParameters,
       agentSession,
       url,
+      extensions,
     } = request;
 
     const eventSource = new RuntimeEventSource();
@@ -243,12 +255,17 @@ please use an LLM adapter instead.`,
         runId,
         eventSource,
         forwardedParameters,
+        extensions,
       });
 
+      // for backwards compatibility, we deal with the case that no threadId is provided
+      // by the frontend, by using the threadId from the response
+      const nonEmptyThreadId = threadId ?? result.threadId;
+
       outputMessagesPromise
         .then((outputMessages) => {
           this.onAfterRequest?.({
-            threadId: result.threadId,
+            threadId: nonEmptyThreadId,
             runId: result.runId,
             inputMessages,
             outputMessages,
@@ -259,7 +276,7 @@ please use an LLM adapter instead.`,
         .catch((_error) => {});
 
       return {
-        threadId: result.threadId,
+        threadId: nonEmptyThreadId,
         runId: result.runId,
         eventSource,
         serverSideActions,
@@ -271,6 +288,7 @@ please use an LLM adapter instead.`,
           //   serverSideActions.find((serverSideAction) => serverSideAction.name == action.name),
           // ),
         ),
+        extensions: result.extensions,
       };
     } catch (error) {
       if (error instanceof CopilotKitError) {
@@ -282,9 +300,7 @@ please use an LLM adapter instead.`,
     }
   }
 
-  async discoverAgentsFromEndpoints(
-    graphqlContext: GraphQLContext,
-  ): Promise<(Agent & { endpoint: EndpointDefinition })[]> {
+  async discoverAgentsFromEndpoints(graphqlContext: GraphQLContext): Promise<AgentWithEndpoint[]> {
     const headers = createHeaders(null, graphqlContext);
     const agents = this.remoteEndpointDefinitions.reduce(
       async (acc: Promise<Agent[]>, endpoint) => {
@@ -331,8 +347,9 @@ please use an LLM adapter instead.`,
           const data: InfoResponse = await response.json();
           const endpointAgents = (data?.agents ?? []).map((agent) => ({
             name: agent.name,
-            description: agent.description ?? "",
+            description: agent.description ?? "" ?? "",
             id: randomId(), // Required by Agent type
+            endpoint,
           }));
           return [...agents, ...endpointAgents];
         } catch (error) {
@@ -348,11 +365,87 @@ please use an LLM adapter instead.`,
     return agents;
   }
 
+  async loadAgentState(
+    graphqlContext: GraphQLContext,
+    threadId: string,
+    agentName: string,
+  ): Promise<LoadAgentStateResponse> {
+    const agentsWithEndpoints = await this.discoverAgentsFromEndpoints(graphqlContext);
+
+    const agentWithEndpoint = agentsWithEndpoints.find((agent) => agent.name === agentName);
+    if (!agentWithEndpoint) {
+      throw new Error("Agent not found");
+    }
+    const headers = createHeaders(null, graphqlContext);
+
+    if (agentWithEndpoint.endpoint.type === EndpointType.LangGraphPlatform) {
+      const client = new LangGraphClient({
+        apiUrl: agentWithEndpoint.endpoint.deploymentUrl,
+        apiKey: agentWithEndpoint.endpoint.langsmithApiKey,
+      });
+      const state = (await client.threads.getState(threadId)).values as any;
+
+      if (Object.keys(state).length === 0) {
+        return {
+          threadId,
+          threadExists: false,
+          state: JSON.stringify({}),
+          messages: JSON.stringify([]),
+        };
+      } else {
+        console.log(state);
+        const { messages, ...stateWithoutMessages } = state;
+        const copilotkitMessages = langchainMessagesToCopilotKit(messages);
+        return {
+          threadId,
+          threadExists: true,
+          state: JSON.stringify(stateWithoutMessages),
+          messages: JSON.stringify(copilotkitMessages),
+        };
+      }
+    } else if (
+      agentWithEndpoint.endpoint.type === EndpointType.CopilotKit ||
+      !("type" in agentWithEndpoint.endpoint)
+    ) {
+      const response = await fetch(
+        `${(agentWithEndpoint.endpoint as CopilotKitEndpoint).url}/agents/state`,
+        {
+          method: "POST",
+          headers,
+          body: JSON.stringify({
+            properties: graphqlContext.properties,
+            threadId,
+            name: agentName,
+          }),
+        },
+      );
+      const data: LoadAgentStateResponse = await response.json();
+
+      return {
+        ...data,
+        state: JSON.stringify(data.state),
+        messages: JSON.stringify(data.messages),
+      };
+    } else {
+      throw new Error(`Unknown endpoint type: ${(agentWithEndpoint.endpoint as any).type}`);
+    }
+  }
+
   private async processAgentRequest(
     request: CopilotRuntimeRequest,
   ): Promise<CopilotRuntimeResponse> {
-    const { messages: rawMessages, outputMessagesPromise, graphqlContext, agentSession } = request;
-    const { threadId, agentName, nodeName } = agentSession;
+    const {
+      messages: rawMessages,
+      outputMessagesPromise,
+      graphqlContext,
+      agentSession,
+      threadId: threadIdFromRequest,
+    } = request;
+    const { agentName, nodeName } = agentSession;
+
+    // for backwards compatibility, deal with the case when no threadId is provided
+    const threadId = threadIdFromRequest ?? agentSession.threadId;
+
     const serverSideActions = await this.getServerSideActions(request);
 
     const messages = convertGqlInputToMessages(rawMessages);

package/src/lib/runtime/remote-lg-action.ts

@@ -1,5 +1,6 @@
 import { Client } from "@langchain/langgraph-sdk";
-import { createHash, randomUUID } from "node:crypto";
+import { createHash } from "node:crypto";
+import { randomUUID, isValidUUID } from "@copilotkit/shared";
 import { parse as parsePartialJson } from "partial-json";
 import { Logger } from "pino";
 import { ActionInput } from "../../graphql/inputs/action.input";
@@ -76,7 +77,7 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
   const {
     deploymentUrl,
     langsmithApiKey,
-    threadId: agrsInitialThreadId,
+    threadId: argsInitialThreadId,
     agent,
     nodeName: initialNodeName,
     state: initialState,
@@ -90,26 +91,37 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
   const { name, assistantId: initialAssistantId } = agent;
 
   const client = new Client({ apiUrl: deploymentUrl, apiKey: langsmithApiKey });
-  let initialThreadId = agrsInitialThreadId;
-  const wasInitiatedWithExistingThread = !!initialThreadId;
-  if (initialThreadId && initialThreadId.startsWith("ck-")) {
-    initialThreadId = initialThreadId.substring(3);
+
+  let threadId = argsInitialThreadId ?? randomUUID();
+  if (argsInitialThreadId && argsInitialThreadId.startsWith("ck-")) {
+    threadId = argsInitialThreadId.substring(3);
+  }
+
+  if (!isValidUUID(threadId)) {
+    console.warn(
+      `Cannot use the threadId ${threadId} with LangGraph Platform. Must be a valid UUID.`,
+    );
   }
 
-  const threadId = initialThreadId ?? randomUUID();
-  if (initialThreadId === threadId) {
+  let wasInitiatedWithExistingThread = true;
+  try {
     await client.threads.get(threadId);
-  } else {
-    await client.threads.create({ threadId: threadId });
+  } catch (error) {
+    wasInitiatedWithExistingThread = false;
+    await client.threads.create({ threadId });
   }
 
   let agentState = { values: {} };
   if (wasInitiatedWithExistingThread) {
     agentState = await client.threads.getState(threadId);
   }
+
   const agentStateValues = agentState.values as State;
   state.messages = agentStateValues.messages;
-  const mode = wasInitiatedWithExistingThread && nodeName != "__end__" ? "continue" : "start";
+  const mode =
+    threadId && nodeName != "__end__" && nodeName != undefined && nodeName != null
+      ? "continue"
+      : "start";
   let formattedMessages = [];
   try {
     formattedMessages = copilotkitMessagesToLangChain(messages);
@@ -483,7 +495,7 @@ function langGraphDefaultMergeState(
   };
 }
 
-function langchainMessagesToCopilotKit(messages: any[]): any[] {
+export function langchainMessagesToCopilotKit(messages: any[]): any[] {
   const result: any[] = [];
   const tool_call_names: Record<string, string> = {};
 

package/src/service-adapters/anthropic/anthropic-adapter.ts

@@ -29,8 +29,7 @@ import {
   limitMessagesToTokenCount,
 } from "./utils";
 
-import { randomId } from "@copilotkit/shared";
-import { TextMessage } from "../../graphql/types/converted";
+import { randomId, randomUUID } from "@copilotkit/shared";
 
 const DEFAULT_MODEL = "claude-3-sonnet-20240229";
 
@@ -162,7 +161,7 @@ export class AnthropicAdapter implements CopilotServiceAdapter {
     });
 
     return {
-      threadId: threadId || randomId(),
+      threadId: threadId || randomUUID(),
     };
   }
 }

package/src/service-adapters/empty/empty-adapter.ts

@@ -20,14 +20,14 @@ import {
   CopilotRuntimeChatCompletionRequest,
   CopilotRuntimeChatCompletionResponse,
 } from "../service-adapter";
-import { randomId } from "@copilotkit/shared";
+import { randomUUID } from "@copilotkit/shared";
 
 export class EmptyAdapter implements CopilotServiceAdapter {
   async process(
     request: CopilotRuntimeChatCompletionRequest,
   ): Promise<CopilotRuntimeChatCompletionResponse> {
     return {
-      threadId: request.threadId || randomId(),
+      threadId: request.threadId || randomUUID(),
     };
   }
 }

package/src/service-adapters/events.ts

@@ -226,10 +226,12 @@ export class RuntimeEventSource {
     serverSideActions,
     guardrailsResult$,
     actionInputsWithoutAgents,
+    threadId,
   }: {
     serverSideActions: Action<any>[];
     guardrailsResult$?: Subject<GuardrailsResult>;
     actionInputsWithoutAgents: ActionInput[];
+    threadId: string;
   }) {
     this.callback(this.eventStream$).catch((error) => {
       console.error("Error in event source callback", error);
@@ -285,6 +287,7 @@ export class RuntimeEventSource {
             eventWithState.actionExecutionParentMessageId,
             eventWithState.actionExecutionId,
             actionInputsWithoutAgents,
+            threadId,
           ).catch((error) => {
             console.error(error);
           });
@@ -313,6 +316,7 @@ async function executeAction(
   actionExecutionParentMessageId: string | null,
   actionExecutionId: string,
   actionInputsWithoutAgents: ActionInput[],
+  threadId: string,
 ) {
   if (guardrailsResult$) {
     const { status } = await firstValueFrom(guardrailsResult$);
@@ -370,6 +374,7 @@ async function executeAction(
 
     const stream = await action.langGraphAgentHandler({
       name: action.name,
+      threadId,
       actionInputsWithoutAgents,
       additionalMessages: [agentExecution, agentExecutionResult],
     });

package/src/service-adapters/experimental/ollama/ollama-adapter.ts

@@ -24,7 +24,7 @@ import {
   CopilotRuntimeChatCompletionResponse,
 } from "../../service-adapter";
 import { Ollama } from "@langchain/community/llms/ollama";
-import { randomId } from "@copilotkit/shared";
+import { randomId, randomUUID } from "@copilotkit/shared";
 
 const DEFAULT_MODEL = "llama3:latest";
 
@@ -73,7 +73,7 @@ export class ExperimentalOllamaAdapter implements CopilotServiceAdapter {
       eventStream$.complete();
     });
     return {
-      threadId: request.threadId || randomId(),
+      threadId: request.threadId || randomUUID(),
     };
   }
 }

package/src/service-adapters/groq/groq-adapter.ts

@@ -25,7 +25,7 @@ import {
   convertMessageToOpenAIMessage,
   limitMessagesToTokenCount,
 } from "../openai/utils";
-import { randomId } from "@copilotkit/shared";
+import { randomUUID } from "@copilotkit/shared";
 
 const DEFAULT_MODEL = "llama3-groq-70b-8192-tool-use-preview";
 
@@ -167,7 +167,7 @@ export class GroqAdapter implements CopilotServiceAdapter {
     });
 
     return {
-      threadId: threadId || randomId(),
+      threadId: request.threadId || randomUUID(),
     };
   }
 }

package/src/service-adapters/langchain/langchain-adapter.ts

@@ -44,7 +44,7 @@ import {
 } from "./utils";
 import { DynamicStructuredTool } from "@langchain/core/tools";
 import { LangChainReturnType } from "./types";
-import { randomId } from "@copilotkit/shared";
+import { randomUUID } from "@copilotkit/shared";
 import { awaitAllCallbacks } from "@langchain/core/callbacks/promises";
 
 interface ChainFnParameters {
@@ -72,8 +72,15 @@ export class LangChainAdapter implements CopilotServiceAdapter {
     request: CopilotRuntimeChatCompletionRequest,
   ): Promise<CopilotRuntimeChatCompletionResponse> {
     try {
-      const { eventSource, model, actions, messages, runId } = request;
-      const threadId = request.threadId ?? randomId();
+      const {
+        eventSource,
+        model,
+        actions,
+        messages,
+        runId,
+        threadId: threadIdFromRequest,
+      } = request;
+      const threadId = threadIdFromRequest ?? randomUUID();
       const result = await this.options.chainFn({
         messages: messages.map(convertMessageToLangChainMessage),
         tools: actions.map(convertActionInputToLangChainTool),

package/src/service-adapters/openai/openai-adapter.ts

@@ -59,7 +59,7 @@ import {
   convertMessageToOpenAIMessage,
   limitMessagesToTokenCount,
 } from "./utils";
-import { randomId } from "@copilotkit/shared";
+import { randomUUID } from "@copilotkit/shared";
 
 const DEFAULT_MODEL = "gpt-4o";
 
@@ -107,7 +107,7 @@ export class OpenAIAdapter implements CopilotServiceAdapter {
     request: CopilotRuntimeChatCompletionRequest,
   ): Promise<CopilotRuntimeChatCompletionResponse> {
     const {
-      threadId,
+      threadId: threadIdFromRequest,
       model = this.model,
       messages,
       actions,
@@ -115,6 +115,7 @@ export class OpenAIAdapter implements CopilotServiceAdapter {
       forwardedParameters,
     } = request;
     const tools = actions.map(convertActionInputToOpenAITool);
+    const threadId = threadIdFromRequest ?? randomUUID();
 
     let openaiMessages = messages.map(convertMessageToOpenAIMessage);
     openaiMessages = limitMessagesToTokenCount(openaiMessages, tools, model);
@@ -204,7 +205,7 @@ export class OpenAIAdapter implements CopilotServiceAdapter {
     });
 
     return {
-      threadId: threadId || randomId(),
+      threadId,
     };
   }
 }