@ag-ui/proto 0.0.27

package/src/generated/types.ts

@@ -0,0 +1,285 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.7.0
+//   protoc               v5.29.3
+// source: types.proto
+
+/* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+
+export const protobufPackage = "ag_ui";
+
+export interface ToolCall {
+  id: string;
+  type: string;
+  function: ToolCall_Function | undefined;
+}
+
+export interface ToolCall_Function {
+  name: string;
+  arguments: string;
+}
+
+export interface Message {
+  id: string;
+  role: string;
+  content?: string | undefined;
+  name?: string | undefined;
+  toolCalls: ToolCall[];
+  toolCallId?: string | undefined;
+}
+
+function createBaseToolCall(): ToolCall {
+  return { id: "", type: "", function: undefined };
+}
+
+export const ToolCall: MessageFns<ToolCall> = {
+  encode(message: ToolCall, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.id !== "") {
+      writer.uint32(10).string(message.id);
+    }
+    if (message.type !== "") {
+      writer.uint32(18).string(message.type);
+    }
+    if (message.function !== undefined) {
+      ToolCall_Function.encode(message.function, writer.uint32(26).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ToolCall {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseToolCall();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.id = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.type = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.function = ToolCall_Function.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  create<I extends Exact<DeepPartial<ToolCall>, I>>(base?: I): ToolCall {
+    return ToolCall.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ToolCall>, I>>(object: I): ToolCall {
+    const message = createBaseToolCall();
+    message.id = object.id ?? "";
+    message.type = object.type ?? "";
+    message.function = (object.function !== undefined && object.function !== null)
+      ? ToolCall_Function.fromPartial(object.function)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseToolCall_Function(): ToolCall_Function {
+  return { name: "", arguments: "" };
+}
+
+export const ToolCall_Function: MessageFns<ToolCall_Function> = {
+  encode(message: ToolCall_Function, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.name !== "") {
+      writer.uint32(10).string(message.name);
+    }
+    if (message.arguments !== "") {
+      writer.uint32(18).string(message.arguments);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ToolCall_Function {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseToolCall_Function();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.name = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.arguments = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  create<I extends Exact<DeepPartial<ToolCall_Function>, I>>(base?: I): ToolCall_Function {
+    return ToolCall_Function.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ToolCall_Function>, I>>(object: I): ToolCall_Function {
+    const message = createBaseToolCall_Function();
+    message.name = object.name ?? "";
+    message.arguments = object.arguments ?? "";
+    return message;
+  },
+};
+
+function createBaseMessage(): Message {
+  return { id: "", role: "", content: undefined, name: undefined, toolCalls: [], toolCallId: undefined };
+}
+
+export const Message: MessageFns<Message> = {
+  encode(message: Message, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.id !== "") {
+      writer.uint32(10).string(message.id);
+    }
+    if (message.role !== "") {
+      writer.uint32(18).string(message.role);
+    }
+    if (message.content !== undefined) {
+      writer.uint32(26).string(message.content);
+    }
+    if (message.name !== undefined) {
+      writer.uint32(34).string(message.name);
+    }
+    for (const v of message.toolCalls) {
+      ToolCall.encode(v!, writer.uint32(42).fork()).join();
+    }
+    if (message.toolCallId !== undefined) {
+      writer.uint32(50).string(message.toolCallId);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Message {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMessage();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.id = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.role = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.content = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+
+          message.name = reader.string();
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+
+          message.toolCalls.push(ToolCall.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+
+          message.toolCallId = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  create<I extends Exact<DeepPartial<Message>, I>>(base?: I): Message {
+    return Message.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<Message>, I>>(object: I): Message {
+    const message = createBaseMessage();
+    message.id = object.id ?? "";
+    message.role = object.role ?? "";
+    message.content = object.content ?? undefined;
+    message.name = object.name ?? undefined;
+    message.toolCalls = object.toolCalls?.map((e) => ToolCall.fromPartial(e)) || [];
+    message.toolCallId = object.toolCallId ?? undefined;
+    return message;
+  },
+};
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+export interface MessageFns<T> {
+  encode(message: T, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): T;
+  create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+  fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export { encode, decode } from "./proto";
+
+export const AGUI_MEDIA_TYPE = "application/vnd.ag-ui.event+proto";

package/src/proto/events.proto

@@ -0,0 +1,143 @@
+syntax = "proto3";
+
+package ag_ui;
+
+import "google/protobuf/struct.proto";
+import "patch.proto";
+import "types.proto";
+
+enum EventType {
+  TEXT_MESSAGE_START = 0;
+  TEXT_MESSAGE_CONTENT = 1;
+  TEXT_MESSAGE_END = 2;
+  TOOL_CALL_START = 3;
+  TOOL_CALL_ARGS = 4;
+  TOOL_CALL_END = 5;
+  STATE_SNAPSHOT = 6;
+  STATE_DELTA = 7;
+  MESSAGES_SNAPSHOT = 8;
+  RAW = 9;
+  CUSTOM = 10;
+  RUN_STARTED = 11;
+  RUN_FINISHED = 12;
+  RUN_ERROR = 13;
+  STEP_STARTED = 14;
+  STEP_FINISHED = 15;
+}
+
+message BaseEvent {
+  EventType type = 1;
+  optional int64 timestamp = 2;
+  optional google.protobuf.Value raw_event = 3;
+}
+
+message TextMessageStartEvent {
+  BaseEvent base_event = 1;
+  string message_id = 2;
+  optional string role = 3;
+}
+
+message TextMessageContentEvent {
+  BaseEvent base_event = 1;
+  string message_id = 2;
+  string delta = 3;
+}
+
+message TextMessageEndEvent {
+  BaseEvent base_event = 1;
+  string message_id = 2;
+}
+
+message ToolCallStartEvent {
+  BaseEvent base_event = 1;
+  string tool_call_id = 2;
+  string tool_call_name = 3;
+  optional string parent_message_id = 4;
+}
+
+message ToolCallArgsEvent {
+  BaseEvent base_event = 1;
+  string tool_call_id = 2;
+  string delta = 3;
+}
+
+message ToolCallEndEvent {
+  BaseEvent base_event = 1;
+  string tool_call_id = 2;
+}
+
+message StateSnapshotEvent {
+  BaseEvent base_event = 1;
+  google.protobuf.Value snapshot = 2;
+}
+
+message StateDeltaEvent {
+  BaseEvent base_event = 1;
+  repeated JsonPatchOperation delta = 2;
+}
+
+message MessagesSnapshotEvent {
+  BaseEvent base_event = 1;
+  repeated Message messages = 2;
+}
+
+message RawEvent {
+  BaseEvent base_event = 1;
+  google.protobuf.Value event = 2;
+  optional string source = 3;
+}
+
+message CustomEvent {
+  BaseEvent base_event = 1;
+  string name = 2;
+  optional google.protobuf.Value value = 3;
+}
+
+message RunStartedEvent {
+  BaseEvent base_event = 1;
+  string thread_id = 2;
+  string run_id = 3;
+}
+
+message RunFinishedEvent {
+  BaseEvent base_event = 1;
+  string thread_id = 2;
+  string run_id = 3;
+}
+
+message RunErrorEvent {
+  BaseEvent base_event = 1;
+  optional string code = 2;
+  string message = 3;
+}
+
+message StepStartedEvent {
+  BaseEvent base_event = 1;
+  string step_name = 2;
+}
+
+message StepFinishedEvent {
+  BaseEvent base_event = 1;
+  string step_name = 2;
+}
+
+message Event {
+  oneof event {
+    TextMessageStartEvent text_message_start = 1;
+    TextMessageContentEvent text_message_content = 2;
+    TextMessageEndEvent text_message_end = 3;
+    ToolCallStartEvent tool_call_start = 4;
+    ToolCallArgsEvent tool_call_args = 5;
+    ToolCallEndEvent tool_call_end = 6;
+    StateSnapshotEvent state_snapshot = 7;
+    StateDeltaEvent state_delta = 8;
+    MessagesSnapshotEvent messages_snapshot = 9;
+    RawEvent raw = 10;
+    CustomEvent custom = 11;
+    RunStartedEvent run_started = 12;
+    RunFinishedEvent run_finished = 13;
+    RunErrorEvent run_error = 14;
+    StepStartedEvent step_started = 15;
+    StepFinishedEvent step_finished = 16;
+  }
+}

package/src/proto/patch.proto

@@ -0,0 +1,21 @@
+syntax = "proto3";
+
+import "google/protobuf/struct.proto";
+
+package ag_ui;
+
+enum JsonPatchOperationType {
+  ADD = 0;
+  REMOVE = 1;
+  REPLACE = 2;
+  MOVE = 3;
+  COPY = 4;
+  TEST = 5;
+}
+
+message JsonPatchOperation {
+  JsonPatchOperationType op = 1;
+  string path = 2;
+  optional string from = 3;
+  optional google.protobuf.Value value = 4;
+}

package/src/proto/types.proto

@@ -0,0 +1,22 @@
+syntax = "proto3";
+
+package ag_ui;
+
+message ToolCall {
+  string id = 1;
+  string type = 2; 
+  message Function {
+    string name = 1;
+    string arguments = 2; 
+  }  
+  Function function = 3;
+}
+
+message Message {
+  string id = 1;
+  string role = 2;
+  optional string content = 3;
+  optional string name = 4;
+  repeated ToolCall tool_calls = 5;
+  optional string tool_call_id = 6;
+}

package/src/proto.ts

@@ -0,0 +1,91 @@
+import { BaseEvent, EventSchemas, EventType, Message } from "@ag-ui/core";
+import * as protoEvents from "./generated/events";
+import * as protoPatch from "./generated/patch";
+
+function toCamelCase(str: string): string {
+  return str.toLowerCase().replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+
+/**
+ * Encodes an event message to a protocol buffer binary format.
+ */
+export function encode(event: BaseEvent): Uint8Array {
+  const oneofField = toCamelCase(event.type);
+  const { type, timestamp, rawEvent, ...rest } = event as any;
+
+  // since protobuf does not support optional arrays, we need to ensure that the toolCalls array is always present
+  if (type === EventType.MESSAGES_SNAPSHOT) {
+    rest.messages = rest.messages.map((message: Message) => {
+      const untypedMessage = message as any;
+      if (untypedMessage.toolCalls === undefined) {
+        return { ...message, toolCalls: [] };
+      }
+      return message;
+    });
+  }
+
+  // custom mapping for json patch operations
+  if (type === EventType.STATE_DELTA) {
+    rest.delta = rest.delta.map((operation: any) => ({
+      ...operation,
+      op: protoPatch.JsonPatchOperationType[operation.op.toUpperCase()],
+    }));
+  }
+
+  const eventMessage = {
+    [oneofField]: {
+      baseEvent: {
+        type: protoEvents.EventType[event.type],
+        timestamp,
+        rawEvent,
+      },
+      ...rest,
+    },
+  };
+  return protoEvents.Event.encode(eventMessage).finish();
+}
+
+/**
+ * Decodes a protocol buffer binary format to an event message.
+ * The format includes a 4-byte length prefix followed by the message.
+ */
+export function decode(data: Uint8Array): BaseEvent {
+  const event = protoEvents.Event.decode(data);
+  const decoded = Object.values(event).find((value) => value !== undefined);
+  if (!decoded) {
+    throw new Error("Invalid event");
+  }
+  decoded.type = protoEvents.EventType[decoded.baseEvent.type];
+  decoded.timestamp = decoded.baseEvent.timestamp;
+  decoded.rawEvent = decoded.baseEvent.rawEvent;
+
+  // we want tool calls to be optional, so we need to remove them if they are empty
+  if (decoded.type === EventType.MESSAGES_SNAPSHOT) {
+    for (const message of (decoded as any).messages as Message[]) {
+      const untypedMessage = message as any;
+      if (untypedMessage.toolCalls?.length === 0) {
+        untypedMessage.toolCalls = undefined;
+      }
+    }
+  }
+
+  // custom mapping for json patch operations
+  if (decoded.type === EventType.STATE_DELTA) {
+    for (const operation of (decoded as any).delta) {
+      operation.op = protoPatch.JsonPatchOperationType[operation.op].toLowerCase();
+      Object.keys(operation).forEach((key) => {
+        if (operation[key] === undefined) {
+          delete operation[key];
+        }
+      });
+    }
+  }
+
+  Object.keys(decoded).forEach((key) => {
+    if (decoded[key] === undefined) {
+      delete decoded[key];
+    }
+  });
+
+  return EventSchemas.parse(decoded);
+}

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/__tests__/**"]
+}

package/tsup.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: ["src/index.ts"],
+  format: ["esm", "cjs"],
+  dts: true,
+  splitting: false,
+  sourcemap: true,
+  clean: true,
+});