@ag-ui/proto 0.0.27

package/.turbo/turbo-build.log

@@ -0,0 +1,23 @@
+
+
+> @ag-ui/proto@0.0.27 build /Users/mme/Code/ag-ui-protocol/typescript-sdk/packages/proto
+> tsup
+
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.4.0
+CLI Using tsup config: /Users/mme/Code/ag-ui-protocol/typescript-sdk/packages/proto/tsup.config.ts
+CLI Target: es2019
+CLI Cleaning output folder
+ESM Build start
+CJS Build start
+ESM dist/index.mjs     60.80 KB
+ESM dist/index.mjs.map 122.38 KB
+ESM ⚡️ Build success in 14ms
+CJS dist/index.js     62.64 KB
+CJS dist/index.js.map 122.19 KB
+CJS ⚡️ Build success in 15ms
+DTS Build start
+DTS ⚡️ Build success in 1047ms
+DTS dist/index.d.mts 481.00 B
+DTS dist/index.d.ts  481.00 B

package/.turbo/turbo-generate.log

@@ -0,0 +1,5 @@
+
+
+> @ag-ui/proto@0.0.27 generate /Users/mme/Code/ag-ui-protocol/typescript-sdk/packages/proto
+> protoc --plugin=./node_modules/.bin/protoc-gen-ts_proto --ts_proto_out=./src/generated --ts_proto_opt=esModuleInterop=true,outputJsonMethods=false,outputClientImpl=false -I ./src/proto ./src/proto/*.proto
+

package/__tests__/message-events.test.ts

@@ -0,0 +1,268 @@
+import {
+  BaseEvent,
+  EventType,
+  MessagesSnapshotEvent,
+  TextMessageStartEvent,
+  TextMessageContentEvent,
+  TextMessageEndEvent,
+} from "@ag-ui/core";
+import { expect, describe, it } from "@jest/globals";
+import { encode, decode } from "../src/proto";
+import { expectRoundTripEquality } from "./test-utils";
+
+describe("Message Events", () => {
+  describe("TextMessageStartEvent", () => {
+    it("should round-trip encode/decode correctly", () => {
+      const event: TextMessageStartEvent = {
+        type: EventType.TEXT_MESSAGE_START,
+        timestamp: Date.now(),
+        messageId: "msg-1",
+        role: "assistant",
+      };
+
+      expectRoundTripEquality(event);
+    });
+
+    it("should handle missing optional fields", () => {
+      const event: TextMessageStartEvent = {
+        type: EventType.TEXT_MESSAGE_START,
+        messageId: "msg-1",
+        role: "assistant",
+      };
+
+      expectRoundTripEquality(event);
+    });
+  });
+
+  describe("TextMessageContentEvent", () => {
+    it("should round-trip encode/decode correctly", () => {
+      const event: TextMessageContentEvent = {
+        type: EventType.TEXT_MESSAGE_CONTENT,
+        timestamp: Date.now(),
+        messageId: "msg-1",
+        delta: "Hello, how can I help you today?",
+      };
+
+      expectRoundTripEquality(event);
+    });
+
+    it("should handle special characters in content delta", () => {
+      const event: TextMessageContentEvent = {
+        type: EventType.TEXT_MESSAGE_CONTENT,
+        messageId: "msg-1",
+        delta: "Special chars: 🚀 ñ € 😊 \n\t\"'\\`",
+      };
+
+      expectRoundTripEquality(event);
+    });
+  });
+
+  describe("TextMessageEndEvent", () => {
+    it("should round-trip encode/decode correctly", () => {
+      const event: TextMessageEndEvent = {
+        type: EventType.TEXT_MESSAGE_END,
+        timestamp: Date.now(),
+        messageId: "msg-1",
+      };
+
+      expectRoundTripEquality(event);
+    });
+  });
+
+  describe("MessagesSnapshotEvent", () => {
+    it("should round-trip encode/decode with multiple messages", () => {
+      const event: MessagesSnapshotEvent = {
+        type: EventType.MESSAGES_SNAPSHOT,
+        timestamp: Date.now(),
+        messages: [
+          {
+            id: "msg-1",
+            role: "user",
+            content: "Can you help me with my task?",
+          },
+          {
+            id: "msg-2",
+            role: "assistant",
+            content: "I'd be happy to help! What task do you need assistance with?",
+          },
+        ],
+      };
+
+      expectRoundTripEquality(event);
+    });
+
+    it("should handle messages with tool calls", () => {
+      const event: MessagesSnapshotEvent = {
+        type: EventType.MESSAGES_SNAPSHOT,
+        messages: [
+          {
+            id: "msg-1",
+            role: "user",
+            content: "What's the weather in San Francisco?",
+          },
+          {
+            id: "msg-2",
+            role: "assistant",
+            content: "Let me check the weather for you.",
+            toolCalls: [
+              {
+                id: "tool-1",
+                type: "function",
+                function: {
+                  name: "get_weather",
+                  arguments: JSON.stringify({ location: "San Francisco" }),
+                },
+              },
+            ],
+          },
+        ],
+      };
+
+      expectRoundTripEquality(event);
+    });
+
+    it("should handle messages with multiple tool calls and complex arguments", () => {
+      const event: MessagesSnapshotEvent = {
+        type: EventType.MESSAGES_SNAPSHOT,
+        messages: [
+          {
+            id: "msg-1",
+            role: "assistant",
+            content: undefined, // Changed from null to undefined
+            toolCalls: [
+              {
+                id: "tool-1",
+                type: "function",
+                function: {
+                  name: "analyze_data",
+                  arguments: JSON.stringify({
+                    dataset: "sales_2023",
+                    metrics: ["revenue", "growth", "conversion"],
+                    filters: {
+                      region: "North America",
+                      timeframe: { start: "2023-01-01", end: "2023-12-31" },
+                    },
+                  }),
+                },
+              },
+              {
+                id: "tool-2",
+                type: "function",
+                function: {
+                  name: "generate_report",
+                  arguments: JSON.stringify({
+                    title: "Annual Sales Report",
+                    format: "pdf",
+                    sections: ["summary", "detailed_analysis", "recommendations"],
+                  }),
+                },
+              },
+            ],
+          },
+        ],
+      };
+
+      expectRoundTripEquality(event);
+    });
+
+    it("should handle messages with undefined toolCalls", () => {
+      const event: MessagesSnapshotEvent = {
+        type: EventType.MESSAGES_SNAPSHOT,
+        messages: [
+          {
+            id: "msg-1",
+            role: "user",
+            content: "Hello",
+          },
+          {
+            id: "msg-2",
+            role: "assistant",
+            content: "Hi there!",
+            // No toolCalls field
+          },
+        ],
+      };
+
+      const encoded = encode(event);
+      const decoded = decode(encoded) as MessagesSnapshotEvent;
+
+      // Check messages length
+      expect(decoded.messages).toHaveLength(event.messages.length);
+
+      // Check first message
+      expect(decoded.messages[0].id).toBe(event.messages[0].id);
+      expect(decoded.messages[0].role).toBe(event.messages[0].role);
+      expect(decoded.messages[0].content).toBe(event.messages[0].content);
+      expect((decoded.messages[0] as any).toolCalls).toBeUndefined();
+
+      // Check second message
+      expect(decoded.messages[1].id).toBe(event.messages[1].id);
+      expect(decoded.messages[1].role).toBe(event.messages[1].role);
+      expect(decoded.messages[1].content).toBe(event.messages[1].content);
+      expect((decoded.messages[1] as any).toolCalls).toBeUndefined();
+    });
+
+    it("should handle messages with empty toolCalls array", () => {
+      const event: MessagesSnapshotEvent = {
+        type: EventType.MESSAGES_SNAPSHOT,
+        messages: [
+          {
+            id: "msg-1",
+            role: "assistant",
+            content: "I processed your request.",
+            toolCalls: [], // Explicitly empty array
+          },
+        ],
+      };
+
+      const encoded = encode(event);
+      const decoded = decode(encoded) as MessagesSnapshotEvent;
+
+      // Check that empty toolCalls array is converted to undefined
+      expect(decoded.messages[0].id).toBe(event.messages[0].id);
+      expect(decoded.messages[0].role).toBe(event.messages[0].role);
+      expect(decoded.messages[0].content).toBe(event.messages[0].content);
+      expect((decoded.messages[0] as any).toolCalls).toBeUndefined();
+    });
+
+    // Test for mixed messages (one with empty toolCalls, one with non-empty)
+    it("should correctly handle a mix of messages with empty and non-empty toolCalls", () => {
+      const event: MessagesSnapshotEvent = {
+        type: EventType.MESSAGES_SNAPSHOT,
+        messages: [
+          {
+            id: "msg-1",
+            role: "assistant",
+            content: "First message",
+            toolCalls: [], // Empty array that should be converted to undefined
+          },
+          {
+            id: "msg-2",
+            role: "assistant",
+            content: "Second message",
+            toolCalls: [
+              {
+                id: "tool-1",
+                type: "function",
+                function: {
+                  name: "test_function",
+                  arguments: "{}",
+                },
+              },
+            ],
+          },
+        ],
+      };
+
+      const encoded = encode(event);
+      const decoded = decode(encoded) as MessagesSnapshotEvent;
+
+      // Check first message (empty toolCalls should be undefined)
+      expect((decoded.messages[0] as any).toolCalls).toBeUndefined();
+
+      // Check second message (non-empty toolCalls should be preserved)
+      expect((decoded.messages[1] as any).toolCalls).toBeDefined();
+      expect((decoded.messages[1] as any).toolCalls?.length).toBe(1);
+    });
+  });
+});

package/__tests__/proto.test.ts

@@ -0,0 +1,194 @@
+import { encode, decode } from "../src/proto";
+import {
+  BaseEvent,
+  EventType,
+  StateDeltaEvent,
+  ToolCallStartEvent,
+  MessagesSnapshotEvent,
+} from "@ag-ui/core";
+import { describe, it, expect } from "@jest/globals";
+import * as protoEvents from "../src/generated/events";
+
+describe("Proto", () => {
+  it("should encode events", () => {
+    const event: BaseEvent = {
+      type: EventType.TOOL_CALL_START,
+      timestamp: Date.now(),
+    };
+    const encoded = encode(event);
+    expect(encoded).toBeInstanceOf(Uint8Array);
+  });
+  it("should handle state delta events encoding", () => {
+    const event: StateDeltaEvent = {
+      type: EventType.STATE_DELTA,
+      timestamp: Date.now(),
+      delta: [{ op: "add", path: "/foo", value: "bar" }],
+    };
+    const encoded = encode(event);
+    expect(encoded).toBeInstanceOf(Uint8Array);
+  });
+  // Test for round-trip encoding/decoding
+  it("should correctly round-trip encode/decode an event", () => {
+    const originalEvent: ToolCallStartEvent = {
+      type: EventType.TOOL_CALL_START,
+      toolCallId: "123",
+      toolCallName: "test",
+    };
+    const encoded = encode(originalEvent);
+    const decoded = decode(encoded);
+    expect(decoded.type).toBe(originalEvent.type);
+    expect(decoded.timestamp).toBe(originalEvent.timestamp);
+  });
+  // Test for StateDeltaEvent round-trip
+  it("should correctly round-trip encode/decode a StateDeltaEvent event", () => {
+    const originalEvent: StateDeltaEvent = {
+      type: EventType.STATE_DELTA,
+      timestamp: 1698765432123,
+      delta: [
+        { op: "add", path: "/foo", value: "bar" },
+        { op: "remove", path: "/baz" },
+      ],
+    };
+    const encoded = encode(originalEvent);
+    const decoded = decode(encoded) as StateDeltaEvent;
+
+    expect(decoded.type).toBe(originalEvent.type);
+    expect(decoded.timestamp).toBe(originalEvent.timestamp);
+    expect(decoded.delta).toHaveLength(originalEvent.delta.length);
+    // Check delta operations
+    expect(decoded.delta[0].op).toBe(originalEvent.delta[0].op);
+    expect(decoded.delta[0].path).toBe(originalEvent.delta[0].path);
+    expect(decoded.delta[0].value).toBe(originalEvent.delta[0].value);
+    expect(decoded.delta[1].op).toBe(originalEvent.delta[1].op);
+    expect(decoded.delta[1].path).toBe(originalEvent.delta[1].path);
+  });
+  // Test for complex values
+  it("should correctly handle complex values in StateDeltaEvent events", () => {
+    const complexValue = {
+      nested: {
+        array: [1, 2, 3],
+        object: { key: "value" },
+      },
+      boolean: true,
+      number: 42,
+    };
+    const originalEvent: StateDeltaEvent = {
+      type: EventType.STATE_DELTA,
+      timestamp: 1698765432123,
+      delta: [{ op: "add", path: "/complex", value: complexValue }],
+    };
+    const encoded = encode(originalEvent);
+    const decoded = decode(encoded) as StateDeltaEvent;
+    expect(decoded.delta[0].value).toEqual(complexValue);
+  });
+  it("should correctly encode/decode a MessagesSnapshotEvent event with tool calls", () => {
+    const originalEvent: MessagesSnapshotEvent = {
+      type: EventType.MESSAGES_SNAPSHOT,
+      timestamp: 1698765432123,
+      messages: [
+        {
+          id: "msg-1",
+          role: "user",
+          content: "Hello, can you help me with something?",
+        },
+        {
+          id: "msg-2",
+          role: "assistant",
+          content: "I'll help you analyze that data.",
+          toolCalls: [
+            {
+              id: "tool-call-1",
+              type: "function",
+              function: {
+                name: "analyze_data",
+                arguments: JSON.stringify({
+                  dataset: "sales_q2",
+                  metrics: ["revenue", "growth"],
+                }),
+              },
+            },
+            {
+              id: "tool-call-2",
+              type: "function",
+              function: {
+                name: "generate_chart",
+                arguments: JSON.stringify({
+                  chartType: "bar",
+                  data: "processed_data",
+                }),
+              },
+            },
+          ],
+        },
+      ],
+    };
+
+    const encoded = encode(originalEvent);
+    const decoded = decode(encoded) as MessagesSnapshotEvent;
+
+    // Verify basic event properties
+    expect(decoded.type).toBe(originalEvent.type);
+    expect(decoded.timestamp).toBe(originalEvent.timestamp);
+
+    // Verify messages array
+    expect(decoded.messages).toHaveLength(originalEvent.messages.length);
+
+    // Verify first message (user)
+    expect(decoded.messages[0].id).toBe(originalEvent.messages[0].id);
+    expect(decoded.messages[0].role).toBe(originalEvent.messages[0].role);
+    expect(decoded.messages[0].content).toBe(originalEvent.messages[0].content);
+
+    // Verify second message (assistant with tool calls)
+    expect(decoded.messages[1].id).toBe(originalEvent.messages[1].id);
+    expect(decoded.messages[1].role).toBe(originalEvent.messages[1].role);
+    expect(decoded.messages[1].content).toBe(originalEvent.messages[1].content);
+
+    // Verify tool calls
+    expect((decoded.messages[1] as any).toolCalls).toBeDefined();
+    expect((decoded.messages[1] as any).toolCalls).toHaveLength(
+      (originalEvent.messages[1] as any).toolCalls!.length,
+    );
+
+    // Verify first tool call
+    expect((decoded.messages[1] as any).toolCalls![0].id).toBe(
+      (originalEvent.messages[1] as any).toolCalls![0].id,
+    );
+    expect((decoded.messages[1] as any).toolCalls![0].type).toBe(
+      (originalEvent.messages[1] as any).toolCalls![0].type,
+    );
+    expect((decoded.messages[1] as any).toolCalls![0].function.name).toBe(
+      (originalEvent.messages[1] as any).toolCalls![0].function.name,
+    );
+
+    // Parse and compare JSON arguments
+    const decodedArgs1 = JSON.parse((decoded.messages[1] as any).toolCalls![0].function.arguments);
+    const originalArgs1 = JSON.parse(
+      (originalEvent.messages[1] as any).toolCalls![0].function.arguments,
+    );
+    expect(decodedArgs1).toEqual(originalArgs1);
+
+    // Verify second tool call
+    expect((decoded.messages[1] as any).toolCalls![1].id).toBe(
+      (originalEvent.messages[1] as any).toolCalls![1].id,
+    );
+    expect((decoded.messages[1] as any).toolCalls![1].function.name).toBe(
+      (originalEvent.messages[1] as any).toolCalls![1].function.name,
+    );
+
+    const decodedArgs2 = JSON.parse((decoded.messages[1] as any).toolCalls![1].function.arguments);
+    const originalArgs2 = JSON.parse(
+      (originalEvent.messages[1] as any).toolCalls![1].function.arguments,
+    );
+    expect(decodedArgs2).toEqual(originalArgs2);
+  });
+
+  // Test for the "Invalid event" error case
+  it("should throw an error when decoding an invalid event", () => {
+    // Create an empty Event message without any oneof field set
+    const emptyEvent = protoEvents.Event.create({});
+    const encodedEmpty = protoEvents.Event.encode(emptyEvent).finish();
+
+    // Attempt to decode the empty event should throw an error
+    expect(() => decode(encodedEmpty)).toThrow("Invalid event");
+  });
+});