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