@copilotkit/runtime 1.4.0-pre-1-4-0.0 → 1.4.0-pre-1-4-0.10

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

@@ -7,6 +7,7 @@ import { LangGraphCloudAgent, LangGraphCloudEndpoint } from "./remote-actions";
 import { CopilotRequestContextProperties } from "../integrations";
 import { Message, MessageType } from "../../graphql/types/converted";
 import { MessageRole } from "../../graphql/types/enums";
+import { CustomEventNames, LangGraphEventTypes } from "../../agents/langgraph/events";
 
 type State = Record<string, any>;
 
@@ -111,7 +112,13 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
   const agentStateValues = agentState.values as State;
   state.messages = agentStateValues.messages;
   const mode = wasInitiatedWithExistingThread && nodeName != "__end__" ? "continue" : "start";
-  state = langGraphDefaultMergeState(state, formatMessages(messages), actions, name);
+  let formattedMessages = [];
+  try {
+    formattedMessages = formatMessages(messages);
+  } catch (e) {
+    logger.error(e, `Error event thrown: ${e.message}`);
+  }
+  state = langGraphDefaultMergeState(state, formattedMessages, actions, name);
 
   if (mode === "continue") {
     await client.threads.updateState(threadId, { values: state, asNode: nodeName });
@@ -133,7 +140,7 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
   let streamingStateExtractor = new StreamingStateExtractor([]);
   let prevNodeName = null;
   let emitIntermediateStateUntilEnd = null;
-  let shouldExit = null;
+  let shouldExit = false;
   let externalRunId = null;
 
   const streamResponse = client.runs.stream(threadId, assistantId, {
@@ -144,163 +151,149 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
   const emit = (message: string) => controller.enqueue(new TextEncoder().encode(message));
 
   let latestStateValues = {};
+  let updatedState = state;
 
-  for await (const chunk of streamResponse) {
-    if (!["events", "values", "error"].includes(chunk.event)) continue;
+  try {
+    for await (const chunk of streamResponse) {
+      if (!["events", "values", "error"].includes(chunk.event)) continue;
 
-    if (chunk.event === "error") {
-      logger.error(chunk, `Error event thrown: ${chunk.data.message}`);
-      throw new Error(`Error event thrown: ${chunk.data.message}`);
-    }
+      if (chunk.event === "error") {
+        logger.error(chunk, `Error event thrown: ${chunk.data.message}`);
+        throw new Error(`Error event thrown: ${chunk.data.message}`);
+      }
 
-    if (chunk.event === "values") {
-      latestStateValues = chunk.data;
-      continue;
-    }
+      if (chunk.event === "values") {
+        latestStateValues = chunk.data;
+        continue;
+      }
 
-    const event = chunk.data;
-    const currentNodeName = event.name;
-    const eventType = event.event;
-    const runId = event.metadata.run_id;
-    externalRunId = runId;
-    const metadata = event.metadata;
-
-    shouldExit = shouldExit != null ? shouldExit : metadata["copilotkit:exit"];
-    const emitIntermediateState = metadata["copilotkit:emit-intermediate-state"];
-    const forceEmitIntermediateState = metadata["copilotkit:force-emit-intermediate-state"];
-    const manuallyEmitMessage = metadata["copilotkit:manually-emit-messages"];
-    const manuallyEmitToolCall = metadata["copilotkit:manually-emit-tool-calls"];
-    // we only want to update the node name under certain conditions
-    // since we don't need any internal node names to be sent to the frontend
-    if (graphInfo["nodes"].some((node) => node.id === currentNodeName)) {
-      nodeName = currentNodeName;
-    }
+      const event = chunk.data;
+      const currentNodeName = event.name;
+      const eventType = event.event;
+      const runId = event.metadata.run_id;
+      externalRunId = runId;
+      const metadata = event.metadata;
+
+      shouldExit =
+        shouldExit ||
+        (eventType === LangGraphEventTypes.OnCustomEvent &&
+          event.name === CustomEventNames.CopilotKitExit);
+
+      const emitIntermediateState = metadata["copilotkit:emit-intermediate-state"];
+      const manuallyEmitIntermediateState =
+        eventType === LangGraphEventTypes.OnCustomEvent &&
+        event.name === CustomEventNames.CopilotKitManuallyEmitIntermediateState;
+
+      // we only want to update the node name under certain conditions
+      // since we don't need any internal node names to be sent to the frontend
+      if (graphInfo["nodes"].some((node) => node.id === currentNodeName)) {
+        nodeName = currentNodeName;
+
+        // only update state from values when entering or exiting a known node
+        if (
+          eventType === LangGraphEventTypes.OnChainStart ||
+          eventType === LangGraphEventTypes.OnChainEnd
+        ) {
+          updatedState = latestStateValues;
+        }
+      }
 
-    if (!nodeName) {
-      continue;
-    }
+      if (!nodeName) {
+        continue;
+      }
 
-    if (forceEmitIntermediateState) {
-      if (eventType === "on_chain_end") {
-        state = event.data.output;
+      if (manuallyEmitIntermediateState) {
+        updatedState = event.data;
         emit(
           getStateSyncEvent({
             threadId,
             runId,
             agentName: agent.name,
             nodeName,
-            state: event.data.output,
+            state: updatedState,
             running: true,
             active: true,
           }),
         );
+        continue;
       }
-      continue;
-    }
 
-    if (manuallyEmitMessage) {
-      if (eventType === "on_chain_end") {
-        state = event.data.output;
-        emit(
-          JSON.stringify({
-            event: "on_copilotkit_emit_message",
-            message: event.data.output,
-            messageId: randomUUID(),
-            role: MessageRole.assistant,
-          }) + "\n",
-        );
+      if (emitIntermediateState && emitIntermediateStateUntilEnd == null) {
+        emitIntermediateStateUntilEnd = nodeName;
       }
-      continue;
-    }
 
-    if (manuallyEmitToolCall) {
-      if (eventType === "on_chain_end") {
-        state = event.data.output;
-        emit(
-          JSON.stringify({
-            event: "on_copilotkit_emit_tool_call",
-            name: event.data.output.name,
-            args: event.data.output.args,
-            id: event.data.output.id,
-          }) + "\n",
-        );
+      if (emitIntermediateState && eventType === LangGraphEventTypes.OnChatModelStart) {
+        // reset the streaming state extractor
+        streamingStateExtractor = new StreamingStateExtractor(emitIntermediateState);
       }
-      continue;
-    }
 
-    if (emitIntermediateState && emitIntermediateStateUntilEnd == null) {
-      emitIntermediateStateUntilEnd = nodeName;
-    }
-
-    if (emitIntermediateState && eventType === "on_chat_model_start") {
-      // reset the streaming state extractor
-      streamingStateExtractor = new StreamingStateExtractor(emitIntermediateState);
-    }
-
-    let updatedState = latestStateValues;
+      if (emitIntermediateState && eventType === LangGraphEventTypes.OnChatModelStream) {
+        streamingStateExtractor.bufferToolCalls(event);
+      }
 
-    if (emitIntermediateState && eventType === "on_chat_model_stream") {
-      streamingStateExtractor.bufferToolCalls(event);
-    }
+      if (emitIntermediateStateUntilEnd !== null) {
+        updatedState = {
+          ...updatedState,
+          ...streamingStateExtractor.extractState(),
+        };
+      }
 
-    if (emitIntermediateStateUntilEnd !== null) {
-      updatedState = {
-        ...updatedState,
-        ...streamingStateExtractor.extractState(),
-      };
-    }
+      if (
+        !emitIntermediateState &&
+        currentNodeName === emitIntermediateStateUntilEnd &&
+        eventType === LangGraphEventTypes.OnChainEnd
+      ) {
+        // stop emitting function call state
+        emitIntermediateStateUntilEnd = null;
+      }
 
-    if (
-      !emitIntermediateState &&
-      currentNodeName === emitIntermediateStateUntilEnd &&
-      eventType === "on_chain_end"
-    ) {
-      // stop emitting function call state
-      emitIntermediateStateUntilEnd = null;
-    }
+      const exitingNode =
+        nodeName === currentNodeName && eventType === LangGraphEventTypes.OnChainEnd;
 
-    const exitingNode = nodeName === currentNodeName && eventType === "on_chain_end";
+      if (
+        JSON.stringify(updatedState) !== JSON.stringify(state) ||
+        prevNodeName != nodeName ||
+        exitingNode
+      ) {
+        state = updatedState;
+        prevNodeName = nodeName;
+        emit(
+          getStateSyncEvent({
+            threadId,
+            runId,
+            agentName: agent.name,
+            nodeName,
+            state,
+            running: true,
+            active: !exitingNode,
+          }),
+        );
+      }
 
-    if (
-      JSON.stringify(updatedState) !== JSON.stringify(state) ||
-      prevNodeName != nodeName ||
-      exitingNode
-    ) {
-      state = updatedState;
-      prevNodeName = nodeName;
-      emit(
-        getStateSyncEvent({
-          threadId,
-          runId,
-          agentName: agent.name,
-          nodeName,
-          state,
-          running: true,
-          active: !exitingNode,
-        }),
-      );
+      emit(JSON.stringify(event) + "\n");
     }
 
-    emit(JSON.stringify(event) + "\n");
+    state = await client.threads.getState(threadId);
+    const isEndNode = state.next.length === 0;
+    nodeName = Object.keys(state.metadata.writes)[0];
+
+    emit(
+      getStateSyncEvent({
+        threadId,
+        runId: externalRunId,
+        agentName: agent.name,
+        nodeName: isEndNode ? "__end__" : nodeName,
+        state: state.values,
+        running: !shouldExit,
+        active: false,
+      }),
+    );
+
+    return Promise.resolve();
+  } catch (e) {
+    // TODO: handle error state here.
+    return Promise.resolve();
   }
-
-  state = await client.threads.getState(threadId);
-  const isEndNode = state.next.length === 0;
-  nodeName = Object.keys(state.metadata.writes)[0];
-
-  emit(
-    getStateSyncEvent({
-      threadId,
-      runId: externalRunId,
-      agentName: agent.name,
-      nodeName: isEndNode ? "__end__" : nodeName,
-      state: state.values,
-      running: !shouldExit,
-      active: false,
-    }),
-  );
-
-  return Promise.resolve();
 }
 
 function getStateSyncEvent({
@@ -329,7 +322,7 @@ function getStateSyncEvent({
 
   return (
     JSON.stringify({
-      event: "on_copilotkit_state_sync",
+      event: LangGraphEventTypes.OnCopilotKitStateSync,
       thread_id: threadId,
       run_id: runId,
       agent_name: agentName,
@@ -361,10 +354,10 @@ class StreamingStateExtractor {
     if (event.data.chunk.tool_call_chunks.length > 0) {
       const chunk = event.data.chunk.tool_call_chunks[0];
 
-      if (chunk.name !== null) {
+      if (chunk.name !== null && chunk.name !== undefined) {
         this.currentToolCall = chunk.name;
         this.toolCallBuffer[this.currentToolCall] = chunk.args;
-      } else if (this.currentToolCall !== null) {
+      } else if (this.currentToolCall !== null && this.currentToolCall !== undefined) {
         this.toolCallBuffer[this.currentToolCall] += chunk.args;
       }
     }
@@ -466,15 +459,14 @@ function langGraphDefaultMergeState(
     } else {
       // Replace the message with the existing one
       for (let i = 0; i < mergedMessages.length; i++) {
-        if (mergedMessages[i].id === message.id) {
-          if ("tool_calls" in message) {
-            if (
-              ("tool_calls" in mergedMessages[i] || "additional_kwargs" in mergedMessages[i]) &&
-              mergedMessages[i].content
-            ) {
-              message.tool_calls = mergedMessages[i]["tool_calls"];
-              message.additional_kwargs = mergedMessages[i].additional_kwargs;
-            }
+        if (mergedMessages[i].id === message.id && message.role === "assistant") {
+          if (
+            ("tool_calls" in mergedMessages[i] || "additional_kwargs" in mergedMessages[i]) &&
+            mergedMessages[i].content
+          ) {
+            // @ts-expect-error -- message did not have a tool call, now it will
+            message.tool_calls = mergedMessages[i]["tool_calls"];
+            message.additional_kwargs = mergedMessages[i].additional_kwargs;
           }
           mergedMessages[i] = message;
         }
@@ -559,28 +551,13 @@ function langGraphDefaultMergeState(
     correctedMessages.push(currentMessage);
   }
 
-  return deepMerge(state, {
+  return {
+    ...state,
     messages: correctedMessages,
     copilotkit: {
       actions,
     },
-  });
-}
-
-function deepMerge(obj1: State, obj2: State) {
-  let result = { ...obj1 };
-  for (let key in obj2) {
-    if (typeof obj2[key] === "object" && !Array.isArray(obj2[key])) {
-      if (obj1[key]) {
-        result[key] = deepMerge(obj1[key], obj2[key]);
-      } else {
-        result[key] = { ...obj2[key] };
-      }
-    } else {
-      result[key] = obj2[key];
-    }
-  }
-  return result;
+  };
 }
 
 function formatMessages(messages: Message[]): LangGraphCloudMessage[] {
@@ -615,7 +592,7 @@ function formatMessages(messages: Message[]): LangGraphCloudMessage[] {
         id: message.id,
         tool_call_id: message.actionExecutionId,
         name: message.actionName,
-        role: MessageRole.assistant,
+        role: MessageRole.tool,
       } satisfies LangGraphCloudResultMessage;
     }
 

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

@@ -18,6 +18,39 @@
  *
  * return copilotKit.streamHttpServerResponse(req, res, serviceAdapter);
  * ```
+ *
+ * ## Example with Azure OpenAI
+ *
+ * ```ts
+ * import { CopilotRuntime, OpenAIAdapter } from "@copilotkit/runtime";
+ * import OpenAI from "openai";
+ *
+ * // The name of your Azure OpenAI Instance.
+ * // https://learn.microsoft.com/en-us/azure/cognitive-services/openai/how-to/create-resource?pivots=web-portal#create-a-resource
+ * const instance = "<your instance name>";
+ *
+ * // Corresponds to your Model deployment within your OpenAI resource, e.g. my-gpt35-16k-deployment
+ * // Navigate to the Azure OpenAI Studio to deploy a model.
+ * const model = "<your model>";
+ *
+ * const apiKey = process.env["AZURE_OPENAI_API_KEY"];
+ * if (!apiKey) {
+ *   throw new Error("The AZURE_OPENAI_API_KEY environment variable is missing or empty.");
+ * }
+ *
+ * const copilotKit = new CopilotRuntime();
+ *
+ * const openai = new OpenAI({
+ *   apiKey,
+ *   baseURL: `https://${instance}.openai.azure.com/openai/deployments/${model}`,
+ *   defaultQuery: { "api-version": "2024-04-01-preview" },
+ *   defaultHeaders: { "api-key": apiKey },
+ * });
+ *
+ * const serviceAdapter = new OpenAIAdapter({ openai });
+ *
+ * return copilotKit.streamHttpServerResponse(req, res, serviceAdapter);
+ * ```
  */
 import OpenAI from "openai";
 import {

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

@@ -1,11 +1,12 @@
-import {
-  ActionExecutionMessage,
-  Message,
-  ResultMessage,
-  TextMessage,
-} from "../../graphql/types/converted";
+import { Message } from "../../graphql/types/converted";
 import { ActionInput } from "../../graphql/inputs/action.input";
-import { ChatCompletionMessageParam, ChatCompletionTool } from "openai/resources";
+import {
+  ChatCompletionMessageParam,
+  ChatCompletionTool,
+  ChatCompletionUserMessageParam,
+  ChatCompletionAssistantMessageParam,
+  ChatCompletionSystemMessageParam,
+} from "openai/resources";
 
 export function limitMessagesToTokenCount(
   messages: any[],
@@ -120,9 +121,12 @@ export function convertActionInputToOpenAITool(action: ActionInput): ChatComplet
 export function convertMessageToOpenAIMessage(message: Message): ChatCompletionMessageParam {
   if (message.isTextMessage()) {
     return {
-      role: message.role,
+      role: message.role as ChatCompletionUserMessageParam["role"],
       content: message.content,
-    };
+    } satisfies
+      | ChatCompletionUserMessageParam
+      | ChatCompletionAssistantMessageParam
+      | ChatCompletionSystemMessageParam;
   } else if (message.isActionExecutionMessage()) {
     return {
       role: "assistant",