@fragno-dev/pi-harness 0.0.0-stage → 0.0.3

package/dist/browser/agent-harness-event-protocol-CuKubox1.js

@@ -0,0 +1,666 @@
+//#region src/pi/harness/json-value.ts
+const jsonValueError = (path, reason) => /* @__PURE__ */ new Error(`PI_HARNESS_EVENT_VALUE_NOT_JSON_COMPATIBLE:${path}:${reason}`);
+const snapshotJsonValueAtPath = (value, path, ancestors) => {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) throw jsonValueError(path, "non-finite-number");
+		return value;
+	}
+	if (typeof value !== "object") throw jsonValueError(path, typeof value);
+	if (ancestors.has(value)) throw jsonValueError(path, "cycle");
+	ancestors.add(value);
+	try {
+		if (Array.isArray(value)) {
+			const snapshot = [];
+			for (let index = 0; index < value.length; index += 1) {
+				if (!Object.hasOwn(value, index)) throw jsonValueError(`${path}[${index}]`, "sparse-array-entry");
+				snapshot.push(snapshotJsonValueAtPath(value[index], `${path}[${index}]`, ancestors));
+			}
+			return snapshot;
+		}
+		const prototype = Object.getPrototypeOf(value);
+		if (prototype !== Object.prototype && prototype !== null) throw jsonValueError(path, "non-plain-object");
+		const snapshot = {};
+		for (const key of Object.keys(value)) {
+			const propertyValue = value[key];
+			if (propertyValue === void 0) continue;
+			snapshot[key] = snapshotJsonValueAtPath(propertyValue, `${path}.${key}`, ancestors);
+		}
+		return snapshot;
+	} finally {
+		ancestors.delete(value);
+	}
+};
+/** Validates and detaches a value at the workflow JSON boundary. */
+const snapshotPiHarnessJsonValue = (value, path = "$event") => snapshotJsonValueAtPath(value, path, /* @__PURE__ */ new Set());
+const assertJsonValueAtPath = (value, path, ancestors) => {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return;
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) throw jsonValueError(path, "non-finite-number");
+		return;
+	}
+	if (typeof value !== "object") throw jsonValueError(path, typeof value);
+	if (ancestors.has(value)) throw jsonValueError(path, "cycle");
+	ancestors.add(value);
+	try {
+		if (Array.isArray(value)) {
+			for (let index = 0; index < value.length; index += 1) {
+				if (!Object.hasOwn(value, index)) throw jsonValueError(`${path}[${index}]`, "sparse-array-entry");
+				assertJsonValueAtPath(value[index], `${path}[${index}]`, ancestors);
+			}
+			return;
+		}
+		const prototype = Object.getPrototypeOf(value);
+		if (prototype !== Object.prototype && prototype !== null) throw jsonValueError(path, "non-plain-object");
+		for (const key of Object.keys(value)) {
+			const propertyValue = value[key];
+			if (propertyValue !== void 0) assertJsonValueAtPath(propertyValue, `${path}.${key}`, ancestors);
+		}
+	} finally {
+		ancestors.delete(value);
+	}
+};
+/** Validates persisted protocol input without copying it. */
+const assertPiHarnessJsonValue = (value, path = "$event") => {
+	assertJsonValueAtPath(value, path, /* @__PURE__ */ new Set());
+};
+const freezeJsonValue = (value, visited) => {
+	if (value === null || typeof value !== "object" || visited.has(value)) return;
+	visited.add(value);
+	for (const child of Array.isArray(value) ? value : Object.values(value)) freezeJsonValue(child, visited);
+	Object.freeze(value);
+};
+/** Validates and freezes persisted protocol input so interned references remain immutable. */
+const freezePiHarnessJsonValue = (value, path = "$event") => {
+	assertPiHarnessJsonValue(value, path);
+	freezeJsonValue(value, /* @__PURE__ */ new Set());
+	return value;
+};
+//#endregion
+//#region src/pi/harness/agent-harness-event-protocol.ts
+const piToolCallArgumentsText = (toolCall) => {
+	const partialJson = toolCall.partialJson;
+	return typeof partialJson === "string" ? partialJson : void 0;
+};
+const assistantMessageMetadata = ({ usage, stopReason, errorMessage, timestamp }) => ({
+	usage,
+	stopReason,
+	errorMessage,
+	timestamp
+});
+const compactAssistantMessageMetadataUpdate = (previous, next) => {
+	const update = {
+		...previous.usage.input === next.usage.input && previous.usage.output === next.usage.output && previous.usage.cacheRead === next.usage.cacheRead && previous.usage.cacheWrite === next.usage.cacheWrite && previous.usage.cacheWrite1h === next.usage.cacheWrite1h && previous.usage.reasoning === next.usage.reasoning && previous.usage.totalTokens === next.usage.totalTokens && previous.usage.cost.input === next.usage.cost.input && previous.usage.cost.output === next.usage.cost.output && previous.usage.cost.cacheRead === next.usage.cost.cacheRead && previous.usage.cost.cacheWrite === next.usage.cost.cacheWrite && previous.usage.cost.total === next.usage.cost.total ? {} : { usage: next.usage },
+		...previous.stopReason === next.stopReason ? {} : { stopReason: next.stopReason },
+		...previous.errorMessage === next.errorMessage ? {} : { errorMessage: next.errorMessage ?? null },
+		...previous.timestamp === next.timestamp ? {} : { timestamp: next.timestamp }
+	};
+	return Object.keys(update).length === 0 ? void 0 : update;
+};
+const assistantMessageWithMetadataUpdate = (message, update) => ({
+	...message,
+	...update.usage === void 0 ? {} : { usage: update.usage },
+	...update.stopReason === void 0 ? {} : { stopReason: update.stopReason },
+	...update.errorMessage === void 0 ? {} : update.errorMessage === null ? { errorMessage: void 0 } : { errorMessage: update.errorMessage },
+	...update.timestamp === void 0 ? {} : { timestamp: update.timestamp }
+});
+const streamedMessageUpdateEvent = (event) => {
+	switch (event.type) {
+		case "start":
+		case "done":
+		case "error": throw new Error("PI_HARNESS_EVENT_PROTOCOL_NON_STREAMING_MESSAGE_UPDATE");
+		case "text_start":
+		case "text_delta":
+		case "text_end":
+		case "thinking_start":
+		case "thinking_delta":
+		case "thinking_end":
+		case "toolcall_start":
+		case "toolcall_delta":
+		case "toolcall_end": return event;
+	}
+	throw new Error("PI_HARNESS_EVENT_PROTOCOL_UNKNOWN_MESSAGE_UPDATE");
+};
+const thinkingContentFromPartial = (event) => {
+	const content = event.partial.content[event.contentIndex];
+	if (content?.type !== "thinking") throw new Error("PI_HARNESS_EVENT_PROTOCOL_THINKING_UPDATE_WITHOUT_THINKING_BLOCK");
+	return content;
+};
+const toolCallFromPartial = (event) => {
+	const content = event.partial.content[event.contentIndex];
+	if (content?.type !== "toolCall") throw new Error("PI_HARNESS_EVENT_PROTOCOL_TOOL_CALL_UPDATE_WITHOUT_TOOL_CALL_BLOCK");
+	return content;
+};
+const thinkingMetadataFields = (content) => content.redacted === void 0 ? {} : { redacted: content.redacted };
+const projectToolCall = ({ thoughtSignature: _thoughtSignature, ...toolCall }) => toolCall;
+const projectAssistantMessage = ({ api: _api, provider: _provider, model: _model, responseModel: _responseModel, responseId: _responseId, diagnostics: _diagnostics, content, ...message }) => ({
+	...message,
+	content: content.map((block) => {
+		switch (block.type) {
+			case "text": {
+				const { textSignature: _textSignature, ...text } = block;
+				return text;
+			}
+			case "thinking": {
+				const { thinkingSignature: _thinkingSignature, ...thinking } = block;
+				return thinking;
+			}
+			case "toolCall": return projectToolCall(block);
+		}
+		throw new Error("PI_HARNESS_FRONTEND_PROTOCOL_UNKNOWN_ASSISTANT_CONTENT");
+	})
+});
+const projectAgentMessage = (message) => message.role === "assistant" ? projectAssistantMessage(message) : message;
+const compactAssistantMessageEvent = (event) => {
+	switch (event.type) {
+		case "text_start": return {
+			type: event.type,
+			contentIndex: event.contentIndex
+		};
+		case "text_delta": return {
+			type: event.type,
+			contentIndex: event.contentIndex,
+			delta: event.delta
+		};
+		case "text_end": return {
+			type: event.type,
+			contentIndex: event.contentIndex,
+			content: event.content
+		};
+		case "thinking_start": {
+			const content = thinkingContentFromPartial(event);
+			return {
+				type: event.type,
+				contentIndex: event.contentIndex,
+				...thinkingMetadataFields(content)
+			};
+		}
+		case "thinking_delta": {
+			const content = thinkingContentFromPartial(event);
+			return {
+				type: event.type,
+				contentIndex: event.contentIndex,
+				delta: event.delta,
+				...thinkingMetadataFields(content)
+			};
+		}
+		case "thinking_end": {
+			const content = thinkingContentFromPartial(event);
+			return {
+				type: event.type,
+				contentIndex: event.contentIndex,
+				content: event.content,
+				...thinkingMetadataFields(content)
+			};
+		}
+		case "toolcall_start": return {
+			type: event.type,
+			contentIndex: event.contentIndex,
+			toolCall: projectToolCall(toolCallFromPartial(event))
+		};
+		case "toolcall_delta": return {
+			type: event.type,
+			contentIndex: event.contentIndex,
+			delta: event.delta
+		};
+		case "toolcall_end": return {
+			type: event.type,
+			contentIndex: event.contentIndex,
+			toolCall: projectToolCall(event.toolCall)
+		};
+	}
+	throw new Error("PI_HARNESS_EVENT_PROTOCOL_UNKNOWN_STREAMING_MESSAGE_UPDATE");
+};
+function isPrimitiveOnlyMessageUpdate(event) {
+	if (event.type !== "message_update") return false;
+	if (event.metadata !== void 0) return false;
+	switch (event.update.type) {
+		case "text_start":
+		case "text_delta":
+		case "text_end":
+		case "thinking_start":
+		case "thinking_delta":
+		case "thinking_end":
+		case "toolcall_delta": return true;
+		case "toolcall_start":
+		case "toolcall_end": return false;
+	}
+	throw new Error("PI_HARNESS_EVENT_PROTOCOL_UNKNOWN_COMPACT_MESSAGE_UPDATE");
+}
+const streamedAssistantMessageEvent = (update, partial) => {
+	switch (update.type) {
+		case "text_start":
+		case "thinking_start":
+		case "toolcall_start": return {
+			type: update.type,
+			contentIndex: update.contentIndex,
+			partial
+		};
+		case "text_delta":
+		case "thinking_delta":
+		case "toolcall_delta": return {
+			type: update.type,
+			contentIndex: update.contentIndex,
+			delta: update.delta,
+			partial
+		};
+		case "text_end":
+		case "thinking_end": return {
+			type: update.type,
+			contentIndex: update.contentIndex,
+			content: update.content,
+			partial
+		};
+		case "toolcall_end": return {
+			type: update.type,
+			contentIndex: update.contentIndex,
+			toolCall: update.toolCall,
+			partial
+		};
+	}
+	throw new Error("PI_HARNESS_EVENT_PROTOCOL_UNKNOWN_COMPACT_MESSAGE_UPDATE");
+};
+const applyCompactAssistantMessageEvent = (message, update, toolCallJsonByContentIndex) => {
+	if (update.contentIndex > message.content.length) throw new Error(`PI_HARNESS_EVENT_PROTOCOL_SPARSE_CONTENT_INDEX:${update.contentIndex}`);
+	switch (update.type) {
+		case "text_start":
+			message.content[update.contentIndex] = {
+				type: "text",
+				text: ""
+			};
+			return;
+		case "text_delta": {
+			const content = message.content[update.contentIndex];
+			if (content?.type !== "text") throw new Error("PI_HARNESS_EVENT_PROTOCOL_TEXT_DELTA_WITHOUT_TEXT_BLOCK");
+			message.content[update.contentIndex] = {
+				type: "text",
+				text: content.text + update.delta
+			};
+			return;
+		}
+		case "text_end":
+			message.content[update.contentIndex] = {
+				type: "text",
+				text: update.content
+			};
+			return;
+		case "thinking_start":
+			message.content[update.contentIndex] = {
+				type: "thinking",
+				thinking: "",
+				...update.redacted === void 0 ? {} : { redacted: update.redacted }
+			};
+			return;
+		case "thinking_delta": {
+			const content = message.content[update.contentIndex];
+			if (content?.type !== "thinking") throw new Error("PI_HARNESS_EVENT_PROTOCOL_THINKING_DELTA_WITHOUT_THINKING_BLOCK");
+			message.content[update.contentIndex] = {
+				type: "thinking",
+				thinking: content.thinking + update.delta,
+				...update.redacted === void 0 ? {} : { redacted: update.redacted }
+			};
+			return;
+		}
+		case "thinking_end":
+			message.content[update.contentIndex] = {
+				type: "thinking",
+				thinking: update.content,
+				...update.redacted === void 0 ? {} : { redacted: update.redacted }
+			};
+			return;
+		case "toolcall_start":
+			toolCallJsonByContentIndex.set(update.contentIndex, piToolCallArgumentsText(update.toolCall) ?? "");
+			message.content[update.contentIndex] = update.toolCall;
+			return;
+		case "toolcall_delta": {
+			const content = message.content[update.contentIndex];
+			if (content?.type !== "toolCall") throw new Error("PI_HARNESS_EVENT_PROTOCOL_TOOL_CALL_DELTA_WITHOUT_TOOL_CALL_BLOCK");
+			const previousJson = toolCallJsonByContentIndex.get(update.contentIndex);
+			if (previousJson === void 0) throw new Error("PI_HARNESS_EVENT_PROTOCOL_TOOL_CALL_DELTA_WITHOUT_TOOL_CALL_START");
+			const partialJson = previousJson + update.delta;
+			toolCallJsonByContentIndex.set(update.contentIndex, partialJson);
+			message.content[update.contentIndex] = {
+				...content,
+				partialJson
+			};
+			return;
+		}
+		case "toolcall_end":
+			toolCallJsonByContentIndex.delete(update.contentIndex);
+			message.content[update.contentIndex] = update.toolCall;
+	}
+};
+var ValueEncoder = class {
+	#idsByValue = /* @__PURE__ */ new Map();
+	encode(value) {
+		const existingId = this.#idsByValue.get(value);
+		if (existingId !== void 0) return {
+			kind: "reference",
+			id: existingId
+		};
+		const id = this.#idsByValue.size;
+		this.#idsByValue.set(value, id);
+		return {
+			kind: "value",
+			id,
+			value
+		};
+	}
+};
+var ValueDecoder = class {
+	#valuesById = /* @__PURE__ */ new Map();
+	decode(encoded) {
+		if (encoded.kind === "value") {
+			this.#valuesById.set(encoded.id, encoded.value);
+			return encoded.value;
+		}
+		if (!this.#valuesById.has(encoded.id)) throw new Error(`PI_HARNESS_EVENT_PROTOCOL_UNKNOWN_VALUE_REFERENCE:${encoded.id}`);
+		return this.#valuesById.get(encoded.id);
+	}
+};
+var MessageEncoder = class {
+	#idsByMessage = /* @__PURE__ */ new Map();
+	encode(message) {
+		const existingId = this.#idsByMessage.get(message);
+		if (existingId !== void 0) return {
+			kind: "reference",
+			id: existingId
+		};
+		const id = this.#idsByMessage.size;
+		this.#idsByMessage.set(message, id);
+		return {
+			kind: "message",
+			id,
+			message: projectAgentMessage(message)
+		};
+	}
+};
+var MessageDecoder = class {
+	#messagesById = /* @__PURE__ */ new Map();
+	decode(encoded) {
+		if (encoded.kind === "message") {
+			this.#messagesById.set(encoded.id, encoded.message);
+			return encoded.message;
+		}
+		const message = this.#messagesById.get(encoded.id);
+		if (!message) throw new Error(`PI_HARNESS_EVENT_PROTOCOL_UNKNOWN_MESSAGE_REFERENCE:${encoded.id}`);
+		return message;
+	}
+};
+const piHarnessEventStreamKey = ({ stepKey, executionId, epoch }) => `${stepKey}\u0000${executionId}\u0000${epoch}`;
+function assertPiHarnessEncodedEvent(value) {
+	assertPiHarnessJsonValue(value);
+	if (typeof value !== "object" || value === null || !("protocol" in value) || value.protocol !== "pi-harness-event" || !("version" in value) || value.version !== 2 || !("event" in value) || typeof value.event !== "object" || value.event === null || !("type" in value.event) || typeof value.event.type !== "string") throw new Error("PI_HARNESS_EVENT_PROTOCOL_UNSUPPORTED_PROTOCOL");
+}
+var PiHarnessEventEncoder = class {
+	#messages = new MessageEncoder();
+	#values = new ValueEncoder();
+	#activeAssistantMetadata;
+	encode(event) {
+		const compactEvent = this.#encodeEvent(event);
+		const envelope = {
+			protocol: "pi-harness-event",
+			version: 2,
+			event: compactEvent
+		};
+		const encoded = isPrimitiveOnlyMessageUpdate(compactEvent) ? envelope : snapshotPiHarnessJsonValue(envelope, `$event.${event.type}`);
+		this.#advanceAssistantMetadata(event, compactEvent);
+		return encoded;
+	}
+	#advanceAssistantMetadata(event, compactEvent) {
+		if (event.type === "message_start") this.#activeAssistantMetadata = event.message.role === "assistant" ? snapshotPiHarnessJsonValue(assistantMessageMetadata(event.message)) : void 0;
+		else if (event.type === "message_update") {
+			if (compactEvent.type !== "message_update") throw new Error("PI_HARNESS_EVENT_PROTOCOL_INVALID_COMPACT_MESSAGE_UPDATE");
+			if (compactEvent.metadata === void 0) return;
+			this.#activeAssistantMetadata = snapshotPiHarnessJsonValue(assistantMessageMetadata(event.assistantMessageEvent.partial));
+		} else if (event.type === "message_end") this.#activeAssistantMetadata = void 0;
+	}
+	#encodeEvent(event) {
+		switch (event.type) {
+			case "agent_start":
+			case "turn_start": return { type: event.type };
+			case "agent_end": return {
+				type: event.type,
+				messages: event.messages.map((message) => this.#messages.encode(message))
+			};
+			case "turn_end": return {
+				type: event.type,
+				message: this.#messages.encode(event.message),
+				toolResults: event.toolResults.map((message) => this.#messages.encode(message))
+			};
+			case "message_start": return {
+				type: event.type,
+				message: this.#messages.encode(event.message)
+			};
+			case "message_update": {
+				if (!this.#activeAssistantMetadata) throw new Error("PI_HARNESS_EVENT_PROTOCOL_MESSAGE_UPDATE_WITHOUT_ASSISTANT_START");
+				if (event.message.role !== "assistant") throw new Error("PI_HARNESS_EVENT_PROTOCOL_MESSAGE_UPDATE_NOT_ASSISTANT");
+				const assistantMessageEvent = streamedMessageUpdateEvent(event.assistantMessageEvent);
+				const update = compactAssistantMessageEvent(assistantMessageEvent);
+				const metadata = compactAssistantMessageMetadataUpdate(this.#activeAssistantMetadata, assistantMessageEvent.partial);
+				return {
+					type: event.type,
+					update,
+					...metadata ? { metadata } : {}
+				};
+			}
+			case "message_end": return {
+				type: event.type,
+				message: this.#messages.encode(event.message)
+			};
+			case "tool_execution_start": return {
+				...event,
+				args: this.#values.encode(event.args)
+			};
+			case "tool_execution_update": return {
+				...event,
+				args: this.#values.encode(event.args),
+				partialResult: this.#values.encode(snapshotPiHarnessJsonValue(event.partialResult, "$event.tool_execution_update.partialResult"))
+			};
+			case "tool_execution_end": return {
+				...event,
+				result: this.#values.encode(event.result)
+			};
+			case "queue_update": return {
+				type: event.type,
+				steer: event.steer.map((message) => this.#messages.encode(message)),
+				followUp: event.followUp.map((message) => this.#messages.encode(message)),
+				nextTurn: event.nextTurn.map((message) => this.#messages.encode(message))
+			};
+			case "save_point":
+			case "settled":
+			case "retry_scheduled":
+			case "retry_attempt_start":
+			case "retry_finished":
+			case "thinking_level_update":
+			case "tools_update": return event;
+			case "abort": return {
+				type: event.type,
+				clearedSteer: event.clearedSteer.map((message) => this.#messages.encode(message)),
+				clearedFollowUp: event.clearedFollowUp.map((message) => this.#messages.encode(message))
+			};
+			case "after_provider_response": return {
+				type: event.type,
+				status: event.status,
+				headers: this.#values.encode(event.headers)
+			};
+			case "session_compact": return {
+				type: event.type,
+				compactionEntry: this.#values.encode(event.compactionEntry),
+				fromHook: event.fromHook
+			};
+			case "session_tree": return {
+				type: event.type,
+				newLeafId: event.newLeafId,
+				oldLeafId: event.oldLeafId,
+				...event.summaryEntry ? { summaryEntry: this.#values.encode(event.summaryEntry) } : {},
+				...event.fromHook === void 0 ? {} : { fromHook: event.fromHook }
+			};
+			case "model_update": return {
+				type: event.type,
+				model: this.#values.encode(event.model),
+				...event.previousModel ? { previousModel: this.#values.encode(event.previousModel) } : {},
+				source: event.source
+			};
+			case "resources_update": return {
+				type: event.type,
+				resources: this.#values.encode(event.resources),
+				previousResources: this.#values.encode(event.previousResources)
+			};
+			default: return {
+				type: "raw",
+				event
+			};
+		}
+	}
+};
+const piHarnessEventProtocol = {
+	createEncoder: () => new PiHarnessEventEncoder(),
+	createDecoder: () => new PiHarnessEventDecoder(),
+	eventType: (value) => {
+		assertPiHarnessEncodedEvent(value);
+		return value.event.type === "raw" ? value.event.event.type : value.event.type;
+	}
+};
+var PiHarnessEventDecoder = class {
+	#messages = new MessageDecoder();
+	#values = new ValueDecoder();
+	#toolCallJsonByContentIndex = /* @__PURE__ */ new Map();
+	#activeAssistantMessage;
+	decode(value) {
+		const encoded = freezePiHarnessJsonValue(value);
+		assertPiHarnessEncodedEvent(encoded);
+		return this.#decodeEvent(encoded.event);
+	}
+	#decodeEvent(encoded) {
+		switch (encoded.type) {
+			case "raw": return encoded.event;
+			case "agent_start":
+			case "turn_start": return { type: encoded.type };
+			case "agent_end": return {
+				type: encoded.type,
+				messages: encoded.messages.map((message) => this.#messages.decode(message))
+			};
+			case "turn_end": return {
+				type: encoded.type,
+				message: this.#messages.decode(encoded.message),
+				toolResults: encoded.toolResults.map((message) => this.#messages.decode(message))
+			};
+			case "message_start": {
+				const message = this.#messages.decode(encoded.message);
+				this.#toolCallJsonByContentIndex.clear();
+				this.#activeAssistantMessage = message.role === "assistant" ? message : void 0;
+				return {
+					type: encoded.type,
+					message
+				};
+			}
+			case "message_update": {
+				if (!this.#activeAssistantMessage) throw new Error("PI_HARNESS_EVENT_PROTOCOL_MESSAGE_UPDATE_WITHOUT_ASSISTANT_START");
+				const reconstructedMessage = snapshotPiHarnessJsonValue(this.#activeAssistantMessage);
+				applyCompactAssistantMessageEvent(reconstructedMessage, encoded.update, this.#toolCallJsonByContentIndex);
+				const message = encoded.metadata ? assistantMessageWithMetadataUpdate(reconstructedMessage, encoded.metadata) : reconstructedMessage;
+				this.#activeAssistantMessage = message;
+				return {
+					type: encoded.type,
+					message,
+					assistantMessageEvent: streamedAssistantMessageEvent(encoded.update, message)
+				};
+			}
+			case "message_end": {
+				const message = this.#messages.decode(encoded.message);
+				this.#toolCallJsonByContentIndex.clear();
+				this.#activeAssistantMessage = void 0;
+				return {
+					type: encoded.type,
+					message
+				};
+			}
+			case "tool_execution_start": return {
+				...encoded,
+				args: this.#values.decode(encoded.args)
+			};
+			case "tool_execution_update": return {
+				...encoded,
+				args: this.#values.decode(encoded.args),
+				partialResult: this.#values.decode(encoded.partialResult)
+			};
+			case "tool_execution_end": return {
+				...encoded,
+				result: this.#values.decode(encoded.result)
+			};
+			case "queue_update": return {
+				type: encoded.type,
+				steer: encoded.steer.map((message) => this.#messages.decode(message)),
+				followUp: encoded.followUp.map((message) => this.#messages.decode(message)),
+				nextTurn: encoded.nextTurn.map((message) => this.#messages.decode(message))
+			};
+			case "save_point":
+			case "settled":
+			case "retry_scheduled":
+			case "retry_attempt_start":
+			case "retry_finished":
+			case "thinking_level_update": return encoded;
+			case "tools_update": return {
+				...encoded,
+				toolNames: [...encoded.toolNames],
+				previousToolNames: [...encoded.previousToolNames],
+				activeToolNames: [...encoded.activeToolNames],
+				previousActiveToolNames: [...encoded.previousActiveToolNames]
+			};
+			case "abort": return {
+				type: encoded.type,
+				clearedSteer: encoded.clearedSteer.map((message) => this.#messages.decode(message)),
+				clearedFollowUp: encoded.clearedFollowUp.map((message) => this.#messages.decode(message))
+			};
+			case "after_provider_response": return {
+				type: encoded.type,
+				status: encoded.status,
+				headers: this.#values.decode(encoded.headers)
+			};
+			case "session_compact": return {
+				type: encoded.type,
+				compactionEntry: this.#values.decode(encoded.compactionEntry),
+				fromHook: encoded.fromHook
+			};
+			case "session_tree": return {
+				type: encoded.type,
+				newLeafId: encoded.newLeafId,
+				oldLeafId: encoded.oldLeafId,
+				...encoded.summaryEntry ? { summaryEntry: this.#values.decode(encoded.summaryEntry) } : {},
+				...encoded.fromHook === void 0 ? {} : { fromHook: encoded.fromHook }
+			};
+			case "model_update": return {
+				type: encoded.type,
+				model: this.#values.decode(encoded.model),
+				previousModel: encoded.previousModel ? this.#values.decode(encoded.previousModel) : void 0,
+				source: encoded.source
+			};
+			case "resources_update": return {
+				type: encoded.type,
+				resources: this.#values.decode(encoded.resources),
+				previousResources: this.#values.decode(encoded.previousResources)
+			};
+		}
+		throw new Error("PI_HARNESS_EVENT_PROTOCOL_UNKNOWN_EVENT");
+	}
+};
+var PiHarnessEventStreamDecoders = class {
+	#decodersByStream = /* @__PURE__ */ new Map();
+	start(identity) {
+		this.#decodersByStream.set(piHarnessEventStreamKey(identity), new PiHarnessEventDecoder());
+	}
+	finish(identity) {
+		this.#decodersByStream.delete(piHarnessEventStreamKey(identity));
+	}
+	decode(identity, event) {
+		const streamKey = piHarnessEventStreamKey(identity);
+		const decoder = this.#decodersByStream.get(streamKey);
+		if (!decoder) throw new Error(`Pi harness event stream ${JSON.stringify(streamKey)} was not started.`);
+		return decoder.decode(event);
+	}
+};
+//#endregion
+export { piToolCallArgumentsText as a, piHarnessEventProtocol as i, PiHarnessEventEncoder as n, PiHarnessEventStreamDecoders as r, PiHarnessEventDecoder as t };
+
+//# sourceMappingURL=agent-harness-event-protocol-CuKubox1.js.map