@copilotkit/runtime 1.10.6 → 1.50.0-beta.0

package/src/graphql/message-conversion/roundtrip-conversion.test.ts

@@ -0,0 +1,526 @@
+import { describe, test, expect, vi } from "vitest";
+import * as gql from "../types/converted/index";
+import agui from "@copilotkit/shared";
+import { aguiToGQL } from "./agui-to-gql";
+import { gqlToAGUI } from "./gql-to-agui";
+
+// Helper to strip functions for deep equality
+function stripFunctions(obj: any): any {
+  if (typeof obj === "function") return undefined;
+  if (Array.isArray(obj)) return obj.map(stripFunctions);
+  if (obj && typeof obj === "object") {
+    const out: any = {};
+    for (const k in obj) {
+      if (typeof obj[k] !== "function") {
+        out[k] = stripFunctions(obj[k]);
+      }
+    }
+    return out;
+  }
+  return obj;
+}
+
+describe("roundtrip message conversion", () => {
+  test("text message AGUI -> GQL -> AGUI", () => {
+    const aguiMsg: agui.Message = {
+      id: "user-1",
+      role: "user",
+      content: "Hello!",
+    };
+    const gqlMsgs = aguiToGQL(aguiMsg);
+    const aguiMsgs2 = gqlToAGUI(gqlMsgs);
+    expect(stripFunctions(aguiMsgs2[0])).toEqual(stripFunctions(aguiMsg));
+  });
+
+  test("text message GQL -> AGUI -> GQL", () => {
+    const gqlMsg = new gql.TextMessage({
+      id: "assistant-1",
+      content: "Hi!",
+      role: gql.Role.assistant,
+    });
+    const aguiMsgs = gqlToAGUI(gqlMsg);
+    const gqlMsgs2 = aguiToGQL(aguiMsgs);
+    // Should be equivalent in content, id, and role
+    expect(gqlMsgs2[0].id).toBe(gqlMsg.id);
+    expect((gqlMsgs2[0] as any).content).toBe(gqlMsg.content);
+    expect((gqlMsgs2[0] as any).role).toBe(gqlMsg.role);
+  });
+
+  test("tool message AGUI -> GQL -> AGUI", () => {
+    const aguiMsg: agui.Message = {
+      id: "tool-1",
+      role: "tool",
+      content: "Tool result",
+      toolCallId: "tool-call-1",
+      toolName: "testAction",
+    };
+    const gqlMsgs = aguiToGQL(aguiMsg);
+    const aguiMsgs2 = gqlToAGUI(gqlMsgs);
+    expect(stripFunctions(aguiMsgs2[0])).toEqual(stripFunctions(aguiMsg));
+  });
+
+  test("tool message GQL -> AGUI -> GQL", () => {
+    const gqlMsg = new gql.ResultMessage({
+      id: "tool-1",
+      result: "Tool result",
+      actionExecutionId: "tool-call-1",
+      actionName: "testAction",
+    });
+    const aguiMsgs = gqlToAGUI(gqlMsg);
+    const gqlMsgs2 = aguiToGQL(aguiMsgs);
+    expect(gqlMsgs2[0].id).toBe(gqlMsg.id);
+    expect((gqlMsgs2[0] as any).result).toBe(gqlMsg.result);
+    expect((gqlMsgs2[0] as any).actionExecutionId).toBe(gqlMsg.actionExecutionId);
+  });
+
+  test("action execution AGUI -> GQL -> AGUI", () => {
+    const aguiMsg: agui.Message = {
+      id: "assistant-1",
+      role: "assistant",
+      content: "Running action",
+      toolCalls: [
+        {
+          id: "tool-call-1",
+          type: "function",
+          function: {
+            name: "doSomething",
+            arguments: JSON.stringify({ foo: "bar" }),
+          },
+        },
+      ],
+    };
+    const gqlMsgs = aguiToGQL(aguiMsg);
+    const aguiMsgs2 = gqlToAGUI(gqlMsgs);
+    // Should have an assistant message and an action execution message
+    expect(aguiMsgs2[0].role).toBe("assistant");
+    expect(aguiMsgs2[1].role).toBe("assistant");
+    // Only check toolCalls if present
+    if ("toolCalls" in aguiMsgs2[1]) {
+      expect((aguiMsgs2[1] as any).toolCalls[0].function.name).toBe("doSomething");
+    }
+  });
+
+  test("action execution GQL -> AGUI -> GQL", () => {
+    const actionExecMsg = new gql.ActionExecutionMessage({
+      id: "tool-call-1",
+      name: "doSomething",
+      arguments: { foo: "bar" },
+      parentMessageId: "assistant-1",
+    });
+    const aguiMsgs = gqlToAGUI([actionExecMsg]);
+    const gqlMsgs2 = aguiToGQL(aguiMsgs);
+    // The ActionExecutionMessage is at index 1, not index 0
+    expect(gqlMsgs2[1].id).toBe("tool-call-1");
+    // The name should be extracted from the toolCall function name
+    expect((gqlMsgs2[1] as any).name).toBe("doSomething");
+    expect((gqlMsgs2[1] as any).arguments).toEqual({ foo: "bar" });
+  });
+
+  test("agent state GQL -> AGUI -> GQL", () => {
+    const agentStateMsg = new gql.AgentStateMessage({
+      id: "agent-state-1",
+      agentName: "testAgent",
+      state: { status: "running" },
+      role: gql.Role.assistant,
+    });
+    const aguiMsgs = gqlToAGUI([agentStateMsg]);
+    const gqlMsgs2 = aguiToGQL(aguiMsgs);
+    expect(gqlMsgs2[0].id).toBe("agent-state-1");
+    // The agentName should be preserved in the roundtrip
+    expect((gqlMsgs2[0] as any).agentName).toBe("testAgent");
+  });
+
+  test("action execution with render function roundtrip", () => {
+    const mockRender = vi.fn();
+    const aguiMsg: agui.Message = {
+      id: "assistant-1",
+      role: "assistant",
+      content: "Running action",
+      toolCalls: [
+        {
+          id: "tool-call-1",
+          type: "function",
+          function: {
+            name: "doSomething",
+            arguments: JSON.stringify({ foo: "bar" }),
+          },
+        },
+      ],
+      generativeUI: mockRender,
+    };
+    const actions: Record<string, any> = { doSomething: { name: "doSomething" } };
+    const gqlMsgs = aguiToGQL(aguiMsg, actions);
+    const aguiMsgs2 = gqlToAGUI(gqlMsgs, actions);
+    // The render function should be preserved in actions context
+    expect(typeof actions.doSomething.render).toBe("function");
+    // The roundtripped message should have the same tool call
+    if ("toolCalls" in aguiMsgs2[1]) {
+      expect((aguiMsgs2[1] as any).toolCalls[0].function.name).toBe("doSomething");
+    }
+  });
+
+  test("image message GQL -> AGUI -> GQL", () => {
+    const gqlMsg = new gql.ImageMessage({
+      id: "img-1",
+      format: "jpeg",
+      bytes: "somebase64string",
+      role: gql.Role.user,
+    });
+    const aguiMsgs = gqlToAGUI(gqlMsg);
+    const gqlMsgs2 = aguiToGQL(aguiMsgs);
+    expect(gqlMsgs2[0].id).toBe(gqlMsg.id);
+    expect((gqlMsgs2[0] as any).format).toBe(gqlMsg.format);
+    expect((gqlMsgs2[0] as any).bytes).toBe(gqlMsg.bytes);
+    expect((gqlMsgs2[0] as any).role).toBe(gqlMsg.role);
+  });
+
+  test("image message AGUI -> GQL -> AGUI (assistant and user)", () => {
+    // Assistant image message
+    const aguiAssistantImageMsg: agui.Message = {
+      id: "img-assistant-1",
+      role: "assistant",
+      image: {
+        format: "jpeg",
+        bytes: "assistantbase64data",
+      },
+      content: "", // required for type
+    };
+    const gqlAssistantMsgs = aguiToGQL(aguiAssistantImageMsg);
+    const aguiAssistantMsgs2 = gqlToAGUI(gqlAssistantMsgs);
+    expect(aguiAssistantMsgs2[0].id).toBe(aguiAssistantImageMsg.id);
+    expect(aguiAssistantMsgs2[0].role).toBe("assistant");
+    expect((aguiAssistantMsgs2[0] as any).image.format).toBe("jpeg");
+    expect((aguiAssistantMsgs2[0] as any).image.bytes).toBe("assistantbase64data");
+
+    // User image message
+    const aguiUserImageMsg: agui.Message = {
+      id: "img-user-1",
+      role: "user",
+      image: {
+        format: "png",
+        bytes: "userbase64data",
+      },
+      content: "", // required for type
+    };
+    const gqlUserMsgs = aguiToGQL(aguiUserImageMsg);
+    const aguiUserMsgs2 = gqlToAGUI(gqlUserMsgs);
+    expect(aguiUserMsgs2[0].id).toBe(aguiUserImageMsg.id);
+    expect(aguiUserMsgs2[0].role).toBe("user");
+    expect((aguiUserMsgs2[0] as any).image.format).toBe("png");
+    expect((aguiUserMsgs2[0] as any).image.bytes).toBe("userbase64data");
+  });
+
+  test("wild card action roundtrip conversion", () => {
+    const mockRender = vi.fn((props) => `Wildcard rendered: ${props.args.test}`);
+    const aguiMsg: agui.Message = {
+      id: "assistant-wildcard-1",
+      role: "assistant",
+      content: "Running wild card action",
+      toolCalls: [
+        {
+          id: "tool-call-wildcard-1",
+          type: "function",
+          function: {
+            name: "unknownAction",
+            arguments: JSON.stringify({ test: "wildcard-value" }),
+          },
+        },
+      ],
+      generativeUI: mockRender,
+    };
+
+    const actions: Record<string, any> = {
+      "*": { name: "*" },
+    };
+
+    // AGUI -> GQL -> AGUI roundtrip
+    const gqlMsgs = aguiToGQL(aguiMsg, actions);
+    const aguiMsgs2 = gqlToAGUI(gqlMsgs, actions);
+
+    // Verify the wild card action preserved the render function
+    expect(typeof actions["*"].render).toBe("function");
+    expect(actions["*"].render).toBe(mockRender);
+
+    // Verify the roundtripped message structure
+    expect(aguiMsgs2).toHaveLength(2);
+    expect(aguiMsgs2[0].role).toBe("assistant");
+    expect(aguiMsgs2[1].role).toBe("assistant");
+
+    // Check that the tool call is preserved
+    if ("toolCalls" in aguiMsgs2[1]) {
+      expect((aguiMsgs2[1] as any).toolCalls[0].function.name).toBe("unknownAction");
+      expect((aguiMsgs2[1] as any).toolCalls[0].function.arguments).toBe(
+        '{"test":"wildcard-value"}',
+      );
+    }
+  });
+
+  test("wild card action with specific action priority roundtrip", () => {
+    const mockRender = vi.fn((props) => `Specific action rendered: ${props.args.test}`);
+    const aguiMsg: agui.Message = {
+      id: "assistant-priority-1",
+      role: "assistant",
+      content: "Running specific action",
+      toolCalls: [
+        {
+          id: "tool-call-priority-1",
+          type: "function",
+          function: {
+            name: "specificAction",
+            arguments: JSON.stringify({ test: "specific-value" }),
+          },
+        },
+      ],
+      generativeUI: mockRender,
+    };
+
+    const actions: Record<string, any> = {
+      specificAction: { name: "specificAction" },
+      "*": { name: "*" },
+    };
+
+    // AGUI -> GQL -> AGUI roundtrip
+    const gqlMsgs = aguiToGQL(aguiMsg, actions);
+    const aguiMsgs2 = gqlToAGUI(gqlMsgs, actions);
+
+    // Verify the specific action preserved the render function (not wild card)
+    expect(typeof actions.specificAction.render).toBe("function");
+    expect(actions.specificAction.render).toBe(mockRender);
+    expect(actions["*"].render).toBeUndefined();
+
+    // Verify the roundtripped message structure
+    expect(aguiMsgs2).toHaveLength(2);
+    expect(aguiMsgs2[0].role).toBe("assistant");
+    expect(aguiMsgs2[1].role).toBe("assistant");
+
+    // Check that the tool call is preserved
+    if ("toolCalls" in aguiMsgs2[1]) {
+      expect((aguiMsgs2[1] as any).toolCalls[0].function.name).toBe("specificAction");
+      expect((aguiMsgs2[1] as any).toolCalls[0].function.arguments).toBe(
+        '{"test":"specific-value"}',
+      );
+    }
+  });
+
+  test("wild card action GQL -> AGUI -> GQL roundtrip", () => {
+    const actionExecMsg = new gql.ActionExecutionMessage({
+      id: "wildcard-action-1",
+      name: "unknownAction",
+      arguments: { test: "wildcard-gql-value" },
+      parentMessageId: "assistant-1",
+    });
+
+    const actions: Record<string, any> = {
+      "*": {
+        name: "*",
+        render: vi.fn((props) => `GQL wildcard rendered: ${props.args.test}`),
+      },
+    };
+
+    // GQL -> AGUI -> GQL roundtrip
+    const aguiMsgs = gqlToAGUI([actionExecMsg], actions);
+    const gqlMsgs2 = aguiToGQL(aguiMsgs, actions);
+
+    // When converting ActionExecutionMessage to AGUI and back, we get:
+    // 1. A TextMessage (assistant message with toolCalls)
+    // 2. An ActionExecutionMessage (the tool call itself)
+    expect(gqlMsgs2).toHaveLength(2);
+    expect(gqlMsgs2[0].id).toBe("wildcard-action-1");
+    expect((gqlMsgs2[0] as any).role).toBe(gql.Role.assistant);
+    expect(gqlMsgs2[1].id).toBe("wildcard-action-1");
+    expect((gqlMsgs2[1] as any).name).toBe("unknownAction");
+    expect((gqlMsgs2[1] as any).arguments).toEqual({ test: "wildcard-gql-value" });
+  });
+
+  test("roundtrip conversion with result parsing edge cases", () => {
+    // Test with a tool result that contains a JSON string
+    const toolResultMsg: agui.Message = {
+      id: "tool-result-json",
+      role: "tool",
+      content: '{"status": "success", "data": {"value": 42}}',
+      toolCallId: "tool-call-json",
+      toolName: "jsonAction",
+    };
+
+    // Convert AGUI -> GQL -> AGUI
+    const gqlMsgs = aguiToGQL(toolResultMsg);
+    const aguiMsgs = gqlToAGUI(gqlMsgs);
+
+    expect(gqlMsgs).toHaveLength(1);
+    expect(gqlMsgs[0]).toBeInstanceOf(gql.ResultMessage);
+    expect((gqlMsgs[0] as any).result).toBe('{"status": "success", "data": {"value": 42}}');
+
+    expect(aguiMsgs).toHaveLength(1);
+    expect(aguiMsgs[0].role).toBe("tool");
+    expect(aguiMsgs[0].content).toBe('{"status": "success", "data": {"value": 42}}');
+  });
+
+  test("roundtrip conversion with object content in tool results", () => {
+    // Test with a tool result that has object content (edge case)
+    const toolResultMsg: agui.Message = {
+      id: "tool-result-object",
+      role: "tool",
+      content: { status: "success", data: { value: 42 } } as any,
+      toolCallId: "tool-call-object",
+      toolName: "objectAction",
+    };
+
+    // Convert AGUI -> GQL -> AGUI
+    const gqlMsgs = aguiToGQL(toolResultMsg);
+    const aguiMsgs = gqlToAGUI(gqlMsgs);
+
+    expect(gqlMsgs).toHaveLength(1);
+    expect(gqlMsgs[0]).toBeInstanceOf(gql.ResultMessage);
+    expect((gqlMsgs[0] as any).result).toBe('{"status":"success","data":{"value":42}}');
+
+    expect(aguiMsgs).toHaveLength(1);
+    expect(aguiMsgs[0].role).toBe("tool");
+    expect(aguiMsgs[0].content).toBe('{"status":"success","data":{"value":42}}');
+  });
+
+  test("roundtrip conversion with action execution and result parsing", () => {
+    const mockRender = vi.fn((props) => `Rendered: ${JSON.stringify(props.result)}`);
+
+    // Create action execution message
+    const actionExecMsg = new gql.ActionExecutionMessage({
+      id: "action-with-result",
+      name: "testAction",
+      arguments: { input: "test-value" },
+      parentMessageId: "parent-result",
+    });
+
+    // Create result message
+    const resultMsg = new gql.ResultMessage({
+      id: "result-with-json",
+      result: '{"output": "processed", "count": 5}',
+      actionExecutionId: "action-with-result",
+      actionName: "testAction",
+    });
+
+    const actions = {
+      testAction: {
+        name: "testAction",
+        render: mockRender,
+      },
+    };
+
+    // Convert GQL -> AGUI
+    const aguiMsgs = gqlToAGUI([actionExecMsg, resultMsg], actions);
+
+    // The action execution should have a generativeUI function that parses string results
+    expect(aguiMsgs).toHaveLength(2);
+    expect(aguiMsgs[0].role).toBe("assistant");
+    expect("generativeUI" in aguiMsgs[0]).toBe(true);
+    expect(aguiMsgs[1].role).toBe("tool");
+    expect(aguiMsgs[1].content).toBe('{"output": "processed", "count": 5}');
+
+    // Test that the render function receives parsed results
+    if ("generativeUI" in aguiMsgs[0] && aguiMsgs[0].generativeUI) {
+      aguiMsgs[0].generativeUI({ result: '{"parsed": true}' });
+      expect(mockRender).toHaveBeenCalledWith(
+        expect.objectContaining({
+          result: { parsed: true }, // Should be parsed from string
+        }),
+      );
+    }
+
+    // Convert back AGUI -> GQL
+    const gqlMsgs2 = aguiToGQL(aguiMsgs, actions);
+
+    // Should have 3 messages: TextMessage, ActionExecutionMessage, ResultMessage
+    expect(gqlMsgs2).toHaveLength(3);
+    expect(gqlMsgs2[0]).toBeInstanceOf(gql.TextMessage);
+    expect(gqlMsgs2[1]).toBeInstanceOf(gql.ActionExecutionMessage);
+    expect(gqlMsgs2[2]).toBeInstanceOf(gql.ResultMessage);
+
+    // Check that arguments roundtripped correctly
+    expect((gqlMsgs2[1] as any).arguments).toEqual({ input: "test-value" });
+    expect((gqlMsgs2[2] as any).result).toBe('{"output": "processed", "count": 5}');
+  });
+
+  test("roundtrip conversion verifies correct property distribution for regular actions", () => {
+    const mockRender = vi.fn((props) => `Regular action: ${JSON.stringify(props.args)}`);
+
+    const actionExecMsg = new gql.ActionExecutionMessage({
+      id: "regular-action-test",
+      name: "regularAction",
+      arguments: { test: "regular-value" },
+      parentMessageId: "parent-regular",
+    });
+
+    const actions = {
+      regularAction: {
+        name: "regularAction",
+        render: mockRender,
+      },
+    };
+
+    // GQL -> AGUI -> GQL roundtrip
+    const aguiMsgs = gqlToAGUI([actionExecMsg], actions);
+    const gqlMsgs2 = aguiToGQL(aguiMsgs, actions);
+
+    // Verify the roundtrip preserved the action
+    expect(gqlMsgs2).toHaveLength(2);
+    expect(gqlMsgs2[1]).toBeInstanceOf(gql.ActionExecutionMessage);
+    expect((gqlMsgs2[1] as any).name).toBe("regularAction");
+
+    // Test that regular actions do NOT receive the name property in render props
+    if ("generativeUI" in aguiMsgs[0] && aguiMsgs[0].generativeUI) {
+      aguiMsgs[0].generativeUI();
+      expect(mockRender).toHaveBeenCalledWith(
+        expect.objectContaining({
+          args: { test: "regular-value" },
+          // name property should NOT be present for regular actions
+        }),
+      );
+
+      // Verify name property is NOT present
+      const callArgs = mockRender.mock.calls[0][0];
+      expect(callArgs).not.toHaveProperty("name");
+    }
+  });
+
+  test("roundtrip conversion verifies correct property distribution for wildcard actions", () => {
+    const mockRender = vi.fn(
+      (props) => `Wildcard action: ${props.name} with ${JSON.stringify(props.args)}`,
+    );
+
+    const actionExecMsg = new gql.ActionExecutionMessage({
+      id: "wildcard-action-test",
+      name: "unknownAction",
+      arguments: { test: "wildcard-value" },
+      parentMessageId: "parent-wildcard",
+    });
+
+    const actions = {
+      "*": {
+        name: "*",
+        render: mockRender,
+      },
+    };
+
+    // GQL -> AGUI -> GQL roundtrip
+    const aguiMsgs = gqlToAGUI([actionExecMsg], actions);
+    const gqlMsgs2 = aguiToGQL(aguiMsgs, actions);
+
+    // Verify the roundtrip preserved the action
+    expect(gqlMsgs2).toHaveLength(2);
+    expect(gqlMsgs2[1]).toBeInstanceOf(gql.ActionExecutionMessage);
+    expect((gqlMsgs2[1] as any).name).toBe("unknownAction");
+
+    // Test that wildcard actions DO receive the name property in render props
+    if ("generativeUI" in aguiMsgs[0] && aguiMsgs[0].generativeUI) {
+      aguiMsgs[0].generativeUI();
+      expect(mockRender).toHaveBeenCalledWith(
+        expect.objectContaining({
+          args: { test: "wildcard-value" },
+          name: "unknownAction", // name property SHOULD be present for wildcard actions
+        }),
+      );
+
+      // Verify name property IS present
+      const callArgs = mockRender.mock.calls[0][0];
+      expect(callArgs).toHaveProperty("name", "unknownAction");
+    }
+  });
+});

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

