1695 lines
57 KiB
JavaScript
1695 lines
57 KiB
JavaScript
import { EventSchemas, EventType } from "@ag-ui/core";
|
|
import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
|
|
|
|
//#region src/generated/google/protobuf/struct.ts
|
|
/**
|
|
* `NullValue` is a singleton enumeration to represent the null value for the
|
|
* `Value` type union.
|
|
*
|
|
* The JSON representation for `NullValue` is JSON `null`.
|
|
*/
|
|
let NullValue = /* @__PURE__ */ function(NullValue) {
|
|
/** NULL_VALUE - Null value. */
|
|
NullValue[NullValue["NULL_VALUE"] = 0] = "NULL_VALUE";
|
|
NullValue[NullValue["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
|
|
return NullValue;
|
|
}({});
|
|
function createBaseStruct() {
|
|
return { fields: {} };
|
|
}
|
|
const Struct = {
|
|
encode(message, writer = new BinaryWriter()) {
|
|
Object.entries(message.fields).forEach(([key, value]) => {
|
|
if (value !== void 0) Struct_FieldsEntry.encode({
|
|
key,
|
|
value
|
|
}, writer.uint32(10).fork()).join();
|
|
});
|
|
return writer;
|
|
},
|
|
decode(input, length) {
|
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === void 0 ? reader.len : reader.pos + length;
|
|
const message = createBaseStruct();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
if (tag !== 10) break;
|
|
const entry1 = Struct_FieldsEntry.decode(reader, reader.uint32());
|
|
if (entry1.value !== void 0) message.fields[entry1.key] = entry1.value;
|
|
continue;
|
|
}
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) break;
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
create(base) {
|
|
return Struct.fromPartial(base ?? {});
|
|
},
|
|
fromPartial(object) {
|
|
const message = createBaseStruct();
|
|
message.fields = Object.entries(object.fields ?? {}).reduce((acc, [key, value]) => {
|
|
if (value !== void 0) acc[key] = value;
|
|
return acc;
|
|
}, {});
|
|
return message;
|
|
},
|
|
wrap(object) {
|
|
const struct = createBaseStruct();
|
|
if (object !== void 0) for (const key of Object.keys(object)) struct.fields[key] = object[key];
|
|
return struct;
|
|
},
|
|
unwrap(message) {
|
|
const object = {};
|
|
if (message.fields) for (const key of Object.keys(message.fields)) object[key] = message.fields[key];
|
|
return object;
|
|
}
|
|
};
|
|
function createBaseStruct_FieldsEntry() {
|
|
return {
|
|
key: "",
|
|
value: void 0
|
|
};
|
|
}
|
|
const Struct_FieldsEntry = {
|
|
encode(message, writer = new BinaryWriter()) {
|
|
if (message.key !== "") writer.uint32(10).string(message.key);
|
|
if (message.value !== void 0) Value.encode(Value.wrap(message.value), writer.uint32(18).fork()).join();
|
|
return writer;
|
|
},
|
|
decode(input, length) {
|
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === void 0 ? reader.len : reader.pos + length;
|
|
const message = createBaseStruct_FieldsEntry();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
if (tag !== 10) break;
|
|
message.key = reader.string();
|
|
continue;
|
|
case 2:
|
|
if (tag !== 18) break;
|
|
message.value = Value.unwrap(Value.decode(reader, reader.uint32()));
|
|
continue;
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) break;
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
create(base) {
|
|
return Struct_FieldsEntry.fromPartial(base ?? {});
|
|
},
|
|
fromPartial(object) {
|
|
const message = createBaseStruct_FieldsEntry();
|
|
message.key = object.key ?? "";
|
|
message.value = object.value ?? void 0;
|
|
return message;
|
|
}
|
|
};
|
|
function createBaseValue() {
|
|
return {
|
|
nullValue: void 0,
|
|
numberValue: void 0,
|
|
stringValue: void 0,
|
|
boolValue: void 0,
|
|
structValue: void 0,
|
|
listValue: void 0
|
|
};
|
|
}
|
|
const Value = {
|
|
encode(message, writer = new BinaryWriter()) {
|
|
if (message.nullValue !== void 0) writer.uint32(8).int32(message.nullValue);
|
|
if (message.numberValue !== void 0) writer.uint32(17).double(message.numberValue);
|
|
if (message.stringValue !== void 0) writer.uint32(26).string(message.stringValue);
|
|
if (message.boolValue !== void 0) writer.uint32(32).bool(message.boolValue);
|
|
if (message.structValue !== void 0) Struct.encode(Struct.wrap(message.structValue), writer.uint32(42).fork()).join();
|
|
if (message.listValue !== void 0) ListValue.encode(ListValue.wrap(message.listValue), writer.uint32(50).fork()).join();
|
|
return writer;
|
|
},
|
|
decode(input, length) {
|
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === void 0 ? reader.len : reader.pos + length;
|
|
const message = createBaseValue();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
if (tag !== 8) break;
|
|
message.nullValue = reader.int32();
|
|
continue;
|
|
case 2:
|
|
if (tag !== 17) break;
|
|
message.numberValue = reader.double();
|
|
continue;
|
|
case 3:
|
|
if (tag !== 26) break;
|
|
message.stringValue = reader.string();
|
|
continue;
|
|
case 4:
|
|
if (tag !== 32) break;
|
|
message.boolValue = reader.bool();
|
|
continue;
|
|
case 5:
|
|
if (tag !== 42) break;
|
|
message.structValue = Struct.unwrap(Struct.decode(reader, reader.uint32()));
|
|
continue;
|
|
case 6:
|
|
if (tag !== 50) break;
|
|
message.listValue = ListValue.unwrap(ListValue.decode(reader, reader.uint32()));
|
|
continue;
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) break;
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
create(base) {
|
|
return Value.fromPartial(base ?? {});
|
|
},
|
|
fromPartial(object) {
|
|
const message = createBaseValue();
|
|
message.nullValue = object.nullValue ?? void 0;
|
|
message.numberValue = object.numberValue ?? void 0;
|
|
message.stringValue = object.stringValue ?? void 0;
|
|
message.boolValue = object.boolValue ?? void 0;
|
|
message.structValue = object.structValue ?? void 0;
|
|
message.listValue = object.listValue ?? void 0;
|
|
return message;
|
|
},
|
|
wrap(value) {
|
|
const result = createBaseValue();
|
|
if (value === null) result.nullValue = NullValue.NULL_VALUE;
|
|
else if (typeof value === "boolean") result.boolValue = value;
|
|
else if (typeof value === "number") result.numberValue = value;
|
|
else if (typeof value === "string") result.stringValue = value;
|
|
else if (globalThis.Array.isArray(value)) result.listValue = value;
|
|
else if (typeof value === "object") result.structValue = value;
|
|
else if (typeof value !== "undefined") throw new globalThis.Error("Unsupported any value type: " + typeof value);
|
|
return result;
|
|
},
|
|
unwrap(message) {
|
|
if (message.stringValue !== void 0) return message.stringValue;
|
|
else if (message?.numberValue !== void 0) return message.numberValue;
|
|
else if (message?.boolValue !== void 0) return message.boolValue;
|
|
else if (message?.structValue !== void 0) return message.structValue;
|
|
else if (message?.listValue !== void 0) return message.listValue;
|
|
else if (message?.nullValue !== void 0) return null;
|
|
}
|
|
};
|
|
function createBaseListValue() {
|
|
return { values: [] };
|
|
}
|
|
const ListValue = {
|
|
encode(message, writer = new BinaryWriter()) {
|
|
for (const v of message.values) Value.encode(Value.wrap(v), writer.uint32(10).fork()).join();
|
|
return writer;
|
|
},
|
|
decode(input, length) {
|
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === void 0 ? reader.len : reader.pos + length;
|
|
const message = createBaseListValue();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
if (tag !== 10) break;
|
|
message.values.push(Value.unwrap(Value.decode(reader, reader.uint32())));
|
|
continue;
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) break;
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
create(base) {
|
|
return ListValue.fromPartial(base ?? {});
|
|
},
|
|
fromPartial(object) {
|
|
const message = createBaseListValue();
|
|
message.values = object.values?.map((e) => e) || [];
|
|
return message;
|
|
},
|
|
wrap(array) {
|
|
const result = createBaseListValue();
|
|
result.values = array ?? [];
|
|
return result;
|
|
},
|
|
unwrap(message) {
|
|
if (message?.hasOwnProperty("values") && globalThis.Array.isArray(message.values)) return message.values;
|
|
else return message;
|
|
}
|
|
};
|
|
|
|
//#endregion
|
|
//#region src/generated/patch.ts
|
|
let JsonPatchOperationType = /* @__PURE__ */ function(JsonPatchOperationType) {
|
|
JsonPatchOperationType[JsonPatchOperationType["ADD"] = 0] = "ADD";
|
|
JsonPatchOperationType[JsonPatchOperationType["REMOVE"] = 1] = "REMOVE";
|
|
JsonPatchOperationType[JsonPatchOperationType["REPLACE"] = 2] = "REPLACE";
|
|
JsonPatchOperationType[JsonPatchOperationType["MOVE"] = 3] = "MOVE";
|
|
JsonPatchOperationType[JsonPatchOperationType["COPY"] = 4] = "COPY";
|
|
JsonPatchOperationType[JsonPatchOperationType["TEST"] = 5] = "TEST";
|
|
JsonPatchOperationType[JsonPatchOperationType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
|
|
return JsonPatchOperationType;
|
|
}({});
|
|
function createBaseJsonPatchOperation() {
|
|
return {
|
|
op: 0,
|
|
path: "",
|
|
from: void 0,
|
|
value: void 0
|
|
};
|
|
}
|
|
const JsonPatchOperation = {
|
|
encode(message, writer = new BinaryWriter()) {
|
|
if (message.op !== 0) writer.uint32(8).int32(message.op);
|
|
if (message.path !== "") writer.uint32(18).string(message.path);
|
|
if (message.from !== void 0) writer.uint32(26).string(message.from);
|
|
if (message.value !== void 0) Value.encode(Value.wrap(message.value), writer.uint32(34).fork()).join();
|
|
return writer;
|
|
},
|
|
decode(input, length) {
|
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === void 0 ? reader.len : reader.pos + length;
|
|
const message = createBaseJsonPatchOperation();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
if (tag !== 8) break;
|
|
message.op = reader.int32();
|
|
continue;
|
|
case 2:
|
|
if (tag !== 18) break;
|
|
message.path = reader.string();
|
|
continue;
|
|
case 3:
|
|
if (tag !== 26) break;
|
|
message.from = reader.string();
|
|
continue;
|
|
case 4:
|
|
if (tag !== 34) break;
|
|
message.value = Value.unwrap(Value.decode(reader, reader.uint32()));
|
|
continue;
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) break;
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
create(base) {
|
|
return JsonPatchOperation.fromPartial(base ?? {});
|
|
},
|
|
fromPartial(object) {
|
|
const message = createBaseJsonPatchOperation();
|
|
message.op = object.op ?? 0;
|
|
message.path = object.path ?? "";
|
|
message.from = object.from ?? void 0;
|
|
message.value = object.value ?? void 0;
|
|
return message;
|
|
}
|
|
};
|
|
|
|
//#endregion
|
|
//#region src/generated/types.ts
|
|
function createBaseToolCall() {
|
|
return {
|
|
id: "",
|
|
type: "",
|
|
function: void 0
|
|
};
|
|
}
|
|
const ToolCall = {
|
|
encode(message, writer = new BinaryWriter()) {
|
|
if (message.id !== "") writer.uint32(10).string(message.id);
|
|
if (message.type !== "") writer.uint32(18).string(message.type);
|
|
if (message.function !== void 0) ToolCall_Function.encode(message.function, writer.uint32(26).fork()).join();
|
|
return writer;
|
|
},
|
|
decode(input, length) {
|
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === void 0 ? 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(base) {
|
|
return ToolCall.fromPartial(base ?? {});
|
|
},
|
|
fromPartial(object) {
|
|
const message = createBaseToolCall();
|
|
message.id = object.id ?? "";
|
|
message.type = object.type ?? "";
|
|
message.function = object.function !== void 0 && object.function !== null ? ToolCall_Function.fromPartial(object.function) : void 0;
|
|
return message;
|
|
}
|
|
};
|
|
function createBaseToolCall_Function() {
|
|
return {
|
|
name: "",
|
|
arguments: ""
|
|
};
|
|
}
|
|
const ToolCall_Function = {
|
|
encode(message, writer = new BinaryWriter()) {
|
|
if (message.name !== "") writer.uint32(10).string(message.name);
|
|
if (message.arguments !== "") writer.uint32(18).string(message.arguments);
|
|
return writer;
|
|
},
|
|
decode(input, length) {
|
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === void 0 ? 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(base) {
|
|
return ToolCall_Function.fromPartial(base ?? {});
|
|
},
|
|
fromPartial(object) {
|
|
const message = createBaseToolCall_Function();
|
|
message.name = object.name ?? "";
|
|
message.arguments = object.arguments ?? "";
|
|
return message;
|
|
}
|
|
};
|
|
function createBaseMessage() {
|
|
return {
|
|
id: "",
|
|
role: "",
|
|
content: void 0,
|
|
name: void 0,
|
|
toolCalls: [],
|
|
toolCallId: void 0,
|
|
error: void 0
|
|
};
|
|
}
|
|
const Message = {
|
|
encode(message, writer = new BinaryWriter()) {
|
|
if (message.id !== "") writer.uint32(10).string(message.id);
|
|
if (message.role !== "") writer.uint32(18).string(message.role);
|
|
if (message.content !== void 0) writer.uint32(26).string(message.content);
|
|
if (message.name !== void 0) writer.uint32(34).string(message.name);
|
|
for (const v of message.toolCalls) ToolCall.encode(v, writer.uint32(42).fork()).join();
|
|
if (message.toolCallId !== void 0) writer.uint32(50).string(message.toolCallId);
|
|
if (message.error !== void 0) writer.uint32(58).string(message.error);
|
|
return writer;
|
|
},
|
|
decode(input, length) {
|
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === void 0 ? 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;
|
|
case 7:
|
|
if (tag !== 58) break;
|
|
message.error = reader.string();
|
|
continue;
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) break;
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
create(base) {
|
|
return Message.fromPartial(base ?? {});
|
|
},
|
|
fromPartial(object) {
|
|
const message = createBaseMessage();
|
|
message.id = object.id ?? "";
|
|
message.role = object.role ?? "";
|
|
message.content = object.content ?? void 0;
|
|
message.name = object.name ?? void 0;
|
|
message.toolCalls = object.toolCalls?.map((e) => ToolCall.fromPartial(e)) || [];
|
|
message.toolCallId = object.toolCallId ?? void 0;
|
|
message.error = object.error ?? void 0;
|
|
return message;
|
|
}
|
|
};
|
|
|
|
//#endregion
|
|
//#region src/generated/events.ts
|
|
let EventType$1 = /* @__PURE__ */ function(EventType) {
|
|
EventType[EventType["TEXT_MESSAGE_START"] = 0] = "TEXT_MESSAGE_START";
|
|
EventType[EventType["TEXT_MESSAGE_CONTENT"] = 1] = "TEXT_MESSAGE_CONTENT";
|
|
EventType[EventType["TEXT_MESSAGE_END"] = 2] = "TEXT_MESSAGE_END";
|
|
EventType[EventType["TOOL_CALL_START"] = 3] = "TOOL_CALL_START";
|
|
EventType[EventType["TOOL_CALL_ARGS"] = 4] = "TOOL_CALL_ARGS";
|
|
EventType[EventType["TOOL_CALL_END"] = 5] = "TOOL_CALL_END";
|
|
EventType[EventType["STATE_SNAPSHOT"] = 6] = "STATE_SNAPSHOT";
|
|
EventType[EventType["STATE_DELTA"] = 7] = "STATE_DELTA";
|
|
EventType[EventType["MESSAGES_SNAPSHOT"] = 8] = "MESSAGES_SNAPSHOT";
|
|
EventType[EventType["RAW"] = 9] = "RAW";
|
|
EventType[EventType["CUSTOM"] = 10] = "CUSTOM";
|
|
EventType[EventType["RUN_STARTED"] = 11] = "RUN_STARTED";
|
|
EventType[EventType["RUN_FINISHED"] = 12] = "RUN_FINISHED";
|
|
EventType[EventType["RUN_ERROR"] = 13] = "RUN_ERROR";
|
|
EventType[EventType["STEP_STARTED"] = 14] = "STEP_STARTED";
|
|
EventType[EventType["STEP_FINISHED"] = 15] = "STEP_FINISHED";
|
|
EventType[EventType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
|
|
return EventType;
|
|
}({});
|
|
function createBaseBaseEvent() {
|
|
return {
|
|
type: 0,
|
|
timestamp: void 0,
|
|
rawEvent: void 0
|
|
};
|
|
}
|
|
const BaseEvent$1 = {
|
|
encode(message, writer = new BinaryWriter()) {
|
|
if (message.type !== 0) writer.uint32(8).int32(message.type);
|
|
if (message.timestamp !== void 0) writer.uint32(16).int64(message.timestamp);
|
|
if (message.rawEvent !== void 0) Value.encode(Value.wrap(message.rawEvent), writer.uint32(26).fork()).join();
|
|
return writer;
|
|
},
|
|
decode(input, length) {
|
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === void 0 ? reader.len : reader.pos + length;
|
|
const message = createBaseBaseEvent();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
if (tag !== 8) break;
|
|
message.type = reader.int32();
|
|
continue;
|
|
case 2:
|
|
if (tag !== 16) break;
|
|
message.timestamp = longToNumber(reader.int64());
|
|
continue;
|
|
case 3:
|
|
if (tag !== 26) break;
|
|
message.rawEvent = Value.unwrap(Value.decode(reader, reader.uint32()));
|
|
continue;
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) break;
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
create(base) {
|
|
return BaseEvent$1.fromPartial(base ?? {});
|
|
},
|
|
fromPartial(object) {
|
|
const message = createBaseBaseEvent();
|
|
message.type = object.type ?? 0;
|
|
message.timestamp = object.timestamp ?? void 0;
|
|
message.rawEvent = object.rawEvent ?? void 0;
|
|
return message;
|
|
}
|
|
};
|
|
function createBaseTextMessageStartEvent() {
|
|
return {
|
|
baseEvent: void 0,
|
|
messageId: "",
|
|
role: void 0
|
|
};
|
|
}
|
|
const TextMessageStartEvent = {
|
|
encode(message, writer = new BinaryWriter()) {
|
|
if (message.baseEvent !== void 0) BaseEvent$1.encode(message.baseEvent, writer.uint32(10).fork()).join();
|
|
if (message.messageId !== "") writer.uint32(18).string(message.messageId);
|
|
if (message.role !== void 0) writer.uint32(26).string(message.role);
|
|
return writer;
|
|
},
|
|
decode(input, length) {
|
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === void 0 ? reader.len : reader.pos + length;
|
|
const message = createBaseTextMessageStartEvent();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
if (tag !== 10) break;
|
|
message.baseEvent = BaseEvent$1.decode(reader, reader.uint32());
|
|
continue;
|
|
case 2:
|
|
if (tag !== 18) break;
|
|
message.messageId = reader.string();
|
|
continue;
|
|
case 3:
|
|
if (tag !== 26) break;
|
|
message.role = reader.string();
|
|
continue;
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) break;
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
create(base) {
|
|
return TextMessageStartEvent.fromPartial(base ?? {});
|
|
},
|
|
fromPartial(object) {
|
|
const message = createBaseTextMessageStartEvent();
|
|
message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent$1.fromPartial(object.baseEvent) : void 0;
|
|
message.messageId = object.messageId ?? "";
|
|
message.role = object.role ?? void 0;
|
|
return message;
|
|
}
|
|
};
|
|
function createBaseTextMessageContentEvent() {
|
|
return {
|
|
baseEvent: void 0,
|
|
messageId: "",
|
|
delta: ""
|
|
};
|
|
}
|
|
const TextMessageContentEvent = {
|
|
encode(message, writer = new BinaryWriter()) {
|
|
if (message.baseEvent !== void 0) BaseEvent$1.encode(message.baseEvent, writer.uint32(10).fork()).join();
|
|
if (message.messageId !== "") writer.uint32(18).string(message.messageId);
|
|
if (message.delta !== "") writer.uint32(26).string(message.delta);
|
|
return writer;
|
|
},
|
|
decode(input, length) {
|
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === void 0 ? reader.len : reader.pos + length;
|
|
const message = createBaseTextMessageContentEvent();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
if (tag !== 10) break;
|
|
message.baseEvent = BaseEvent$1.decode(reader, reader.uint32());
|
|
continue;
|
|
case 2:
|
|
if (tag !== 18) break;
|
|
message.messageId = reader.string();
|
|
continue;
|
|
case 3:
|
|
if (tag !== 26) break;
|
|
message.delta = reader.string();
|
|
continue;
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) break;
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
create(base) {
|
|
return TextMessageContentEvent.fromPartial(base ?? {});
|
|
},
|
|
fromPartial(object) {
|
|
const message = createBaseTextMessageContentEvent();
|
|
message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent$1.fromPartial(object.baseEvent) : void 0;
|
|
message.messageId = object.messageId ?? "";
|
|
message.delta = object.delta ?? "";
|
|
return message;
|
|
}
|
|
};
|
|
function createBaseTextMessageEndEvent() {
|
|
return {
|
|
baseEvent: void 0,
|
|
messageId: ""
|
|
};
|
|
}
|
|
const TextMessageEndEvent = {
|
|
encode(message, writer = new BinaryWriter()) {
|
|
if (message.baseEvent !== void 0) BaseEvent$1.encode(message.baseEvent, writer.uint32(10).fork()).join();
|
|
if (message.messageId !== "") writer.uint32(18).string(message.messageId);
|
|
return writer;
|
|
},
|
|
decode(input, length) {
|
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === void 0 ? reader.len : reader.pos + length;
|
|
const message = createBaseTextMessageEndEvent();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
if (tag !== 10) break;
|
|
message.baseEvent = BaseEvent$1.decode(reader, reader.uint32());
|
|
continue;
|
|
case 2:
|
|
if (tag !== 18) break;
|
|
message.messageId = reader.string();
|
|
continue;
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) break;
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
create(base) {
|
|
return TextMessageEndEvent.fromPartial(base ?? {});
|
|
},
|
|
fromPartial(object) {
|
|
const message = createBaseTextMessageEndEvent();
|
|
message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent$1.fromPartial(object.baseEvent) : void 0;
|
|
message.messageId = object.messageId ?? "";
|
|
return message;
|
|
}
|
|
};
|
|
function createBaseToolCallStartEvent() {
|
|
return {
|
|
baseEvent: void 0,
|
|
toolCallId: "",
|
|
toolCallName: "",
|
|
parentMessageId: void 0
|
|
};
|
|
}
|
|
const ToolCallStartEvent = {
|
|
encode(message, writer = new BinaryWriter()) {
|
|
if (message.baseEvent !== void 0) BaseEvent$1.encode(message.baseEvent, writer.uint32(10).fork()).join();
|
|
if (message.toolCallId !== "") writer.uint32(18).string(message.toolCallId);
|
|
if (message.toolCallName !== "") writer.uint32(26).string(message.toolCallName);
|
|
if (message.parentMessageId !== void 0) writer.uint32(34).string(message.parentMessageId);
|
|
return writer;
|
|
},
|
|
decode(input, length) {
|
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === void 0 ? reader.len : reader.pos + length;
|
|
const message = createBaseToolCallStartEvent();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
if (tag !== 10) break;
|
|
message.baseEvent = BaseEvent$1.decode(reader, reader.uint32());
|
|
continue;
|
|
case 2:
|
|
if (tag !== 18) break;
|
|
message.toolCallId = reader.string();
|
|
continue;
|
|
case 3:
|
|
if (tag !== 26) break;
|
|
message.toolCallName = reader.string();
|
|
continue;
|
|
case 4:
|
|
if (tag !== 34) break;
|
|
message.parentMessageId = reader.string();
|
|
continue;
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) break;
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
create(base) {
|
|
return ToolCallStartEvent.fromPartial(base ?? {});
|
|
},
|
|
fromPartial(object) {
|
|
const message = createBaseToolCallStartEvent();
|
|
message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent$1.fromPartial(object.baseEvent) : void 0;
|
|
message.toolCallId = object.toolCallId ?? "";
|
|
message.toolCallName = object.toolCallName ?? "";
|
|
message.parentMessageId = object.parentMessageId ?? void 0;
|
|
return message;
|
|
}
|
|
};
|
|
function createBaseToolCallArgsEvent() {
|
|
return {
|
|
baseEvent: void 0,
|
|
toolCallId: "",
|
|
delta: ""
|
|
};
|
|
}
|
|
const ToolCallArgsEvent = {
|
|
encode(message, writer = new BinaryWriter()) {
|
|
if (message.baseEvent !== void 0) BaseEvent$1.encode(message.baseEvent, writer.uint32(10).fork()).join();
|
|
if (message.toolCallId !== "") writer.uint32(18).string(message.toolCallId);
|
|
if (message.delta !== "") writer.uint32(26).string(message.delta);
|
|
return writer;
|
|
},
|
|
decode(input, length) {
|
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === void 0 ? reader.len : reader.pos + length;
|
|
const message = createBaseToolCallArgsEvent();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
if (tag !== 10) break;
|
|
message.baseEvent = BaseEvent$1.decode(reader, reader.uint32());
|
|
continue;
|
|
case 2:
|
|
if (tag !== 18) break;
|
|
message.toolCallId = reader.string();
|
|
continue;
|
|
case 3:
|
|
if (tag !== 26) break;
|
|
message.delta = reader.string();
|
|
continue;
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) break;
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
create(base) {
|
|
return ToolCallArgsEvent.fromPartial(base ?? {});
|
|
},
|
|
fromPartial(object) {
|
|
const message = createBaseToolCallArgsEvent();
|
|
message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent$1.fromPartial(object.baseEvent) : void 0;
|
|
message.toolCallId = object.toolCallId ?? "";
|
|
message.delta = object.delta ?? "";
|
|
return message;
|
|
}
|
|
};
|
|
function createBaseToolCallEndEvent() {
|
|
return {
|
|
baseEvent: void 0,
|
|
toolCallId: ""
|
|
};
|
|
}
|
|
const ToolCallEndEvent = {
|
|
encode(message, writer = new BinaryWriter()) {
|
|
if (message.baseEvent !== void 0) BaseEvent$1.encode(message.baseEvent, writer.uint32(10).fork()).join();
|
|
if (message.toolCallId !== "") writer.uint32(18).string(message.toolCallId);
|
|
return writer;
|
|
},
|
|
decode(input, length) {
|
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === void 0 ? reader.len : reader.pos + length;
|
|
const message = createBaseToolCallEndEvent();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
if (tag !== 10) break;
|
|
message.baseEvent = BaseEvent$1.decode(reader, reader.uint32());
|
|
continue;
|
|
case 2:
|
|
if (tag !== 18) break;
|
|
message.toolCallId = reader.string();
|
|
continue;
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) break;
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
create(base) {
|
|
return ToolCallEndEvent.fromPartial(base ?? {});
|
|
},
|
|
fromPartial(object) {
|
|
const message = createBaseToolCallEndEvent();
|
|
message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent$1.fromPartial(object.baseEvent) : void 0;
|
|
message.toolCallId = object.toolCallId ?? "";
|
|
return message;
|
|
}
|
|
};
|
|
function createBaseStateSnapshotEvent() {
|
|
return {
|
|
baseEvent: void 0,
|
|
snapshot: void 0
|
|
};
|
|
}
|
|
const StateSnapshotEvent = {
|
|
encode(message, writer = new BinaryWriter()) {
|
|
if (message.baseEvent !== void 0) BaseEvent$1.encode(message.baseEvent, writer.uint32(10).fork()).join();
|
|
if (message.snapshot !== void 0) Value.encode(Value.wrap(message.snapshot), writer.uint32(18).fork()).join();
|
|
return writer;
|
|
},
|
|
decode(input, length) {
|
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === void 0 ? reader.len : reader.pos + length;
|
|
const message = createBaseStateSnapshotEvent();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
if (tag !== 10) break;
|
|
message.baseEvent = BaseEvent$1.decode(reader, reader.uint32());
|
|
continue;
|
|
case 2:
|
|
if (tag !== 18) break;
|
|
message.snapshot = Value.unwrap(Value.decode(reader, reader.uint32()));
|
|
continue;
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) break;
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
create(base) {
|
|
return StateSnapshotEvent.fromPartial(base ?? {});
|
|
},
|
|
fromPartial(object) {
|
|
const message = createBaseStateSnapshotEvent();
|
|
message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent$1.fromPartial(object.baseEvent) : void 0;
|
|
message.snapshot = object.snapshot ?? void 0;
|
|
return message;
|
|
}
|
|
};
|
|
function createBaseStateDeltaEvent() {
|
|
return {
|
|
baseEvent: void 0,
|
|
delta: []
|
|
};
|
|
}
|
|
const StateDeltaEvent = {
|
|
encode(message, writer = new BinaryWriter()) {
|
|
if (message.baseEvent !== void 0) BaseEvent$1.encode(message.baseEvent, writer.uint32(10).fork()).join();
|
|
for (const v of message.delta) JsonPatchOperation.encode(v, writer.uint32(18).fork()).join();
|
|
return writer;
|
|
},
|
|
decode(input, length) {
|
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === void 0 ? reader.len : reader.pos + length;
|
|
const message = createBaseStateDeltaEvent();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
if (tag !== 10) break;
|
|
message.baseEvent = BaseEvent$1.decode(reader, reader.uint32());
|
|
continue;
|
|
case 2:
|
|
if (tag !== 18) break;
|
|
message.delta.push(JsonPatchOperation.decode(reader, reader.uint32()));
|
|
continue;
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) break;
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
create(base) {
|
|
return StateDeltaEvent.fromPartial(base ?? {});
|
|
},
|
|
fromPartial(object) {
|
|
const message = createBaseStateDeltaEvent();
|
|
message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent$1.fromPartial(object.baseEvent) : void 0;
|
|
message.delta = object.delta?.map((e) => JsonPatchOperation.fromPartial(e)) || [];
|
|
return message;
|
|
}
|
|
};
|
|
function createBaseMessagesSnapshotEvent() {
|
|
return {
|
|
baseEvent: void 0,
|
|
messages: []
|
|
};
|
|
}
|
|
const MessagesSnapshotEvent = {
|
|
encode(message, writer = new BinaryWriter()) {
|
|
if (message.baseEvent !== void 0) BaseEvent$1.encode(message.baseEvent, writer.uint32(10).fork()).join();
|
|
for (const v of message.messages) Message.encode(v, writer.uint32(18).fork()).join();
|
|
return writer;
|
|
},
|
|
decode(input, length) {
|
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === void 0 ? reader.len : reader.pos + length;
|
|
const message = createBaseMessagesSnapshotEvent();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
if (tag !== 10) break;
|
|
message.baseEvent = BaseEvent$1.decode(reader, reader.uint32());
|
|
continue;
|
|
case 2:
|
|
if (tag !== 18) break;
|
|
message.messages.push(Message.decode(reader, reader.uint32()));
|
|
continue;
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) break;
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
create(base) {
|
|
return MessagesSnapshotEvent.fromPartial(base ?? {});
|
|
},
|
|
fromPartial(object) {
|
|
const message = createBaseMessagesSnapshotEvent();
|
|
message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent$1.fromPartial(object.baseEvent) : void 0;
|
|
message.messages = object.messages?.map((e) => Message.fromPartial(e)) || [];
|
|
return message;
|
|
}
|
|
};
|
|
function createBaseRawEvent() {
|
|
return {
|
|
baseEvent: void 0,
|
|
event: void 0,
|
|
source: void 0
|
|
};
|
|
}
|
|
const RawEvent = {
|
|
encode(message, writer = new BinaryWriter()) {
|
|
if (message.baseEvent !== void 0) BaseEvent$1.encode(message.baseEvent, writer.uint32(10).fork()).join();
|
|
if (message.event !== void 0) Value.encode(Value.wrap(message.event), writer.uint32(18).fork()).join();
|
|
if (message.source !== void 0) writer.uint32(26).string(message.source);
|
|
return writer;
|
|
},
|
|
decode(input, length) {
|
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === void 0 ? reader.len : reader.pos + length;
|
|
const message = createBaseRawEvent();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
if (tag !== 10) break;
|
|
message.baseEvent = BaseEvent$1.decode(reader, reader.uint32());
|
|
continue;
|
|
case 2:
|
|
if (tag !== 18) break;
|
|
message.event = Value.unwrap(Value.decode(reader, reader.uint32()));
|
|
continue;
|
|
case 3:
|
|
if (tag !== 26) break;
|
|
message.source = reader.string();
|
|
continue;
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) break;
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
create(base) {
|
|
return RawEvent.fromPartial(base ?? {});
|
|
},
|
|
fromPartial(object) {
|
|
const message = createBaseRawEvent();
|
|
message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent$1.fromPartial(object.baseEvent) : void 0;
|
|
message.event = object.event ?? void 0;
|
|
message.source = object.source ?? void 0;
|
|
return message;
|
|
}
|
|
};
|
|
function createBaseCustomEvent() {
|
|
return {
|
|
baseEvent: void 0,
|
|
name: "",
|
|
value: void 0
|
|
};
|
|
}
|
|
const CustomEvent = {
|
|
encode(message, writer = new BinaryWriter()) {
|
|
if (message.baseEvent !== void 0) BaseEvent$1.encode(message.baseEvent, writer.uint32(10).fork()).join();
|
|
if (message.name !== "") writer.uint32(18).string(message.name);
|
|
if (message.value !== void 0) Value.encode(Value.wrap(message.value), writer.uint32(26).fork()).join();
|
|
return writer;
|
|
},
|
|
decode(input, length) {
|
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === void 0 ? reader.len : reader.pos + length;
|
|
const message = createBaseCustomEvent();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
if (tag !== 10) break;
|
|
message.baseEvent = BaseEvent$1.decode(reader, reader.uint32());
|
|
continue;
|
|
case 2:
|
|
if (tag !== 18) break;
|
|
message.name = reader.string();
|
|
continue;
|
|
case 3:
|
|
if (tag !== 26) break;
|
|
message.value = Value.unwrap(Value.decode(reader, reader.uint32()));
|
|
continue;
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) break;
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
create(base) {
|
|
return CustomEvent.fromPartial(base ?? {});
|
|
},
|
|
fromPartial(object) {
|
|
const message = createBaseCustomEvent();
|
|
message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent$1.fromPartial(object.baseEvent) : void 0;
|
|
message.name = object.name ?? "";
|
|
message.value = object.value ?? void 0;
|
|
return message;
|
|
}
|
|
};
|
|
function createBaseRunStartedEvent() {
|
|
return {
|
|
baseEvent: void 0,
|
|
threadId: "",
|
|
runId: ""
|
|
};
|
|
}
|
|
const RunStartedEvent = {
|
|
encode(message, writer = new BinaryWriter()) {
|
|
if (message.baseEvent !== void 0) BaseEvent$1.encode(message.baseEvent, writer.uint32(10).fork()).join();
|
|
if (message.threadId !== "") writer.uint32(18).string(message.threadId);
|
|
if (message.runId !== "") writer.uint32(26).string(message.runId);
|
|
return writer;
|
|
},
|
|
decode(input, length) {
|
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === void 0 ? reader.len : reader.pos + length;
|
|
const message = createBaseRunStartedEvent();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
if (tag !== 10) break;
|
|
message.baseEvent = BaseEvent$1.decode(reader, reader.uint32());
|
|
continue;
|
|
case 2:
|
|
if (tag !== 18) break;
|
|
message.threadId = reader.string();
|
|
continue;
|
|
case 3:
|
|
if (tag !== 26) break;
|
|
message.runId = reader.string();
|
|
continue;
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) break;
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
create(base) {
|
|
return RunStartedEvent.fromPartial(base ?? {});
|
|
},
|
|
fromPartial(object) {
|
|
const message = createBaseRunStartedEvent();
|
|
message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent$1.fromPartial(object.baseEvent) : void 0;
|
|
message.threadId = object.threadId ?? "";
|
|
message.runId = object.runId ?? "";
|
|
return message;
|
|
}
|
|
};
|
|
function createBaseRunFinishedEvent() {
|
|
return {
|
|
baseEvent: void 0,
|
|
threadId: "",
|
|
runId: "",
|
|
result: void 0
|
|
};
|
|
}
|
|
const RunFinishedEvent = {
|
|
encode(message, writer = new BinaryWriter()) {
|
|
if (message.baseEvent !== void 0) BaseEvent$1.encode(message.baseEvent, writer.uint32(10).fork()).join();
|
|
if (message.threadId !== "") writer.uint32(18).string(message.threadId);
|
|
if (message.runId !== "") writer.uint32(26).string(message.runId);
|
|
if (message.result !== void 0) Value.encode(Value.wrap(message.result), writer.uint32(34).fork()).join();
|
|
return writer;
|
|
},
|
|
decode(input, length) {
|
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === void 0 ? reader.len : reader.pos + length;
|
|
const message = createBaseRunFinishedEvent();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
if (tag !== 10) break;
|
|
message.baseEvent = BaseEvent$1.decode(reader, reader.uint32());
|
|
continue;
|
|
case 2:
|
|
if (tag !== 18) break;
|
|
message.threadId = reader.string();
|
|
continue;
|
|
case 3:
|
|
if (tag !== 26) break;
|
|
message.runId = reader.string();
|
|
continue;
|
|
case 4:
|
|
if (tag !== 34) break;
|
|
message.result = Value.unwrap(Value.decode(reader, reader.uint32()));
|
|
continue;
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) break;
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
create(base) {
|
|
return RunFinishedEvent.fromPartial(base ?? {});
|
|
},
|
|
fromPartial(object) {
|
|
const message = createBaseRunFinishedEvent();
|
|
message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent$1.fromPartial(object.baseEvent) : void 0;
|
|
message.threadId = object.threadId ?? "";
|
|
message.runId = object.runId ?? "";
|
|
message.result = object.result ?? void 0;
|
|
return message;
|
|
}
|
|
};
|
|
function createBaseRunErrorEvent() {
|
|
return {
|
|
baseEvent: void 0,
|
|
code: void 0,
|
|
message: ""
|
|
};
|
|
}
|
|
const RunErrorEvent = {
|
|
encode(message, writer = new BinaryWriter()) {
|
|
if (message.baseEvent !== void 0) BaseEvent$1.encode(message.baseEvent, writer.uint32(10).fork()).join();
|
|
if (message.code !== void 0) writer.uint32(18).string(message.code);
|
|
if (message.message !== "") writer.uint32(26).string(message.message);
|
|
return writer;
|
|
},
|
|
decode(input, length) {
|
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === void 0 ? reader.len : reader.pos + length;
|
|
const message = createBaseRunErrorEvent();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
if (tag !== 10) break;
|
|
message.baseEvent = BaseEvent$1.decode(reader, reader.uint32());
|
|
continue;
|
|
case 2:
|
|
if (tag !== 18) break;
|
|
message.code = reader.string();
|
|
continue;
|
|
case 3:
|
|
if (tag !== 26) break;
|
|
message.message = reader.string();
|
|
continue;
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) break;
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
create(base) {
|
|
return RunErrorEvent.fromPartial(base ?? {});
|
|
},
|
|
fromPartial(object) {
|
|
const message = createBaseRunErrorEvent();
|
|
message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent$1.fromPartial(object.baseEvent) : void 0;
|
|
message.code = object.code ?? void 0;
|
|
message.message = object.message ?? "";
|
|
return message;
|
|
}
|
|
};
|
|
function createBaseStepStartedEvent() {
|
|
return {
|
|
baseEvent: void 0,
|
|
stepName: ""
|
|
};
|
|
}
|
|
const StepStartedEvent = {
|
|
encode(message, writer = new BinaryWriter()) {
|
|
if (message.baseEvent !== void 0) BaseEvent$1.encode(message.baseEvent, writer.uint32(10).fork()).join();
|
|
if (message.stepName !== "") writer.uint32(18).string(message.stepName);
|
|
return writer;
|
|
},
|
|
decode(input, length) {
|
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === void 0 ? reader.len : reader.pos + length;
|
|
const message = createBaseStepStartedEvent();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
if (tag !== 10) break;
|
|
message.baseEvent = BaseEvent$1.decode(reader, reader.uint32());
|
|
continue;
|
|
case 2:
|
|
if (tag !== 18) break;
|
|
message.stepName = reader.string();
|
|
continue;
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) break;
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
create(base) {
|
|
return StepStartedEvent.fromPartial(base ?? {});
|
|
},
|
|
fromPartial(object) {
|
|
const message = createBaseStepStartedEvent();
|
|
message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent$1.fromPartial(object.baseEvent) : void 0;
|
|
message.stepName = object.stepName ?? "";
|
|
return message;
|
|
}
|
|
};
|
|
function createBaseStepFinishedEvent() {
|
|
return {
|
|
baseEvent: void 0,
|
|
stepName: ""
|
|
};
|
|
}
|
|
const StepFinishedEvent = {
|
|
encode(message, writer = new BinaryWriter()) {
|
|
if (message.baseEvent !== void 0) BaseEvent$1.encode(message.baseEvent, writer.uint32(10).fork()).join();
|
|
if (message.stepName !== "") writer.uint32(18).string(message.stepName);
|
|
return writer;
|
|
},
|
|
decode(input, length) {
|
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === void 0 ? reader.len : reader.pos + length;
|
|
const message = createBaseStepFinishedEvent();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
if (tag !== 10) break;
|
|
message.baseEvent = BaseEvent$1.decode(reader, reader.uint32());
|
|
continue;
|
|
case 2:
|
|
if (tag !== 18) break;
|
|
message.stepName = reader.string();
|
|
continue;
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) break;
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
create(base) {
|
|
return StepFinishedEvent.fromPartial(base ?? {});
|
|
},
|
|
fromPartial(object) {
|
|
const message = createBaseStepFinishedEvent();
|
|
message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent$1.fromPartial(object.baseEvent) : void 0;
|
|
message.stepName = object.stepName ?? "";
|
|
return message;
|
|
}
|
|
};
|
|
function createBaseTextMessageChunkEvent() {
|
|
return {
|
|
baseEvent: void 0,
|
|
messageId: void 0,
|
|
role: void 0,
|
|
delta: void 0
|
|
};
|
|
}
|
|
const TextMessageChunkEvent = {
|
|
encode(message, writer = new BinaryWriter()) {
|
|
if (message.baseEvent !== void 0) BaseEvent$1.encode(message.baseEvent, writer.uint32(10).fork()).join();
|
|
if (message.messageId !== void 0) writer.uint32(18).string(message.messageId);
|
|
if (message.role !== void 0) writer.uint32(26).string(message.role);
|
|
if (message.delta !== void 0) writer.uint32(34).string(message.delta);
|
|
return writer;
|
|
},
|
|
decode(input, length) {
|
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === void 0 ? reader.len : reader.pos + length;
|
|
const message = createBaseTextMessageChunkEvent();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
if (tag !== 10) break;
|
|
message.baseEvent = BaseEvent$1.decode(reader, reader.uint32());
|
|
continue;
|
|
case 2:
|
|
if (tag !== 18) break;
|
|
message.messageId = reader.string();
|
|
continue;
|
|
case 3:
|
|
if (tag !== 26) break;
|
|
message.role = reader.string();
|
|
continue;
|
|
case 4:
|
|
if (tag !== 34) break;
|
|
message.delta = reader.string();
|
|
continue;
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) break;
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
create(base) {
|
|
return TextMessageChunkEvent.fromPartial(base ?? {});
|
|
},
|
|
fromPartial(object) {
|
|
const message = createBaseTextMessageChunkEvent();
|
|
message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent$1.fromPartial(object.baseEvent) : void 0;
|
|
message.messageId = object.messageId ?? void 0;
|
|
message.role = object.role ?? void 0;
|
|
message.delta = object.delta ?? void 0;
|
|
return message;
|
|
}
|
|
};
|
|
function createBaseToolCallChunkEvent() {
|
|
return {
|
|
baseEvent: void 0,
|
|
toolCallId: void 0,
|
|
toolCallName: void 0,
|
|
parentMessageId: void 0,
|
|
delta: void 0
|
|
};
|
|
}
|
|
const ToolCallChunkEvent = {
|
|
encode(message, writer = new BinaryWriter()) {
|
|
if (message.baseEvent !== void 0) BaseEvent$1.encode(message.baseEvent, writer.uint32(10).fork()).join();
|
|
if (message.toolCallId !== void 0) writer.uint32(18).string(message.toolCallId);
|
|
if (message.toolCallName !== void 0) writer.uint32(26).string(message.toolCallName);
|
|
if (message.parentMessageId !== void 0) writer.uint32(34).string(message.parentMessageId);
|
|
if (message.delta !== void 0) writer.uint32(42).string(message.delta);
|
|
return writer;
|
|
},
|
|
decode(input, length) {
|
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === void 0 ? reader.len : reader.pos + length;
|
|
const message = createBaseToolCallChunkEvent();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
if (tag !== 10) break;
|
|
message.baseEvent = BaseEvent$1.decode(reader, reader.uint32());
|
|
continue;
|
|
case 2:
|
|
if (tag !== 18) break;
|
|
message.toolCallId = reader.string();
|
|
continue;
|
|
case 3:
|
|
if (tag !== 26) break;
|
|
message.toolCallName = reader.string();
|
|
continue;
|
|
case 4:
|
|
if (tag !== 34) break;
|
|
message.parentMessageId = reader.string();
|
|
continue;
|
|
case 5:
|
|
if (tag !== 42) break;
|
|
message.delta = reader.string();
|
|
continue;
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) break;
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
create(base) {
|
|
return ToolCallChunkEvent.fromPartial(base ?? {});
|
|
},
|
|
fromPartial(object) {
|
|
const message = createBaseToolCallChunkEvent();
|
|
message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent$1.fromPartial(object.baseEvent) : void 0;
|
|
message.toolCallId = object.toolCallId ?? void 0;
|
|
message.toolCallName = object.toolCallName ?? void 0;
|
|
message.parentMessageId = object.parentMessageId ?? void 0;
|
|
message.delta = object.delta ?? void 0;
|
|
return message;
|
|
}
|
|
};
|
|
function createBaseEvent() {
|
|
return {
|
|
textMessageStart: void 0,
|
|
textMessageContent: void 0,
|
|
textMessageEnd: void 0,
|
|
toolCallStart: void 0,
|
|
toolCallArgs: void 0,
|
|
toolCallEnd: void 0,
|
|
stateSnapshot: void 0,
|
|
stateDelta: void 0,
|
|
messagesSnapshot: void 0,
|
|
raw: void 0,
|
|
custom: void 0,
|
|
runStarted: void 0,
|
|
runFinished: void 0,
|
|
runError: void 0,
|
|
stepStarted: void 0,
|
|
stepFinished: void 0,
|
|
textMessageChunk: void 0,
|
|
toolCallChunk: void 0
|
|
};
|
|
}
|
|
const Event = {
|
|
encode(message, writer = new BinaryWriter()) {
|
|
if (message.textMessageStart !== void 0) TextMessageStartEvent.encode(message.textMessageStart, writer.uint32(10).fork()).join();
|
|
if (message.textMessageContent !== void 0) TextMessageContentEvent.encode(message.textMessageContent, writer.uint32(18).fork()).join();
|
|
if (message.textMessageEnd !== void 0) TextMessageEndEvent.encode(message.textMessageEnd, writer.uint32(26).fork()).join();
|
|
if (message.toolCallStart !== void 0) ToolCallStartEvent.encode(message.toolCallStart, writer.uint32(34).fork()).join();
|
|
if (message.toolCallArgs !== void 0) ToolCallArgsEvent.encode(message.toolCallArgs, writer.uint32(42).fork()).join();
|
|
if (message.toolCallEnd !== void 0) ToolCallEndEvent.encode(message.toolCallEnd, writer.uint32(50).fork()).join();
|
|
if (message.stateSnapshot !== void 0) StateSnapshotEvent.encode(message.stateSnapshot, writer.uint32(58).fork()).join();
|
|
if (message.stateDelta !== void 0) StateDeltaEvent.encode(message.stateDelta, writer.uint32(66).fork()).join();
|
|
if (message.messagesSnapshot !== void 0) MessagesSnapshotEvent.encode(message.messagesSnapshot, writer.uint32(74).fork()).join();
|
|
if (message.raw !== void 0) RawEvent.encode(message.raw, writer.uint32(82).fork()).join();
|
|
if (message.custom !== void 0) CustomEvent.encode(message.custom, writer.uint32(90).fork()).join();
|
|
if (message.runStarted !== void 0) RunStartedEvent.encode(message.runStarted, writer.uint32(98).fork()).join();
|
|
if (message.runFinished !== void 0) RunFinishedEvent.encode(message.runFinished, writer.uint32(106).fork()).join();
|
|
if (message.runError !== void 0) RunErrorEvent.encode(message.runError, writer.uint32(114).fork()).join();
|
|
if (message.stepStarted !== void 0) StepStartedEvent.encode(message.stepStarted, writer.uint32(122).fork()).join();
|
|
if (message.stepFinished !== void 0) StepFinishedEvent.encode(message.stepFinished, writer.uint32(130).fork()).join();
|
|
if (message.textMessageChunk !== void 0) TextMessageChunkEvent.encode(message.textMessageChunk, writer.uint32(138).fork()).join();
|
|
if (message.toolCallChunk !== void 0) ToolCallChunkEvent.encode(message.toolCallChunk, writer.uint32(146).fork()).join();
|
|
return writer;
|
|
},
|
|
decode(input, length) {
|
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === void 0 ? reader.len : reader.pos + length;
|
|
const message = createBaseEvent();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
if (tag !== 10) break;
|
|
message.textMessageStart = TextMessageStartEvent.decode(reader, reader.uint32());
|
|
continue;
|
|
case 2:
|
|
if (tag !== 18) break;
|
|
message.textMessageContent = TextMessageContentEvent.decode(reader, reader.uint32());
|
|
continue;
|
|
case 3:
|
|
if (tag !== 26) break;
|
|
message.textMessageEnd = TextMessageEndEvent.decode(reader, reader.uint32());
|
|
continue;
|
|
case 4:
|
|
if (tag !== 34) break;
|
|
message.toolCallStart = ToolCallStartEvent.decode(reader, reader.uint32());
|
|
continue;
|
|
case 5:
|
|
if (tag !== 42) break;
|
|
message.toolCallArgs = ToolCallArgsEvent.decode(reader, reader.uint32());
|
|
continue;
|
|
case 6:
|
|
if (tag !== 50) break;
|
|
message.toolCallEnd = ToolCallEndEvent.decode(reader, reader.uint32());
|
|
continue;
|
|
case 7:
|
|
if (tag !== 58) break;
|
|
message.stateSnapshot = StateSnapshotEvent.decode(reader, reader.uint32());
|
|
continue;
|
|
case 8:
|
|
if (tag !== 66) break;
|
|
message.stateDelta = StateDeltaEvent.decode(reader, reader.uint32());
|
|
continue;
|
|
case 9:
|
|
if (tag !== 74) break;
|
|
message.messagesSnapshot = MessagesSnapshotEvent.decode(reader, reader.uint32());
|
|
continue;
|
|
case 10:
|
|
if (tag !== 82) break;
|
|
message.raw = RawEvent.decode(reader, reader.uint32());
|
|
continue;
|
|
case 11:
|
|
if (tag !== 90) break;
|
|
message.custom = CustomEvent.decode(reader, reader.uint32());
|
|
continue;
|
|
case 12:
|
|
if (tag !== 98) break;
|
|
message.runStarted = RunStartedEvent.decode(reader, reader.uint32());
|
|
continue;
|
|
case 13:
|
|
if (tag !== 106) break;
|
|
message.runFinished = RunFinishedEvent.decode(reader, reader.uint32());
|
|
continue;
|
|
case 14:
|
|
if (tag !== 114) break;
|
|
message.runError = RunErrorEvent.decode(reader, reader.uint32());
|
|
continue;
|
|
case 15:
|
|
if (tag !== 122) break;
|
|
message.stepStarted = StepStartedEvent.decode(reader, reader.uint32());
|
|
continue;
|
|
case 16:
|
|
if (tag !== 130) break;
|
|
message.stepFinished = StepFinishedEvent.decode(reader, reader.uint32());
|
|
continue;
|
|
case 17:
|
|
if (tag !== 138) break;
|
|
message.textMessageChunk = TextMessageChunkEvent.decode(reader, reader.uint32());
|
|
continue;
|
|
case 18:
|
|
if (tag !== 146) break;
|
|
message.toolCallChunk = ToolCallChunkEvent.decode(reader, reader.uint32());
|
|
continue;
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) break;
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
create(base) {
|
|
return Event.fromPartial(base ?? {});
|
|
},
|
|
fromPartial(object) {
|
|
const message = createBaseEvent();
|
|
message.textMessageStart = object.textMessageStart !== void 0 && object.textMessageStart !== null ? TextMessageStartEvent.fromPartial(object.textMessageStart) : void 0;
|
|
message.textMessageContent = object.textMessageContent !== void 0 && object.textMessageContent !== null ? TextMessageContentEvent.fromPartial(object.textMessageContent) : void 0;
|
|
message.textMessageEnd = object.textMessageEnd !== void 0 && object.textMessageEnd !== null ? TextMessageEndEvent.fromPartial(object.textMessageEnd) : void 0;
|
|
message.toolCallStart = object.toolCallStart !== void 0 && object.toolCallStart !== null ? ToolCallStartEvent.fromPartial(object.toolCallStart) : void 0;
|
|
message.toolCallArgs = object.toolCallArgs !== void 0 && object.toolCallArgs !== null ? ToolCallArgsEvent.fromPartial(object.toolCallArgs) : void 0;
|
|
message.toolCallEnd = object.toolCallEnd !== void 0 && object.toolCallEnd !== null ? ToolCallEndEvent.fromPartial(object.toolCallEnd) : void 0;
|
|
message.stateSnapshot = object.stateSnapshot !== void 0 && object.stateSnapshot !== null ? StateSnapshotEvent.fromPartial(object.stateSnapshot) : void 0;
|
|
message.stateDelta = object.stateDelta !== void 0 && object.stateDelta !== null ? StateDeltaEvent.fromPartial(object.stateDelta) : void 0;
|
|
message.messagesSnapshot = object.messagesSnapshot !== void 0 && object.messagesSnapshot !== null ? MessagesSnapshotEvent.fromPartial(object.messagesSnapshot) : void 0;
|
|
message.raw = object.raw !== void 0 && object.raw !== null ? RawEvent.fromPartial(object.raw) : void 0;
|
|
message.custom = object.custom !== void 0 && object.custom !== null ? CustomEvent.fromPartial(object.custom) : void 0;
|
|
message.runStarted = object.runStarted !== void 0 && object.runStarted !== null ? RunStartedEvent.fromPartial(object.runStarted) : void 0;
|
|
message.runFinished = object.runFinished !== void 0 && object.runFinished !== null ? RunFinishedEvent.fromPartial(object.runFinished) : void 0;
|
|
message.runError = object.runError !== void 0 && object.runError !== null ? RunErrorEvent.fromPartial(object.runError) : void 0;
|
|
message.stepStarted = object.stepStarted !== void 0 && object.stepStarted !== null ? StepStartedEvent.fromPartial(object.stepStarted) : void 0;
|
|
message.stepFinished = object.stepFinished !== void 0 && object.stepFinished !== null ? StepFinishedEvent.fromPartial(object.stepFinished) : void 0;
|
|
message.textMessageChunk = object.textMessageChunk !== void 0 && object.textMessageChunk !== null ? TextMessageChunkEvent.fromPartial(object.textMessageChunk) : void 0;
|
|
message.toolCallChunk = object.toolCallChunk !== void 0 && object.toolCallChunk !== null ? ToolCallChunkEvent.fromPartial(object.toolCallChunk) : void 0;
|
|
return message;
|
|
}
|
|
};
|
|
function longToNumber(int64) {
|
|
const num = globalThis.Number(int64.toString());
|
|
if (num > globalThis.Number.MAX_SAFE_INTEGER) throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
|
|
if (num < globalThis.Number.MIN_SAFE_INTEGER) throw new globalThis.Error("Value is smaller than Number.MIN_SAFE_INTEGER");
|
|
return num;
|
|
}
|
|
|
|
//#endregion
|
|
//#region src/proto.ts
|
|
function toCamelCase(str) {
|
|
return str.toLowerCase().replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
|
|
}
|
|
/**
|
|
* Encodes an event message to a protocol buffer binary format.
|
|
*/
|
|
function encode(event) {
|
|
/**
|
|
* In previous versions of AG-UI, we didn't really validate the events
|
|
* against a schema. With stronger types for events and Zod schemas, we
|
|
* can now validate.
|
|
*
|
|
* However, I don't want to break compatibility with existing clients
|
|
* even if they are encoding invalid events. This surfaces a warning
|
|
* to them in those situations.
|
|
*
|
|
* @author mikeryandev
|
|
*/
|
|
let validatedEvent;
|
|
try {
|
|
validatedEvent = EventSchemas.parse(event);
|
|
} catch (err) {
|
|
console.warn("[ag-ui][proto.encode] Malformed devent detected, falling back to unvalidated event", err, event);
|
|
validatedEvent = event;
|
|
}
|
|
const oneofField = toCamelCase(validatedEvent.type);
|
|
const { type, timestamp, rawEvent, ...rest } = validatedEvent;
|
|
if (type === EventType.MESSAGES_SNAPSHOT && Array.isArray(rest.messages)) rest.messages = rest.messages.map((message) => {
|
|
if (message.toolCalls === void 0) return {
|
|
...message,
|
|
toolCalls: []
|
|
};
|
|
return message;
|
|
});
|
|
if (type === EventType.STATE_DELTA && Array.isArray(rest.delta)) rest.delta = rest.delta.map((operation) => ({
|
|
...operation,
|
|
op: JsonPatchOperationType[operation.op.toUpperCase()]
|
|
}));
|
|
const eventMessage = { [oneofField]: {
|
|
baseEvent: {
|
|
type: EventType$1[event.type],
|
|
timestamp,
|
|
rawEvent
|
|
},
|
|
...rest
|
|
} };
|
|
return 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.
|
|
*/
|
|
function decode(data) {
|
|
const event = Event.decode(data);
|
|
const decoded = Object.values(event).find((value) => value !== void 0);
|
|
if (!decoded) throw new Error("Invalid event");
|
|
decoded.type = EventType$1[decoded.baseEvent.type];
|
|
decoded.timestamp = decoded.baseEvent.timestamp;
|
|
decoded.rawEvent = decoded.baseEvent.rawEvent;
|
|
if (decoded.type === EventType.MESSAGES_SNAPSHOT) for (const message of decoded.messages) {
|
|
const untypedMessage = message;
|
|
if (untypedMessage.toolCalls?.length === 0) untypedMessage.toolCalls = void 0;
|
|
}
|
|
if (decoded.type === EventType.STATE_DELTA) for (const operation of decoded.delta) {
|
|
operation.op = JsonPatchOperationType[operation.op].toLowerCase();
|
|
Object.keys(operation).forEach((key) => {
|
|
if (operation[key] === void 0) delete operation[key];
|
|
});
|
|
}
|
|
Object.keys(decoded).forEach((key) => {
|
|
if (decoded[key] === void 0) delete decoded[key];
|
|
});
|
|
return EventSchemas.parse(decoded);
|
|
}
|
|
|
|
//#endregion
|
|
//#region src/index.ts
|
|
const AGUI_MEDIA_TYPE = "application/vnd.ag-ui.event+proto";
|
|
|
|
//#endregion
|
|
export { AGUI_MEDIA_TYPE, decode, encode };
|
|
//# sourceMappingURL=index.mjs.map
|