@fragno-dev/pi-fragment 0.0.1 → 0.0.3

package/dist/browser/index.js

@@ -1,3 +1,802 @@
-import { a as createPiWorkflows, c as SESSION_STATUSES, d as piFragmentDefinition, i as PI_WORKFLOW_NAME, l as STEERING_MODES, n as createPi, o as createPiFragmentClients, r as defineAgent, s as piRoutesFactory, t as createPiFragment, u as THINKING_LEVELS } from "./factory-DKoO_lRA.js";
+import { a as STEERING_MODES, c as piFragmentDefinition, i as SESSION_STATUSES, n as createPiSessionStore, o as THINKING_LEVELS, r as piRoutesFactory, s as PiLogger, t as createPiFragmentClients } from "./clients-BscY_HVe.js";
+import { z } from "zod";
+import { NonRetryableError, defineWorkflow } from "@fragno-dev/workflows";
+import { column, idColumn, schema } from "@fragno-dev/db/schema";
+import { Agent } from "@mariozechner/pi-agent-core";
 
-export { PI_WORKFLOW_NAME, SESSION_STATUSES, STEERING_MODES, THINKING_LEVELS, createPi, createPiFragment, createPiFragmentClients, createPiWorkflows, defineAgent, piFragmentDefinition, piRoutesFactory };
+//#region src/schema.ts
+const piSchema = schema("pi-fragment", (s) => {
+	return s.addTable("session", (t) => {
+		return t.addColumn("id", idColumn()).addColumn("name", column("string").nullable()).addColumn("agent", column("string")).addColumn("status", column("string")).addColumn("steeringMode", column("string")).addColumn("metadata", column("json").nullable()).addColumn("tags", column("json").nullable()).addColumn("createdAt", column("timestamp").defaultTo((b) => b.now())).addColumn("updatedAt", column("timestamp").defaultTo((b) => b.now())).createIndex("idx_session_status", ["status"]).createIndex("idx_session_created", ["createdAt"]);
+	});
+});
+
+//#endregion
+//#region src/pi/mappers.ts
+const normalizeSteeringMode = (value) => {
+	return STEERING_MODES.includes(value) ? value : "one-at-a-time";
+};
+const extractAssistantText = (messages) => {
+	const lastAssistant = [...messages].reverse().find((message) => {
+		return typeof message === "object" && message !== null && "role" in message && message.role === "assistant";
+	});
+	if (!lastAssistant || typeof lastAssistant !== "object") return "";
+	const content = lastAssistant.content;
+	if (!Array.isArray(content)) return "";
+	return content.filter((block) => typeof block === "object" && block !== null && block.type === "text").map((block) => block.text ?? "").join("").trim();
+};
+const extractAssistantTextFromMessage = (message) => {
+	if (!message) return "";
+	return extractAssistantText([message]);
+};
+
+//#endregion
+//#region src/pi/workflow/active-session.ts
+const WAIT_FOR_USER_TIMEOUT_MS$1 = 3600 * 1e3;
+const buildWaitingForUser$1 = (turn) => ({
+	type: "user_message",
+	turn,
+	stepKey: `waitForEvent:wait-user-${turn}`,
+	timeoutMs: WAIT_FOR_USER_TIMEOUT_MS$1
+});
+const getActiveSessionReplayBuffer = (state) => {
+	const replayBuffer = state.activeSessionUpdatesByTurn;
+	return Array.isArray(replayBuffer) ? structuredClone(replayBuffer) : [];
+};
+const createPiActiveSessionState = (options) => {
+	const listeners = /* @__PURE__ */ new Set();
+	const updatesByTurn = /* @__PURE__ */ new Map();
+	const trimPreviousTurns = (turn) => {
+		for (const previousTurn of updatesByTurn.keys()) if (previousTurn < turn - 1) updatesByTurn.delete(previousTurn);
+	};
+	const appendUpdate = (turn, update) => {
+		const existing = updatesByTurn.get(turn) ?? [];
+		updatesByTurn.set(turn, [...existing, structuredClone(update)]);
+		trimPreviousTurns(turn);
+	};
+	const exportReplayBuffer = () => structuredClone([...updatesByTurn.entries()].sort(([leftTurn], [rightTurn]) => leftTurn - rightTurn).map(([turn, updates]) => ({
+		turn,
+		updates
+	})));
+	const syncReplayBuffer = () => {
+		options?.onReplayBufferChange?.(exportReplayBuffer());
+	};
+	const importReplayBuffer = (buffer) => {
+		updatesByTurn.clear();
+		for (const entry of structuredClone(buffer)) for (const update of entry.updates) appendUpdate(entry.turn, update);
+		syncReplayBuffer();
+	};
+	if (options?.replayBuffer) importReplayBuffer(options.replayBuffer);
+	const notify = (update) => {
+		for (const listener of Array.from(listeners)) try {
+			listener(update);
+		} catch (error) {
+			console.warn("Pi active-session listener failed.", {
+				error,
+				updateType: update.type
+			});
+		}
+	};
+	return {
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		publishEvent(turn, event) {
+			const update = {
+				type: "event",
+				turn,
+				event
+			};
+			appendUpdate(turn, update);
+			syncReplayBuffer();
+			notify(update);
+		},
+		settleTurn(turn, status) {
+			const update = {
+				type: "settled",
+				turn,
+				status
+			};
+			appendUpdate(turn, update);
+			syncReplayBuffer();
+			notify(update);
+		},
+		replayTurn(turn) {
+			return structuredClone(updatesByTurn.get(turn) ?? []);
+		},
+		exportReplayBuffer,
+		importReplayBuffer,
+		listenerCount: () => listeners.size
+	};
+};
+const createInitialPiAgentLoopState = (messages = []) => ({
+	messages,
+	events: [],
+	trace: [],
+	summaries: [],
+	turn: 0,
+	phase: "waiting-for-user",
+	waitingFor: buildWaitingForUser$1(0),
+	activeSessionUpdatesByTurn: []
+});
+const ensurePiActiveSessionState = (state) => {
+	if (state.activeSession) return state.activeSession;
+	const activeSession = createPiActiveSessionState({
+		replayBuffer: getActiveSessionReplayBuffer(state),
+		onReplayBufferChange: (replayBuffer) => {
+			state.activeSessionUpdatesByTurn = replayBuffer;
+		}
+	});
+	state.activeSessionUpdatesByTurn = activeSession.exportReplayBuffer();
+	state.activeSession = activeSession;
+	return activeSession;
+};
+
+//#endregion
+//#region src/pi/types.ts
+const PI_TOOL_JOURNAL_VERSION = 1;
+
+//#endregion
+//#region src/pi/workflow/tool-journal.ts
+const isRecord = (value) => typeof value === "object" && value !== null;
+const TOOL_JOURNAL_FIELD = "toolJournal";
+const persistedToolResultContentSchema = z.union([z.object({
+	type: z.literal("text"),
+	text: z.string(),
+	textSignature: z.string().optional()
+}), z.object({
+	type: z.literal("image"),
+	data: z.string(),
+	mimeType: z.string()
+})]);
+const persistedToolResultSchema = z.object({
+	content: z.array(persistedToolResultContentSchema),
+	details: z.unknown()
+});
+const persistedToolCallSchema = z.object({
+	version: z.literal(PI_TOOL_JOURNAL_VERSION),
+	key: z.string(),
+	sessionId: z.string(),
+	turnId: z.string(),
+	toolCallId: z.string(),
+	toolName: z.string(),
+	args: z.record(z.string(), z.unknown()),
+	result: persistedToolResultSchema,
+	isError: z.boolean(),
+	source: z.enum(["executed", "replay"]),
+	capturedAt: z.number().finite(),
+	seq: z.number().int().nonnegative()
+});
+const formatToolJournalIssueLocation = (location, issue) => {
+	if (issue.path.length === 0) return location;
+	return `${location}.${issue.path.join(".")}`;
+};
+const buildStableToolCallKey = (sessionId, turnId, toolCallId) => `${sessionId}:${turnId}:${toolCallId}`;
+const compareToolJournalEntries = (a, b) => a.seq !== b.seq ? a.seq - b.seq : a.capturedAt - b.capturedAt;
+const clonePersistedToolCall = (entry) => structuredClone(entry);
+const buildToolErrorResult = (error) => ({
+	content: [{
+		type: "text",
+		text: error instanceof Error ? error.message : String(error)
+	}],
+	details: {}
+});
+const extractToolErrorMessage = (result) => {
+	for (const block of result.content) if (block.type === "text") return block.text;
+	return "Tool execution failed";
+};
+const createPersistedToolCall = (options) => ({
+	version: PI_TOOL_JOURNAL_VERSION,
+	key: buildStableToolCallKey(options.sessionId, options.turnId, options.toolCallId),
+	sessionId: options.sessionId,
+	turnId: options.turnId,
+	toolCallId: options.toolCallId,
+	toolName: options.toolName,
+	args: options.args,
+	result: options.result,
+	isError: options.isError,
+	source: options.source,
+	capturedAt: Date.now(),
+	seq: options.seq
+});
+const parsePersistedToolCall = (value, location) => {
+	if (!isRecord(value) || Array.isArray(value)) throw new NonRetryableError(`Invalid tool journal entry at ${location}.`);
+	if (value["version"] !== PI_TOOL_JOURNAL_VERSION) throw new NonRetryableError(`Unsupported tool journal version at ${location}: ${String(value["version"])}`);
+	const parsed = persistedToolCallSchema.safeParse(value);
+	if (!parsed.success) {
+		const issue = parsed.error.issues[0];
+		throw new NonRetryableError(`Invalid tool journal entry at ${formatToolJournalIssueLocation(location, issue)}: ${issue.message}`);
+	}
+	return parsed.data;
+};
+const parsePersistedToolJournal = (assistantResult, stepName) => {
+	if (!isRecord(assistantResult) || Array.isArray(assistantResult)) throw new NonRetryableError(`Assistant step ${stepName} returned an invalid result object.`);
+	if (!(TOOL_JOURNAL_FIELD in assistantResult)) return [];
+	const raw = assistantResult[TOOL_JOURNAL_FIELD];
+	if (!Array.isArray(raw)) throw new NonRetryableError(`Assistant step ${stepName} contains an invalid tool journal.`);
+	return raw.map((entry, index) => parsePersistedToolCall(entry, `${stepName}[${index}]`));
+};
+const hydrateReplayCache = (cache, entries) => {
+	const sorted = [...entries].sort(compareToolJournalEntries);
+	for (const entry of sorted) {
+		if (entry.source === "replay" && cache.has(entry.key)) continue;
+		cache.set(entry.key, clonePersistedToolCall(entry));
+	}
+};
+const reduceBashSideEffects = (state, entry) => {
+	const details = isRecord(entry.result.details) ? entry.result.details : {};
+	const base = isRecord(state) ? state : {};
+	const next = {
+		cwd: typeof details.cwd === "string" ? details.cwd : typeof base.cwd === "string" ? base.cwd : "/",
+		files: isRecord(base.files) && !Array.isArray(base.files) ? { ...base.files } : {}
+	};
+	const detailsFiles = isRecord(details.files) && !Array.isArray(details.files) ? details.files : null;
+	if (detailsFiles) for (const [path, value] of Object.entries(detailsFiles)) next.files[path] = value;
+	if (Array.isArray(details.writes)) for (const item of details.writes) {
+		if (!isRecord(item)) continue;
+		const writeEntry = item;
+		const path = typeof writeEntry.path === "string" ? writeEntry.path : null;
+		if (!path) continue;
+		next.files[path] = typeof writeEntry.content === "string" ? writeEntry.content : "";
+	}
+	const deletes = Array.isArray(details.deletes) ? details.deletes : Array.isArray(details.deletedPaths) ? details.deletedPaths : [];
+	for (const path of deletes) if (typeof path === "string") delete next.files[path];
+	return next;
+};
+const buildSideEffectState = (options) => {
+	const reducers = {
+		bash: reduceBashSideEffects,
+		...options.reducers
+	};
+	const state = {};
+	const journal = [...options.cache.values()].sort(compareToolJournalEntries);
+	for (const entry of journal) {
+		const reducer = reducers[entry.toolName];
+		if (!reducer) continue;
+		try {
+			state[entry.toolName] = reducer(state[entry.toolName], entry, {
+				key: entry.key,
+				sessionId: entry.sessionId,
+				turnId: entry.turnId
+			});
+		} catch (error) {
+			throw new NonRetryableError(`Tool side-effect reducer failed for ${entry.toolName}: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	return state;
+};
+const replaySequenceByContext = /* @__PURE__ */ new WeakMap();
+const takeNextReplaySequence = (replayContext) => {
+	const current = replaySequenceByContext.get(replayContext) ?? 0;
+	replaySequenceByContext.set(replayContext, current + 1);
+	return current;
+};
+const createReplayContext = (options) => {
+	const localCache = /* @__PURE__ */ new Map();
+	for (const [key, entry] of options.cache.entries()) localCache.set(key, clonePersistedToolCall(entry));
+	const replayContext = {
+		cache: localCache,
+		journal: [],
+		sideEffects: buildSideEffectState({
+			cache: localCache,
+			reducers: options.reducers
+		})
+	};
+	const maxSeq = [...localCache.values()].reduce((max, entry) => entry.seq > max ? entry.seq : max, -1);
+	replaySequenceByContext.set(replayContext, maxSeq + 1);
+	return replayContext;
+};
+
+//#endregion
+//#region src/pi/workflow/agent-runner.ts
+const isAssistantLikeMessage = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && value.role === "assistant" && Array.isArray(value.content) && typeof value.stopReason === "string";
+const buildStreamErrorAssistantMessage = (model, error) => ({
+	role: "assistant",
+	content: [{
+		type: "text",
+		text: ""
+	}],
+	api: model.api,
+	provider: model.provider,
+	model: model.id,
+	usage: {
+		input: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		totalTokens: 0,
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			total: 0
+		}
+	},
+	stopReason: "error",
+	errorMessage: error instanceof Error ? error.message : String(error),
+	timestamp: Date.now()
+});
+const wrapStreamFn = (streamFn) => streamFn ? async (...args) => {
+	const [model] = args;
+	const stream = await streamFn(...args);
+	if (typeof stream !== "object" || stream === null || Array.isArray(stream)) return stream;
+	const response = stream;
+	if (typeof response.result !== "function") return stream;
+	const originalResult = response.result.bind(stream);
+	let streamResultError;
+	response.result = async () => {
+		if (streamResultError) throw streamResultError;
+		try {
+			const result = await originalResult();
+			if (isAssistantLikeMessage(result)) return result;
+			streamResultError = /* @__PURE__ */ new Error("Stream result is not a valid assistant message.");
+		} catch (error) {
+			streamResultError = error;
+		}
+		const errorMessage = buildStreamErrorAssistantMessage(model, streamResultError);
+		if ("push" in stream && typeof stream.push === "function") stream.push({
+			type: "error",
+			reason: "error",
+			error: errorMessage
+		});
+		return errorMessage;
+	};
+	return stream;
+} : void 0;
+const resolveTool = async (name, factory, context) => {
+	if (!factory) throw new NonRetryableError(`Tool ${name} not found.`);
+	if (typeof factory === "function") {
+		const tool = await factory(context);
+		if (!tool) throw new NonRetryableError(`Tool ${name} returned no definition.`);
+		return tool;
+	}
+	return factory;
+};
+const wrapToolWithReplay = (options) => ({
+	...options.tool,
+	execute: async (toolCallId, params, signal, onUpdate) => {
+		const sessionId = options.context.session.id;
+		const toolCallIdValue = String(toolCallId);
+		const key = buildStableToolCallKey(sessionId, options.context.turnId, toolCallIdValue);
+		const replayEntry = options.context.replay.cache.get(key);
+		if (replayEntry) {
+			options.context.replay.journal.push(clonePersistedToolCall({
+				...replayEntry,
+				source: "replay",
+				seq: takeNextReplaySequence(options.context.replay)
+			}));
+			PiLogger.debug("tool replay hit", {
+				sessionId,
+				turnId: options.context.turnId,
+				toolName: replayEntry.toolName,
+				key
+			});
+			if (replayEntry.isError) throw new Error(extractToolErrorMessage(replayEntry.result));
+			return structuredClone(replayEntry.result);
+		}
+		const argsSnapshot = structuredClone(params);
+		const recordResult = (result, isError) => {
+			const entry = createPersistedToolCall({
+				sessionId,
+				turnId: options.context.turnId,
+				toolCallId: toolCallIdValue,
+				toolName: options.toolName,
+				args: argsSnapshot,
+				result,
+				isError,
+				source: "executed",
+				seq: takeNextReplaySequence(options.context.replay)
+			});
+			options.context.replay.cache.set(entry.key, clonePersistedToolCall(entry));
+			options.context.replay.journal.push(clonePersistedToolCall(entry));
+			return entry;
+		};
+		try {
+			const result = await options.tool.execute(toolCallId, params, signal, onUpdate);
+			recordResult(structuredClone(result), false);
+			return result;
+		} catch (error) {
+			recordResult(buildToolErrorResult(error), true);
+			throw error;
+		}
+	}
+});
+const resolveTools = async (options) => {
+	const toolNames = options.agent.tools ?? [];
+	if (toolNames.length === 0) return [];
+	const context = {
+		session: options.session,
+		turnId: options.turnId,
+		toolConfig: options.agent.toolConfig ?? null,
+		messages: options.messages,
+		replay: options.replay
+	};
+	const resolved = [];
+	for (const name of toolNames) {
+		const tool = await resolveTool(name, options.tools[name], context);
+		resolved.push(wrapToolWithReplay({
+			toolName: name,
+			tool,
+			context
+		}));
+	}
+	return resolved;
+};
+const findLastAssistantMessage = (messages) => messages.findLast((m) => m.role === "assistant") ?? null;
+const createAgent = async (options) => {
+	const now = /* @__PURE__ */ new Date();
+	const session = {
+		id: options.params.sessionId,
+		name: null,
+		status: "active",
+		agent: options.params.agentName,
+		steeringMode: options.steeringMode,
+		metadata: null,
+		tags: [],
+		createdAt: now,
+		updatedAt: now
+	};
+	const agentTools = await resolveTools({
+		agent: options.agent,
+		tools: options.tools,
+		session,
+		turnId: options.turnId,
+		messages: options.messages,
+		replay: options.replay
+	});
+	const initialState = {
+		systemPrompt: options.params.systemPrompt ?? options.agent.systemPrompt,
+		model: options.agent.model,
+		tools: agentTools,
+		messages: options.messages
+	};
+	if (options.agent.thinkingLevel) initialState.thinkingLevel = options.agent.thinkingLevel;
+	const agent = new Agent({
+		initialState,
+		streamFn: wrapStreamFn(options.agent.streamFn),
+		convertToLlm: options.agent.convertToLlm,
+		transformContext: options.agent.transformContext,
+		getApiKey: options.agent.getApiKey,
+		thinkingBudgets: options.agent.thinkingBudgets,
+		maxRetryDelayMs: options.agent.maxRetryDelayMs,
+		sessionId: options.params.sessionId
+	});
+	agent.setSteeringMode(options.steeringMode);
+	const trace = [];
+	const unsubscribe = agent.subscribe((event) => {
+		trace.push(event);
+		options.onEvent?.(event);
+		if (!options.agent.onEvent) return;
+		try {
+			options.agent.onEvent(event, {
+				sessionId: options.params.sessionId,
+				turnId: options.turnId
+			});
+		} catch (error) {
+			console.warn("Agent onEvent hook failed.", {
+				error,
+				sessionId: options.params.sessionId,
+				turnId: options.turnId,
+				agent: options.agent.name
+			});
+		}
+	});
+	try {
+		await agent.continue();
+	} finally {
+		unsubscribe();
+	}
+	const assistant = findLastAssistantMessage(agent.state.messages);
+	const stateError = agent.state.error;
+	if (stateError) throw stateError instanceof Error ? stateError : new Error(String(stateError));
+	if (assistant && "errorMessage" in assistant && typeof assistant.errorMessage === "string") throw new Error(assistant.errorMessage);
+	return {
+		agent,
+		trace,
+		assistant,
+		toolJournal: options.replay.journal.map(clonePersistedToolCall)
+	};
+};
+const runAgentTurn = async (options) => {
+	const result = await createAgent(options);
+	return {
+		messages: result.agent.state.messages,
+		trace: result.trace,
+		assistant: result.assistant,
+		toolJournal: result.toolJournal
+	};
+};
+
+//#endregion
+//#region src/pi/workflow/workflow.ts
+const PI_WORKFLOW_NAME = "agent-loop-workflow";
+const WAIT_FOR_USER_TIMEOUT = "1 hour";
+const WAIT_FOR_USER_TIMEOUT_MS = 3600 * 1e3;
+const agentLoopParamsSchema = z.object({
+	sessionId: z.string(),
+	agentName: z.string(),
+	systemPrompt: z.string().optional(),
+	initialMessages: z.array(z.custom()).optional()
+});
+const userMessageSchema = z.object({
+	text: z.string().optional(),
+	done: z.boolean().optional(),
+	steeringMode: z.enum(["all", "one-at-a-time"]).optional()
+});
+const buildWaitingForUser = (turn) => ({
+	type: "user_message",
+	turn,
+	stepKey: `waitForEvent:wait-user-${turn}`,
+	timeoutMs: WAIT_FOR_USER_TIMEOUT_MS
+});
+const initLoopState = (params, existingState) => {
+	const activeSession = existingState ? ensurePiActiveSessionState(existingState) : createPiActiveSessionState();
+	return {
+		messages: Array.isArray(params.initialMessages) ? params.initialMessages : [],
+		events: [],
+		trace: [],
+		summaries: [],
+		turn: 0,
+		phase: "waiting-for-user",
+		waitingFor: buildWaitingForUser(0),
+		replayCache: /* @__PURE__ */ new Map(),
+		activeSession
+	};
+};
+const setPhase = (loop, phase) => {
+	loop.phase = phase;
+	switch (phase) {
+		case "waiting-for-user":
+			loop.waitingFor = buildWaitingForUser(loop.turn);
+			break;
+		case "running-agent":
+			loop.waitingFor = {
+				type: "assistant",
+				turn: loop.turn,
+				stepKey: `do:assistant-${loop.turn}`
+			};
+			break;
+		case "complete":
+			loop.waitingFor = null;
+			break;
+	}
+};
+const emitState = (ctx, loop) => {
+	ctx?.setState({
+		messages: loop.messages,
+		events: loop.events,
+		trace: loop.trace,
+		summaries: loop.summaries,
+		turn: loop.turn,
+		phase: loop.phase,
+		waitingFor: loop.waitingFor,
+		activeSession: loop.activeSession,
+		activeSessionUpdatesByTurn: loop.activeSession.exportReplayBuffer()
+	});
+};
+const mutateSessionStatus = (forSchema, sessionId, status) => {
+	try {
+		forSchema(piSchema).update("session", sessionId, (builder) => builder.set({ status }));
+	} catch {}
+};
+const projectSessionStatus = (tx, sessionId, status) => {
+	tx.mutate(({ forSchema }) => {
+		mutateSessionStatus(forSchema, sessionId, status);
+	});
+};
+const buildDetailEvent = (turn, event) => {
+	const timestamp = event.timestamp instanceof Date ? event.timestamp : new Date(event.timestamp);
+	return {
+		id: `${event.type}:${turn}:${timestamp.getTime()}`,
+		type: event.type,
+		payload: event.payload ?? null,
+		createdAt: timestamp,
+		deliveredAt: timestamp,
+		consumedByStepKey: `waitForEvent:wait-user-${turn}`
+	};
+};
+const buildTurnSummary = (turn, assistant) => {
+	if (!assistant) return null;
+	return {
+		turn,
+		assistant,
+		summary: extractAssistantTextFromMessage(assistant) || null
+	};
+};
+const parseAssistantStepResult = (value, stepName) => {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new NonRetryableError(`Assistant step ${stepName} returned an invalid result.`);
+	const result = value;
+	if (!Array.isArray(result.messages)) throw new NonRetryableError(`Assistant step ${stepName} is missing messages.`);
+	const messages = result.messages;
+	return {
+		messages,
+		trace: Array.isArray(result.trace) ? result.trace : [],
+		assistant: (result.assistant && typeof result.assistant === "object" ? result.assistant : null) ?? messages.findLast((m) => m.role === "assistant") ?? null,
+		toolJournal: parsePersistedToolJournal(value, stepName)
+	};
+};
+const createPiAgentLoopWorkflow = (options) => defineWorkflow({
+	name: PI_WORKFLOW_NAME,
+	schema: agentLoopParamsSchema,
+	initialState: createInitialPiAgentLoopState()
+}, async function(event, step) {
+	const params = agentLoopParamsSchema.parse(event.payload ?? {});
+	const agentDefinition = options.agents[params.agentName];
+	if (!agentDefinition) throw new NonRetryableError(`Agent ${params.agentName} not found.`);
+	const loop = initLoopState(params, this?.getState());
+	emitState(this, loop);
+	while (true) {
+		setPhase(loop, "waiting-for-user");
+		emitState(this, loop);
+		const userEvent = await step.waitForEvent(`wait-user-${loop.turn}`, {
+			type: "user_message",
+			timeout: WAIT_FOR_USER_TIMEOUT
+		});
+		const userPayload = userMessageSchema.parse(userEvent.payload ?? {});
+		const userText = userPayload.text ?? "";
+		const isDone = userPayload.done ?? false;
+		const steeringMode = normalizeSteeringMode(userPayload.steeringMode);
+		loop.events = [...loop.events, buildDetailEvent(loop.turn, userEvent)];
+		loop.messages = (await step.do(`user-${loop.turn}`, async (tx) => {
+			projectSessionStatus(tx, event.instanceId, "active");
+			const userMessage = {
+				role: "user",
+				content: [{
+					type: "text",
+					text: userText
+				}],
+				timestamp: Date.now()
+			};
+			return { messages: [...loop.messages, userMessage] };
+		})).messages;
+		setPhase(loop, "running-agent");
+		emitState(this, loop);
+		const replay = createReplayContext({
+			cache: loop.replayCache,
+			reducers: options.toolSideEffectReducers
+		});
+		const assistantStepName = `assistant-${loop.turn}`;
+		const traceLengthBeforeTurn = loop.trace.length;
+		const turnId = `${event.instanceId}:${loop.turn}`;
+		let assistantResult;
+		try {
+			assistantResult = await step.do(assistantStepName, { retries: {
+				limit: 1,
+				delay: "0 ms",
+				backoff: "constant"
+			} }, async (tx) => {
+				tx.onTerminalError.mutate(({ forSchema }) => {
+					mutateSessionStatus(forSchema, event.instanceId, "errored");
+				});
+				const result = await runAgentTurn({
+					params,
+					agent: agentDefinition,
+					tools: options.tools,
+					messages: loop.messages,
+					steeringMode,
+					turnId,
+					replay,
+					onEvent: (agentEvent) => {
+						loop.trace = [...loop.trace, agentEvent];
+						loop.activeSession.publishEvent(loop.turn, agentEvent);
+						emitState(this, loop);
+					}
+				});
+				projectSessionStatus(tx, event.instanceId, isDone ? "complete" : "waiting");
+				return result;
+			});
+		} catch (error) {
+			if (!(error instanceof Error && error.name === "RunnerStepSuspended")) {
+				loop.activeSession.settleTurn(loop.turn, "errored");
+				emitState(this, loop);
+			}
+			throw error;
+		}
+		const parsed = parseAssistantStepResult(assistantResult, assistantStepName);
+		loop.messages = parsed.messages;
+		loop.trace = [...loop.trace.slice(0, traceLengthBeforeTurn), ...parsed.trace];
+		const summary = buildTurnSummary(loop.turn, parsed.assistant);
+		if (summary) loop.summaries = [...loop.summaries, summary];
+		hydrateReplayCache(loop.replayCache, parsed.toolJournal);
+		if (isDone) {
+			setPhase(loop, "complete");
+			loop.activeSession.settleTurn(loop.turn, "complete");
+			emitState(this, loop);
+			return { messages: loop.messages };
+		}
+		loop.activeSession.settleTurn(loop.turn, "waiting-for-user");
+		loop.turn += 1;
+		emitState(this, loop);
+	}
+});
+const createPiWorkflows = (options) => {
+	PiLogger.reset();
+	if (options.logging) PiLogger.configure(options.logging);
+	return { agentLoop: createPiAgentLoopWorkflow(options) };
+};
+
+//#endregion
+//#region src/pi/dsl.ts
+const defineAgent = (name, definition) => {
+	if (definition.name && definition.name !== name) throw new Error(`defineAgent name mismatch: expected ${name}, got ${definition.name}`);
+	return {
+		...definition,
+		name
+	};
+};
+const createPi = () => {
+	const agents = {};
+	const tools = {};
+	const toolSideEffectReducers = {};
+	let defaultSteeringMode;
+	let logging;
+	const builder = {
+		agent(definition) {
+			agents[definition.name] = definition;
+			return builder;
+		},
+		agents(registry) {
+			Object.assign(agents, registry);
+			return builder;
+		},
+		tool(name, tool) {
+			tools[name] = tool;
+			return builder;
+		},
+		tools(registry) {
+			Object.assign(tools, registry);
+			return builder;
+		},
+		toolSideEffectReducer(toolName, reducer) {
+			toolSideEffectReducers[toolName] = reducer;
+			return builder;
+		},
+		toolSideEffectReducers(registry) {
+			Object.assign(toolSideEffectReducers, registry);
+			return builder;
+		},
+		defaultSteeringMode(mode) {
+			defaultSteeringMode = mode;
+			return builder;
+		},
+		logging(config) {
+			logging = config;
+			return builder;
+		},
+		build() {
+			const agentsSnapshot = { ...agents };
+			const toolsSnapshot = { ...tools };
+			const reducersSnapshot = { ...toolSideEffectReducers };
+			return {
+				config: {
+					agents: agentsSnapshot,
+					tools: toolsSnapshot,
+					defaultSteeringMode,
+					toolSideEffectReducers: reducersSnapshot,
+					logging
+				},
+				workflows: createPiWorkflows({
+					agents: agentsSnapshot,
+					tools: toolsSnapshot,
+					toolSideEffectReducers: reducersSnapshot,
+					logging
+				})
+			};
+		}
+	};
+	return builder;
+};
+
+//#endregion
+//#region src/pi/factory.ts
+function createPiFragment(config, options, services) {
+	return {};
+}
+
+//#endregion
+export { PI_TOOL_JOURNAL_VERSION, PI_WORKFLOW_NAME, SESSION_STATUSES, STEERING_MODES, THINKING_LEVELS, createPi, createPiFragment, createPiFragmentClients, createPiSessionStore, createPiWorkflows, defineAgent, piFragmentDefinition, piRoutesFactory };
+//# sourceMappingURL=index.js.map