@copilotkit/runtime 1.6.0-next.1 → 1.6.0-next.10

package/src/agents/langgraph/event-source.ts

@@ -20,6 +20,7 @@ interface LangGraphEventWithState {
   lastToolCallId: string | null;
   lastToolCallName: string | null;
   currentContent: string | null;
+  processedToolCallIds: Set<string>;
 }
 
 export class RemoteLangGraphEventSource {
@@ -87,11 +88,20 @@ export class RemoteLangGraphEventSource {
             acc.lastMessageId = this.getCurrentMessageId(event) ?? acc.lastMessageId;
             const toolCallChunks = this.getCurrentToolCallChunks(event) ?? [];
             const responseMetadata = this.getResponseMetadata(event);
+            // Check if a given event is a tool call
+            const toolCallCheck = toolCallChunks && toolCallChunks.length > 0;
+            let isToolCallEnd = responseMetadata?.finish_reason === "tool_calls";
 
             acc.isToolCallStart = toolCallChunks.some((chunk: any) => chunk.name && chunk.id);
             acc.isMessageStart = prevMessageId !== acc.lastMessageId && !acc.isToolCallStart;
-            acc.isToolCall = toolCallChunks && toolCallChunks.length > 0;
-            acc.isToolCallEnd = responseMetadata?.finish_reason === "tool_calls";
+
+            let previousRoundHadToolCall = acc.isToolCall;
+            acc.isToolCall = toolCallCheck;
+            // Previous "acc.isToolCall" was set but now it won't pass the check, it means the tool call just ended.
+            if (previousRoundHadToolCall && !toolCallCheck) {
+              isToolCallEnd = true;
+            }
+            acc.isToolCallEnd = isToolCallEnd;
             acc.isMessageEnd = responseMetadata?.finish_reason === "stop";
             ({ name: acc.lastToolCallName, id: acc.lastToolCallId } = toolCallChunks.find(
               (chunk: any) => chunk.name && chunk.id,
@@ -112,6 +122,7 @@ export class RemoteLangGraphEventSource {
           lastToolCallId: null,
           lastToolCallName: null,
           currentContent: null,
+          processedToolCallIds: new Set<string>(),
         } as LangGraphEventWithState,
       ),
       mergeMap((acc): RuntimeEvent[] => {
@@ -148,9 +159,13 @@ export class RemoteLangGraphEventSource {
 
         // Tool call ended: emit ActionExecutionEnd
         if (
-          responseMetadata?.finish_reason === "tool_calls" &&
-          this.shouldEmitToolCall(shouldEmitToolCalls, acc.lastToolCallName)
+          acc.isToolCallEnd &&
+          this.shouldEmitToolCall(shouldEmitToolCalls, acc.lastToolCallName) &&
+          acc.lastToolCallId &&
+          !acc.processedToolCallIds.has(acc.lastToolCallId)
         ) {
+          acc.processedToolCallIds.add(acc.lastToolCallId);
+
           events.push({
             type: RuntimeEventTypes.ActionExecutionEnd,
             actionExecutionId: acc.lastToolCallId,
@@ -158,7 +173,7 @@ export class RemoteLangGraphEventSource {
         }
 
         // Message ended: emit TextMessageEnd
-        if (responseMetadata?.finish_reason === "stop" && shouldEmitMessages) {
+        else if (responseMetadata?.finish_reason === "stop" && shouldEmitMessages) {
           events.push({
             type: RuntimeEventTypes.TextMessageEnd,
             messageId: acc.lastMessageId,
@@ -236,6 +251,7 @@ export class RemoteLangGraphEventSource {
             }
             // Message started: emit TextMessageStart
             else if (acc.isMessageStart && shouldEmitMessages) {
+              acc.processedToolCallIds.clear();
               events.push({
                 type: RuntimeEventTypes.TextMessageStart,
                 messageId: acc.lastMessageId,

package/src/graphql/types/enums.ts

@@ -5,6 +5,7 @@ export enum MessageRole {
   assistant = "assistant",
   system = "system",
   tool = "tool",
+  developer = "developer",
 }
 
 export enum CopilotRequestType {

package/src/lib/runtime/__tests__/remote-action-constructors.test.ts

@@ -0,0 +1,236 @@
+import { TextEncoder } from "util";
+import { RemoteLangGraphEventSource } from "../../../agents/langgraph/event-source";
+import telemetry from "../../telemetry-client";
+import {
+  constructLGCRemoteAction,
+  constructRemoteActions,
+  createHeaders,
+} from "../remote-action-constructors";
+import { execute } from "../remote-lg-action";
+
+// Mock external dependencies
+jest.mock("../remote-lg-action", () => ({
+  execute: jest.fn(),
+}));
+
+jest.mock("../../telemetry-client", () => ({
+  capture: jest.fn(),
+}));
+
+jest.mock("../../../agents/langgraph/event-source", () => ({
+  RemoteLangGraphEventSource: jest.fn(),
+}));
+
+// Dummy logger
+const logger = {
+  debug: jest.fn(),
+  error: jest.fn(),
+  child: jest.fn(() => logger),
+};
+
+// Dummy graphqlContext
+const graphqlContext = { properties: { dummyProp: "value" } } as any;
+
+// Dummy agent state
+const agentStates = [{ agentName: "agent1", state: "{}", configurable: "{}" }];
+
+// Dummy agent used in constructLGCRemoteAction
+const dummyAgent = { name: "agent1", description: "test agent" };
+const endpoint = {
+  agents: [dummyAgent],
+  deploymentUrl: "http://dummy.deployment",
+  langsmithApiKey: "dummykey",
+};
+
+// Clear mocks before each test
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+describe("remote action constructors", () => {
+  describe("constructLGCRemoteAction", () => {
+    it("should create an agent with langGraphAgentHandler that processes events", async () => {
+      // Arrange: simulate execute returning a dummy ReadableStream
+      const dummyEncodedEvent = new TextEncoder().encode(JSON.stringify({ event: "test" }) + "\n");
+      const readerMock = {
+        read: jest
+          .fn()
+          .mockResolvedValueOnce({ done: false, value: dummyEncodedEvent })
+          .mockResolvedValueOnce({ done: true, value: new Uint8Array() }),
+      };
+
+      const dummyResponse = {
+        getReader: () => readerMock,
+      };
+
+      (execute as jest.Mock).mockResolvedValue(dummyResponse);
+
+      // Mock RemoteLangGraphEventSource to return a dummy processed result
+      const processLangGraphEventsMock = jest.fn(() => "processed events");
+      (RemoteLangGraphEventSource as jest.Mock).mockImplementation(() => ({
+        eventStream$: { next: jest.fn(), complete: jest.fn(), error: jest.fn() },
+        processLangGraphEvents: processLangGraphEventsMock,
+      }));
+
+      // Act: build the action and call langGraphAgentHandler
+      const actions = constructLGCRemoteAction({
+        endpoint,
+        graphqlContext,
+        logger,
+        messages: [],
+        agentStates,
+      });
+      expect(actions).toHaveLength(1);
+      const action = actions[0];
+      expect(action.name).toEqual(dummyAgent.name);
+
+      const result = await action.langGraphAgentHandler({
+        name: dummyAgent.name,
+        actionInputsWithoutAgents: [],
+        threadId: "thread1",
+        nodeName: "node1",
+        additionalMessages: [],
+        metaEvents: [],
+      });
+
+      // Assert: processLangGraphEvents is called and result returned
+      expect(processLangGraphEventsMock).toHaveBeenCalled();
+      expect(result).toBe("processed events");
+
+      // Check telemetry.capture was called with agentExecution true
+      expect(telemetry.capture).toHaveBeenCalledWith(
+        "oss.runtime.remote_action_executed",
+        expect.objectContaining({
+          agentExecution: true,
+          type: "langgraph-platform",
+          agentsAmount: 1,
+        }),
+      );
+    });
+  });
+
+  describe("constructRemoteActions", () => {
+    const json = {
+      agents: [{ name: "agent2", description: "agent desc" }],
+      actions: [
+        {
+          name: "action1",
+          description: "action desc",
+          parameters: { param: "value" },
+        },
+      ],
+    };
+    const url = "http://dummy.api";
+    const onBeforeRequest = jest.fn(() => ({ headers: { Authorization: "Bearer token" } }));
+
+    it("should create remote action handler that calls fetch and returns the result", async () => {
+      // Arrange: mock fetch for action handler
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: true,
+        json: jest.fn().mockResolvedValue({ result: "action result" }),
+      });
+
+      const actionsArray = constructRemoteActions({
+        json,
+        url,
+        onBeforeRequest,
+        graphqlContext,
+        logger,
+        messages: [],
+        agentStates,
+      });
+      // There should be one action (from json.actions) and one agent (from json.agents)
+      expect(actionsArray).toHaveLength(2);
+      const actionHandler = actionsArray[0].handler;
+
+      const result = await actionHandler({ foo: "bar" });
+      expect(result).toEqual("action result");
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        `${url}/actions/execute`,
+        expect.objectContaining({
+          method: "POST",
+          headers: expect.objectContaining({
+            "Content-Type": "application/json",
+            Authorization: "Bearer token",
+          }),
+          body: expect.any(String),
+        }),
+      );
+    });
+
+    it("should create remote agent handler that processes events", async () => {
+      // Arrange: mock fetch for agent handler to return a dummy stream
+      const dummyEncodedAgentEvent = new TextEncoder().encode('{"event":"data"}\n');
+      const agentReaderMock = {
+        read: jest
+          .fn()
+          .mockResolvedValueOnce({ done: false, value: dummyEncodedAgentEvent })
+          .mockResolvedValueOnce({ done: true, value: new Uint8Array() }),
+      };
+      const dummyStreamResponse = {
+        getReader: () => agentReaderMock,
+      };
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: true,
+        text: jest.fn().mockResolvedValue("ok"),
+        body: dummyStreamResponse,
+      });
+
+      const processLangGraphEventsMock = jest.fn(() => "agent events processed");
+      (RemoteLangGraphEventSource as jest.Mock).mockImplementation(() => ({
+        eventStream$: { next: jest.fn(), complete: jest.fn(), error: jest.fn() },
+        processLangGraphEvents: processLangGraphEventsMock,
+      }));
+
+      const actionsArray = constructRemoteActions({
+        json,
+        url,
+        onBeforeRequest,
+        graphqlContext,
+        logger,
+        messages: [],
+        agentStates,
+      });
+      // The remote agent is the second item in the array
+      expect(actionsArray).toHaveLength(2);
+      const remoteAgentHandler = (actionsArray[1] as any).langGraphAgentHandler;
+      const result = await remoteAgentHandler({
+        name: "agent2",
+        actionInputsWithoutAgents: [],
+        threadId: "thread2",
+        nodeName: "node2",
+        additionalMessages: [],
+        metaEvents: [],
+      });
+      expect(processLangGraphEventsMock).toHaveBeenCalled();
+      expect(result).toBe("agent events processed");
+
+      // Check telemetry.capture for agent execution
+      expect(telemetry.capture).toHaveBeenCalledWith(
+        "oss.runtime.remote_action_executed",
+        expect.objectContaining({
+          agentExecution: true,
+          type: "self-hosted",
+          agentsAmount: 1,
+        }),
+      );
+    });
+  });
+
+  describe("createHeaders", () => {
+    it("should merge headers from onBeforeRequest", () => {
+      const onBeforeRequest = jest.fn(() => ({ headers: { "X-Test": "123" } }));
+      const headers = createHeaders(onBeforeRequest, graphqlContext);
+      expect(headers).toEqual({
+        "Content-Type": "application/json",
+        "X-Test": "123",
+      });
+    });
+
+    it("should return only Content-Type if no additional headers", () => {
+      const headers = createHeaders(undefined, graphqlContext);
+      expect(headers).toEqual({ "Content-Type": "application/json" });
+    });
+  });
+});

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

@@ -153,7 +153,7 @@ export interface CopilotRuntimeConstructorParams<T extends Parameter[] | [] = []
   middleware?: Middleware;
 
   /*
-   * A list of server side actions that can be executed.
+   * A list of server side actions that can be executed. Will be ignored when remoteActions are set
    */
   actions?: ActionsConfiguration<T>;
 
@@ -190,7 +190,13 @@ export class CopilotRuntime<const T extends Parameter[] | [] = []> {
   private delegateAgentProcessingToServiceAdapter: boolean;
 
   constructor(params?: CopilotRuntimeConstructorParams<T>) {
-    this.actions = params?.actions || [];
+    // Do not register actions if endpoints are set
+    if (params?.actions && params?.remoteEndpoints) {
+      console.warn("Actions set in runtime instance will be ignored when remote endpoints are set");
+      this.actions = [];
+    } else {
+      this.actions = params?.actions || [];
+    }
 
     for (const chain of params?.langserve || []) {
       const remoteChain = new RemoteChain(chain);
@@ -572,7 +578,7 @@ please use an LLM adapter instead.`,
         threadId,
         runId: undefined,
         eventSource,
-        serverSideActions: [],
+        serverSideActions,
         actionInputsWithoutAgents: allAvailableActions,
       };
     } catch (error) {

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

@@ -18,6 +18,8 @@ import { LangGraphEvent } from "../../agents/langgraph/events";
 import { execute } from "./remote-lg-action";
 import { CopilotKitError, CopilotKitLowLevelError } from "@copilotkit/shared";
 import { CopilotKitApiDiscoveryError, ResolvedCopilotKitError } from "@copilotkit/shared";
+import { parseJson, tryMap } from "@copilotkit/shared";
+import { ActionInput } from "../../graphql/inputs/action.input";
 
 export function constructLGCRemoteAction({
   endpoint,
@@ -59,8 +61,8 @@ export function constructLGCRemoteAction({
       if (agentStates) {
         const jsonState = agentStates.find((state) => state.agentName === name);
         if (jsonState) {
-          state = JSON.parse(jsonState.state);
-          configurable = JSON.parse(jsonState.configurable);
+          state = parseJson(jsonState.state, {});
+          configurable = parseJson(jsonState.configurable, {});
         }
       }
 
@@ -76,10 +78,10 @@ export function constructLGCRemoteAction({
           state,
           configurable,
           properties: graphqlContext.properties,
-          actions: actionInputsWithoutAgents.map((action) => ({
+          actions: tryMap(actionInputsWithoutAgents, (action: ActionInput) => ({
             name: action.name,
             description: action.description,
-            parameters: JSON.parse(action.jsonSchema) as string,
+            parameters: JSON.parse(action.jsonSchema),
           })),
           metaEvents,
         });
@@ -203,8 +205,8 @@ export function constructRemoteActions({
           if (agentStates) {
             const jsonState = agentStates.find((state) => state.agentName === name);
             if (jsonState) {
-              state = JSON.parse(jsonState.state);
-              configurable = JSON.parse(jsonState.configurable);
+              state = parseJson(jsonState.state, {});
+              configurable = parseJson(jsonState.configurable, {});
             }
           }
 
@@ -221,7 +223,7 @@ export function constructRemoteActions({
                 state,
                 configurable,
                 properties: graphqlContext.properties,
-                actions: actionInputsWithoutAgents.map((action) => ({
+                actions: tryMap(actionInputsWithoutAgents, (action: ActionInput) => ({
                   name: action.name,
                   description: action.description,
                   parameters: JSON.parse(action.jsonSchema),

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

@@ -1,4 +1,4 @@
-import { Client as LangGraphClient } from "@langchain/langgraph-sdk";
+import { AssistantGraph, Client as LangGraphClient, GraphSchema } from "@langchain/langgraph-sdk";
 import { createHash } from "node:crypto";
 import { isValidUUID, randomUUID } from "@copilotkit/shared";
 import { parse as parsePartialJson } from "partial-json";
@@ -13,6 +13,7 @@ import telemetry from "../telemetry-client";
 import { MetaEventInput } from "../../graphql/inputs/meta-event.input";
 import { MetaEventName } from "../../graphql/types/meta-events.type";
 import { RunsStreamPayload } from "@langchain/langgraph-sdk/dist/types";
+import { parseJson } from "@copilotkit/shared";
 
 type State = Record<string, any>;
 
@@ -164,12 +165,7 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
   }
   if (lgInterruptMetaEvent?.response) {
     let response = lgInterruptMetaEvent.response;
-    try {
-      payload.command = { resume: JSON.parse(response) };
-      // In case of unparsable string, we keep the event as is
-    } catch (e) {
-      payload.command = { resume: response };
-    }
+    payload.command = { resume: parseJson(response, response) };
   }
 
   if (mode === "continue" && !activeInterruptEvent) {
@@ -208,6 +204,15 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
     await client.assistants.update(assistantId, { config: { configurable } });
   }
   const graphInfo = await client.assistants.getGraph(assistantId);
+  const graphSchema = await client.assistants.getSchemas(assistantId);
+  const schemaKeys = getSchemaKeys(graphSchema);
+
+  // Do not input keys that are not part of the input schema
+  if (payload.input && schemaKeys.input) {
+    payload.input = Object.fromEntries(
+      Object.entries(payload.input).filter(([key]) => schemaKeys.input.includes(key)),
+    );
+  }
 
   let streamingStateExtractor = new StreamingStateExtractor([]);
   let prevNodeName = null;
@@ -334,6 +339,7 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
             state: manuallyEmittedState,
             running: true,
             active: true,
+            schemaKeys,
           }),
         );
         continue;
@@ -384,6 +390,7 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
             state,
             running: true,
             active: !exitingNode,
+            schemaKeys,
           }),
         );
       }
@@ -408,6 +415,7 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
         running: !shouldExit,
         active: false,
         includeMessages: true,
+        schemaKeys,
       }),
     );
 
@@ -431,6 +439,7 @@ function getStateSyncEvent({
   running,
   active,
   includeMessages = false,
+  schemaKeys,
 }: {
   threadId: string;
   runId: string;
@@ -440,6 +449,7 @@ function getStateSyncEvent({
   running: boolean;
   active: boolean;
   includeMessages?: boolean;
+  schemaKeys: { input: string[] | null; output: string[] | null };
 }): string {
   if (!includeMessages) {
     state = Object.keys(state).reduce((acc, key) => {
@@ -455,6 +465,13 @@ function getStateSyncEvent({
     };
   }
 
+  // Do not emit state keys that are not part of the output schema
+  if (schemaKeys.output) {
+    state = Object.fromEntries(
+      Object.entries(state).filter(([key]) => schemaKeys.output.includes(key)),
+    );
+  }
+
   return (
     JSON.stringify({
       event: LangGraphEventTypes.OnCopilotKitStateSync,
@@ -743,3 +760,14 @@ function copilotkitMessagesToLangChain(messages: Message[]): LangGraphPlatformMe
 
   return result;
 }
+
+function getSchemaKeys(graphSchema: GraphSchema) {
+  const CONSTANT_KEYS = ["messages", "copilotkit"];
+  const inputSchema = Object.keys(graphSchema.input_schema.properties);
+  const outputSchema = Object.keys(graphSchema.output_schema.properties);
+
+  return {
+    input: inputSchema && inputSchema.length ? [...inputSchema, ...CONSTANT_KEYS] : null,
+    output: outputSchema && outputSchema.length ? [...outputSchema, ...CONSTANT_KEYS] : null,
+  };
+}

package/src/service-adapters/conversion.ts

@@ -7,58 +7,51 @@ import {
 } from "../graphql/types/converted";
 import { MessageInput } from "../graphql/inputs/message.input";
 import { plainToInstance } from "class-transformer";
+import { tryMap } from "@copilotkit/shared";
 
 export function convertGqlInputToMessages(inputMessages: MessageInput[]): Message[] {
-  const messages: Message[] = [];
-
-  for (const message of inputMessages) {
+  const messages = tryMap(inputMessages, (message) => {
     if (message.textMessage) {
-      messages.push(
-        plainToInstance(TextMessage, {
-          id: message.id,
-          createdAt: message.createdAt,
-          role: message.textMessage.role,
-          content: message.textMessage.content,
-          parentMessageId: message.textMessage.parentMessageId,
-        }),
-      );
+      return plainToInstance(TextMessage, {
+        id: message.id,
+        createdAt: message.createdAt,
+        role: message.textMessage.role,
+        content: message.textMessage.content,
+        parentMessageId: message.textMessage.parentMessageId,
+      });
     } else if (message.actionExecutionMessage) {
-      messages.push(
-        plainToInstance(ActionExecutionMessage, {
-          id: message.id,
-          createdAt: message.createdAt,
-          name: message.actionExecutionMessage.name,
-          arguments: JSON.parse(message.actionExecutionMessage.arguments),
-          parentMessageId: message.actionExecutionMessage.parentMessageId,
-        }),
-      );
+      return plainToInstance(ActionExecutionMessage, {
+        id: message.id,
+        createdAt: message.createdAt,
+        name: message.actionExecutionMessage.name,
+        arguments: JSON.parse(message.actionExecutionMessage.arguments),
+        parentMessageId: message.actionExecutionMessage.parentMessageId,
+      });
     } else if (message.resultMessage) {
-      messages.push(
-        plainToInstance(ResultMessage, {
-          id: message.id,
-          createdAt: message.createdAt,
-          actionExecutionId: message.resultMessage.actionExecutionId,
-          actionName: message.resultMessage.actionName,
-          result: message.resultMessage.result,
-        }),
-      );
+      return plainToInstance(ResultMessage, {
+        id: message.id,
+        createdAt: message.createdAt,
+        actionExecutionId: message.resultMessage.actionExecutionId,
+        actionName: message.resultMessage.actionName,
+        result: message.resultMessage.result,
+      });
     } else if (message.agentStateMessage) {
-      messages.push(
-        plainToInstance(AgentStateMessage, {
-          id: message.id,
-          threadId: message.agentStateMessage.threadId,
-          createdAt: message.createdAt,
-          agentName: message.agentStateMessage.agentName,
-          nodeName: message.agentStateMessage.nodeName,
-          runId: message.agentStateMessage.runId,
-          active: message.agentStateMessage.active,
-          role: message.agentStateMessage.role,
-          state: JSON.parse(message.agentStateMessage.state),
-          running: message.agentStateMessage.running,
-        }),
-      );
+      return plainToInstance(AgentStateMessage, {
+        id: message.id,
+        threadId: message.agentStateMessage.threadId,
+        createdAt: message.createdAt,
+        agentName: message.agentStateMessage.agentName,
+        nodeName: message.agentStateMessage.nodeName,
+        runId: message.agentStateMessage.runId,
+        active: message.agentStateMessage.active,
+        role: message.agentStateMessage.role,
+        state: JSON.parse(message.agentStateMessage.state),
+        running: message.agentStateMessage.running,
+      });
+    } else {
+      return null;
     }
-  }
+  });
 
-  return messages;
+  return messages.filter((m) => m);
 }

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

@@ -15,6 +15,7 @@
  * ```
  */
 import { Groq } from "groq-sdk";
+import type { ChatCompletionMessageParam } from "groq-sdk/resources/chat";
 import {
   CopilotServiceAdapter,
   CopilotRuntimeChatCompletionRequest,
@@ -27,7 +28,7 @@ import {
 } from "../openai/utils";
 import { randomUUID } from "@copilotkit/shared";
 
-const DEFAULT_MODEL = "llama3-groq-70b-8192-tool-use-preview";
+const DEFAULT_MODEL = "llama-3.3-70b-versatile";
 
 export interface GroqAdapterParams {
   /**
@@ -81,7 +82,9 @@ export class GroqAdapter implements CopilotServiceAdapter {
     } = request;
     const tools = actions.map(convertActionInputToOpenAITool);
 
-    let openaiMessages = messages.map(convertMessageToOpenAIMessage);
+    let openaiMessages = messages.map((m) =>
+      convertMessageToOpenAIMessage(m, { keepSystemRole: true }),
+    );
     openaiMessages = limitMessagesToTokenCount(openaiMessages, tools, model);
 
     let toolChoice: any = forwardedParameters?.toolChoice;
@@ -94,7 +97,7 @@ export class GroqAdapter implements CopilotServiceAdapter {
     const stream = await this.groq.chat.completions.create({
       model: model,
       stream: true,
-      messages: openaiMessages,
+      messages: openaiMessages as unknown as ChatCompletionMessageParam[],
       ...(tools.length > 0 && { tools }),
       ...(forwardedParameters?.maxTokens && {
         max_tokens: forwardedParameters.maxTokens,

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

@@ -117,7 +117,7 @@ export class OpenAIAdapter implements CopilotServiceAdapter {
     const tools = actions.map(convertActionInputToOpenAITool);
     const threadId = threadIdFromRequest ?? randomUUID();
 
-    let openaiMessages = messages.map(convertMessageToOpenAIMessage);
+    let openaiMessages = messages.map((m) => convertMessageToOpenAIMessage(m));
     openaiMessages = limitMessagesToTokenCount(openaiMessages, tools, model);
 
     let toolChoice: any = forwardedParameters?.toolChoice;

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

@@ -198,7 +198,7 @@ export class OpenAIAssistantAdapter implements CopilotServiceAdapter {
 
     // get the latest user message
     const userMessage = messages
-      .map(convertMessageToOpenAIMessage)
+      .map((m) => convertMessageToOpenAIMessage(m))
       .map(convertSystemMessageToAssistantAPI)
       .at(-1);