@@ -59,6 +59,7 @@ import {
   CopilotKitLowLevelError,
   isStructuredCopilotKitError,
 } from "@copilotkit/shared";
+import { CopilotRuntime } from "../../lib";
 
 const invokeGuardrails = async ({
   baseUrl,
@@ -128,7 +129,7 @@ export class CopilotResolver {
     let logger = ctx.logger.child({ component: "CopilotResolver.availableAgents" });
 
     logger.debug("Processing");
-    const agentsWithEndpoints = await ctx._copilotkit.runtime.discoverAgentsFromEndpoints(ctx);
+    const agentsWithEndpoints = [];
 
     logger.debug("Event source created, creating response");
 
@@ -172,7 +173,7 @@ export class CopilotResolver {
       ctx.properties = { ...ctx.properties, ...properties };
     }
 
-    const copilotRuntime = ctx._copilotkit.runtime;
+    const copilotRuntime = ctx._copilotkit.runtime as unknown as CopilotRuntime;
     const serviceAdapter = ctx._copilotkit.serviceAdapter;
 
     let copilotCloudPublicApiKey: string | null = null;
@@ -192,19 +193,6 @@ export class CopilotResolver {
       if (!copilotCloudPublicApiKey) {
         logger.error("Public API key not found in headers");
 
-        await copilotRuntime.errorGraphQLError(
-          {
-            message: "X-CopilotCloud-Public-API-Key header is required",
-            code: "MISSING_PUBLIC_API_KEY",
-            type: "GraphQLError",
-          },
-          {
-            operation: "generateCopilotResponse",
-            cloudConfigPresent: Boolean(data.cloud),
-            guardrailsEnabled: Boolean(data.cloud?.guardrails),
-          },
-        );
-
         throw new GraphQLError("X-CopilotCloud-Public-API-Key header is required");
       }
 
@@ -239,39 +227,6 @@ export class CopilotResolver {
 
     logger.debug("Processing");
     let runtimeResponse;
-    try {
-      runtimeResponse = await copilotRuntime.processRuntimeRequest({
-        serviceAdapter,
-        messages: data.messages,
-        actions: data.frontend.actions.filter(
-          (action) => action.available !== ActionInputAvailability.disabled,
-        ),
-        threadId: data.threadId,
-        runId: data.runId,
-        publicApiKey: copilotCloudPublicApiKey,
-        outputMessagesPromise,
-        graphqlContext: ctx,
-        forwardedParameters: data.forwardedParameters,
-        agentSession: data.agentSession,
-        agentStates: data.agentStates,
-        url: data.frontend.url,
-        extensions: data.extensions,
-        metaEvents: data.metaEvents,
-        context: data.context,
-      });
-    } catch (error) {
-      // Catch structured CopilotKit errors at the main mutation level and re-throw as GraphQL errors
-      if (isStructuredCopilotKitError(error) || (error as any)?.extensions?.visibility) {
-        throw new GraphQLError(error.message || "Agent error occurred", {
-          extensions: {
-            ...(error as any).extensions,
-            code: (error as any).code || (error as any).extensions?.code || "AGENT_ERROR",
-            originalError: error,
-          },
-        });
-      }
-      throw error; // Re-throw non-CopilotKit errors as-is
-    }
 
     const {
       eventSource,

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

@@ -5,12 +5,13 @@ import { LoadAgentStateResponse } from "../types/load-agent-state-response.type"
 import type { GraphQLContext } from "../../lib/integrations";
 import { LoadAgentStateInput } from "../inputs/load-agent-state.input";
 import { CopilotKitAgentDiscoveryError } from "@copilotkit/shared";
+import { CopilotRuntime } from "../../lib";
 
 @Resolver(() => LoadAgentStateResponse)
 export class StateResolver {
   @Query(() => LoadAgentStateResponse)
   async loadAgentState(@Ctx() ctx: GraphQLContext, @Arg("data") data: LoadAgentStateInput) {
-    const agents = await ctx._copilotkit.runtime.getAllAgents(ctx);
+    const agents = [];
     const hasAgent = agents.some((agent) => agent.name === data.agentName);
     if (!hasAgent) {
       throw new CopilotKitAgentDiscoveryError({
@@ -19,7 +20,7 @@ export class StateResolver {
       });
     }
 
-    const state = await ctx._copilotkit.runtime.loadAgentState(ctx, data.threadId, data.agentName);
+    const state = {};
 
     return state;
   }

package/src/graphql/types/converted/index.ts

@@ -1,3 +1,4 @@
+import { randomId } from "@copilotkit/shared";
 import {
   ActionExecutionMessageInput,
   ResultMessageInput,
@@ -6,7 +7,9 @@ import {
   ImageMessageInput,
 } from "../../inputs/message.input";
 import { BaseMessageInput } from "../base";
+import { BaseMessageOutput } from "../copilot-response.type";
 import { MessageRole } from "../enums";
+import { MessageStatus, MessageStatusCode } from "../message-status.type";
 
 export type MessageType =
   | "TextMessage"
@@ -15,8 +18,18 @@ export type MessageType =
   | "AgentStateMessage"
   | "ImageMessage";
 
-export class Message extends BaseMessageInput {
+export class Message {
   type: MessageType;
+  id: BaseMessageOutput["id"];
+  createdAt: BaseMessageOutput["createdAt"];
+  status: MessageStatus;
+
+  constructor(props: any) {
+    props.id ??= randomId();
+    props.status ??= { code: MessageStatusCode.Success };
+    props.createdAt ??= new Date();
+    Object.assign(this, props);
+  }
 
   isTextMessage(): this is TextMessage {
     return this.type === "TextMessage";
@@ -39,11 +52,24 @@ export class Message extends BaseMessageInput {
   }
 }
 
-export class TextMessage extends Message implements TextMessageInput {
-  type: MessageType = "TextMessage";
-  content: string;
-  role: MessageRole;
-  parentMessageId?: string;
+// alias Role to MessageRole
+export const Role = MessageRole;
+
+// when constructing any message, the base fields are optional
+type MessageConstructorOptions = Partial<Message>;
+
+type TextMessageConstructorOptions = MessageConstructorOptions & TextMessageInput;
+
+export class TextMessage extends Message implements TextMessageConstructorOptions {
+  content: TextMessageInput["content"];
+  parentMessageId: TextMessageInput["parentMessageId"];
+  role: TextMessageInput["role"];
+  type = "TextMessage" as const;
+
+  constructor(props: TextMessageConstructorOptions) {
+    super(props);
+    this.type = "TextMessage";
+  }
 }
 
 export class ActionExecutionMessage