@flue/sdk 0.4.1 → 0.5.1

package/dist/{session-CFOByKnM.mjs → session-BQULcLE9.mjs}

@@ -1,10 +1,33 @@
 import { a as buildSkillByPathPrompt, c as createTools, f as resolveSkillFilePath, i as buildSkillByNamePrompt, l as formatBashResult, n as buildPromptText, o as createResultTools, p as skillsDirIn, r as buildResultFollowUpPrompt, s as BUILTIN_TOOL_NAMES, t as ResultUnavailableError } from "./result-K1IRhWKM.mjs";
-import { i as getRegisteredApiKey, r as getProviderConfiguration } from "./providers-DeFRIwp0.mjs";
+import { i as getRegisteredApiKey, l as generateOperationId, r as getProviderConfiguration } from "./providers-BjEEoKLy.mjs";
 import { n as createCallHandle, t as abortErrorFor } from "./abort-Bg3qsAkU.mjs";
 import { createFlueFs } from "./sandbox.mjs";
 import { completeSimple, isContextOverflow } from "@mariozechner/pi-ai";
 import { Agent } from "@mariozechner/pi-agent-core";
 
+//#region src/roles.ts
+function assertRoleExists(roles, roleName) {
+	if (!roleName) return;
+	if (roles[roleName]) return;
+	const available = Object.keys(roles);
+	const list = available.length > 0 ? available.join(", ") : "(none defined)";
+	throw new Error(`[flue] Role "${roleName}" not registered. Available roles: ${list}. Define roles as markdown files in \`roles/\` (or \`.flue/roles/\` if your root uses the .flue/ source layout).`);
+}
+function resolveEffectiveRole(options) {
+	const role = options.callRole ?? options.sessionRole ?? options.agentRole;
+	assertRoleExists(options.roles, role);
+	return role;
+}
+function resolveRoleModel(roles, roleName) {
+	assertRoleExists(roles, roleName);
+	return roleName ? roles[roleName]?.model : void 0;
+}
+function resolveRoleThinkingLevel(roles, roleName) {
+	assertRoleExists(roles, roleName);
+	return roleName ? roles[roleName]?.thinkingLevel : void 0;
+}
+
+//#endregion
 //#region src/usage.ts
 /** All-zero `PromptUsage`. Identity element for `addUsage`. */
 function emptyUsage() {
@@ -473,29 +496,6 @@ async function compact(preparation, model, apiKey, signal) {
 	};
 }
 
-//#endregion
-//#region src/roles.ts
-function assertRoleExists(roles, roleName) {
-	if (!roleName) return;
-	if (roles[roleName]) return;
-	const available = Object.keys(roles);
-	const list = available.length > 0 ? available.join(", ") : "(none defined)";
-	throw new Error(`[flue] Role "${roleName}" not registered. Available roles: ${list}. Define roles as markdown files in \`roles/\` (or \`.flue/roles/\` if your root uses the .flue/ source layout).`);
-}
-function resolveEffectiveRole(options) {
-	const role = options.callRole ?? options.sessionRole ?? options.agentRole;
-	assertRoleExists(options.roles, role);
-	return role;
-}
-function resolveRoleModel(roles, roleName) {
-	assertRoleExists(roles, roleName);
-	return roleName ? roles[roleName]?.model : void 0;
-}
-function resolveRoleThinkingLevel(roles, roleName) {
-	assertRoleExists(roles, roleName);
-	return roleName ? roles[roleName]?.thinkingLevel : void 0;
-}
-
 //#endregion
 //#region src/session.ts
 const MAX_TASK_DEPTH = 4;
@@ -652,7 +652,7 @@ var SessionHistory = class SessionHistory {
 	}
 	toData(metadata, createdAt, updatedAt) {
 		return {
-			version: 2,
+			version: 3,
 			entries: [...this.entries],
 			leafId: this.leafId,
 			metadata,
@@ -703,7 +703,7 @@ function generateEntryId(byId) {
 	return crypto.randomUUID();
 }
 var Session = class {
-	id;
+	name;
 	fs;
 	metadata;
 	get role() {
@@ -723,13 +723,16 @@ var Session = class {
 	agentTools;
 	deleted = false;
 	activeOperation;
+	activeOperationId;
+	toolStartTimes = /* @__PURE__ */ new Map();
+	turnStartTime;
 	activeTasks = /* @__PURE__ */ new Set();
 	sessionRole;
 	taskDepth;
 	createTaskSession;
 	onDelete;
 	constructor(options) {
-		this.id = options.id;
+		this.name = options.name;
 		this.storageKey = options.storageKey;
 		this.config = options.config;
 		this.env = options.env;
@@ -764,13 +767,15 @@ var Session = class {
 			},
 			getApiKey: (provider) => this.getProviderApiKey(provider),
 			onPayload: (payload, model) => this.applyProviderPayloadOverrides(payload, model),
-			toolExecution: "parallel"
+			toolExecution: "parallel",
+			sessionId: options.affinityKey
 		});
 		this.eventCallback = options.onAgentEvent;
 		this.harness.subscribe(async (event) => {
 			switch (event.type) {
-				case "agent_start":
-					this.emit({ type: "agent_start" });
+				case "agent_start": break;
+				case "turn_start":
+					this.turnStartTime = Date.now();
 					break;
 				case "message_update": {
 					const aEvent = event.assistantMessageEvent;
@@ -790,6 +795,7 @@ var Session = class {
 					break;
 				}
 				case "tool_execution_start":
+					this.toolStartTimes.set(event.toolCallId, Date.now());
 					this.emit({
 						type: "tool_start",
 						toolName: event.toolName,
@@ -799,16 +805,30 @@ var Session = class {
 					break;
 				case "tool_execution_end":
 					this.emit({
-						type: "tool_end",
+						type: "tool_call",
 						toolName: event.toolName,
 						toolCallId: event.toolCallId,
 						isError: event.isError,
-						result: event.result
+						result: event.result,
+						durationMs: durationSince(this.toolStartTimes.get(event.toolCallId))
 					});
+					this.toolStartTimes.delete(event.toolCallId);
 					break;
-				case "turn_end":
-					this.emit({ type: "turn_end" });
+				case "turn_end": {
+					const message = event.message;
+					const assistant = message.role === "assistant" ? message : void 0;
+					this.emit({
+						type: "turn",
+						durationMs: durationSince(this.turnStartTime),
+						model: assistant?.model,
+						usage: fromProviderUsage(assistant?.usage),
+						stopReason: assistant?.stopReason,
+						isError: assistant?.stopReason === "error" || assistant?.stopReason === "aborted",
+						error: assistant?.errorMessage
+					});
+					this.turnStartTime = void 0;
 					break;
+				}
 				case "agent_end": break;
 			}
 		});
@@ -870,6 +890,7 @@ var Session = class {
 	shell(command, options) {
 		return createCallHandle(options?.signal, (signal) => this.runOperation("shell", signal, async () => {
 			const toolCallId = crypto.randomUUID();
+			const toolStartMs = Date.now();
 			const args = { command };
 			if (options?.cwd !== void 0) args.cwd = options.cwd;
 			if (options?.env !== void 0) args.env = redactEnvValues(options.env);
@@ -893,11 +914,12 @@ var Session = class {
 				const toolResult = formatBashResult(shellResult, command);
 				await this.appendShellTriple(toolCallId, args, toolResult, false);
 				this.emit({
-					type: "tool_end",
+					type: "tool_call",
 					toolName: "bash",
 					toolCallId,
 					isError: false,
-					result: toolResult
+					result: toolResult,
+					durationMs: durationSince(toolStartMs)
 				});
 				return shellResult;
 			} catch (error) {
@@ -913,11 +935,12 @@ var Session = class {
 				};
 				await this.appendShellTriple(toolCallId, args, errResult, true);
 				this.emit({
-					type: "tool_end",
+					type: "tool_call",
 					toolName: "bash",
 					toolCallId,
 					isError: true,
-					result: errResult
+					result: errResult,
+					durationMs: durationSince(toolStartMs)
 				});
 				throw error;
 			}
@@ -1070,7 +1093,7 @@ var Session = class {
 			}],
 			details: {
 				taskId: result.taskId,
-				sessionId: result.sessionId,
+				session: result.session,
 				messageId: result.messageId,
 				role: result.role,
 				cwd: result.cwd
@@ -1078,6 +1101,46 @@ var Session = class {
 		};
 	}
 	async runTask(text, options, signal) {
+		return this.runExclusive("task", async () => {
+			if (signal?.aborted) throw abortErrorFor(signal);
+			this.activeOperationId = generateOperationId();
+			const operationId = this.activeOperationId;
+			const startedAt = Date.now();
+			this.emit({
+				type: "operation_start",
+				operationId,
+				operationKind: "task"
+			});
+			try {
+				const result = await this.runTaskExclusive(text, options, signal);
+				this.emit({
+					type: "operation",
+					operationId,
+					operationKind: "task",
+					durationMs: durationSince(startedAt),
+					isError: false,
+					result: result.output,
+					usage: usageFromResult(result.output)
+				});
+				return result;
+			} catch (error) {
+				const surfaced = signal?.aborted ? abortErrorFor(signal) : error;
+				this.emit({
+					type: "operation",
+					operationId,
+					operationKind: "task",
+					durationMs: durationSince(startedAt),
+					isError: true,
+					error: serializeError(surfaced)
+				});
+				throw surfaced;
+			} finally {
+				this.emit({ type: "idle" });
+				this.activeOperationId = void 0;
+			}
+		});
+	}
+	async runTaskExclusive(text, options, signal) {
 		this.assertActive();
 		if (!this.createTaskSession) throw new Error("[flue] This session cannot create task sessions.");
 		if (this.taskDepth >= MAX_TASK_DEPTH) throw new Error(`[flue] Maximum task depth (${MAX_TASK_DEPTH}) exceeded.`);
@@ -1092,19 +1155,20 @@ var Session = class {
 			prompt: text,
 			role: requestedRole,
 			cwd: options?.cwd,
-			parentSessionId: this.id
+			parentSession: this.name
 		});
+		const taskStartMs = Date.now();
 		try {
 			const role = this.resolveEffectiveRole(options?.role);
 			child = await this.createTaskSession({
-				parentSessionId: this.id,
+				parentSession: this.name,
 				taskId,
 				parentEnv: this.env,
 				cwd: options?.cwd,
 				role,
 				depth: this.taskDepth + 1
 			});
-			await this.recordTaskSession(child.id, child.storageKey, taskId);
+			await this.recordTaskSession(child.name, child.storageKey, taskId);
 			this.activeTasks.add(child);
 			if (signal) {
 				abortListener = () => child?.abort();
@@ -1126,26 +1190,28 @@ var Session = class {
 				output,
 				text: typeof output?.text === "string" ? output.text : child.getAssistantText(),
 				taskId,
-				sessionId: child.id,
+				session: child.name,
 				messageId: child.getLatestAssistantMessageId(),
 				role,
 				cwd: options?.cwd
 			};
 			this.emit({
-				type: "task_end",
+				type: "task",
 				taskId,
 				isError: false,
 				result: taskResult.text,
-				parentSessionId: this.id
+				durationMs: durationSince(taskStartMs),
+				parentSession: this.name
 			});
 			return taskResult;
 		} catch (error) {
 			this.emit({
-				type: "task_end",
+				type: "task",
 				taskId,
 				isError: true,
 				result: getErrorMessage(error),
-				parentSessionId: this.id
+				durationMs: durationSince(taskStartMs),
+				parentSession: this.name
 			});
 			throw error;
 		} finally {
@@ -1159,6 +1225,14 @@ var Session = class {
 	async runOperation(operation, signal, fn) {
 		return this.runExclusive(operation, async () => {
 			if (signal?.aborted) throw abortErrorFor(signal);
+			this.activeOperationId = generateOperationId();
+			const operationId = this.activeOperationId;
+			const startedAt = Date.now();
+			this.emit({
+				type: "operation_start",
+				operationId,
+				operationKind: operation
+			});
 			const onAbort = () => {
 				this.harness.abort();
 				this.compactionAbortController?.abort(signal?.reason);
@@ -1166,18 +1240,38 @@ var Session = class {
 			};
 			signal?.addEventListener("abort", onAbort, { once: true });
 			try {
-				return await fn();
+				const result = await fn();
+				this.emit({
+					type: "operation",
+					operationId,
+					operationKind: operation,
+					durationMs: durationSince(startedAt),
+					isError: false,
+					result,
+					usage: usageFromResult(result)
+				});
+				return result;
 			} catch (error) {
-				throw signal?.aborted ? abortErrorFor(signal) : error;
+				const surfaced = signal?.aborted ? abortErrorFor(signal) : error;
+				this.emit({
+					type: "operation",
+					operationId,
+					operationKind: operation,
+					durationMs: durationSince(startedAt),
+					isError: true,
+					error: serializeError(surfaced)
+				});
+				throw surfaced;
 			} finally {
 				signal?.removeEventListener("abort", onAbort);
 				this.emit({ type: "idle" });
+				this.activeOperationId = void 0;
 			}
 		});
 	}
 	async runExclusive(operation, fn) {
 		this.assertActive();
-		if (this.activeOperation) throw new Error(`[flue] Session "${this.id}" is already running ${this.activeOperation}. Start another session for parallel conversation branches.`);
+		if (this.activeOperation) throw new Error(`[flue] Session "${this.name}" is already running ${this.activeOperation}. Start another session for parallel conversation branches.`);
 		this.activeOperation = operation;
 		try {
 			return await fn();
@@ -1186,27 +1280,18 @@ var Session = class {
 		}
 	}
 	emit(event) {
-		this.eventCallback?.({
+		const decorated = {
 			...event,
-			sessionId: this.id
-		});
+			session: event.session ?? this.name
+		};
+		const operationId = event.operationId ?? this.activeOperationId;
+		if (operationId !== void 0) decorated.operationId = operationId;
+		this.eventCallback?.(decorated);
 	}
 	assertActive() {
-		if (this.deleted) throw new Error(`[flue] Session "${this.id}" has been deleted.`);
+		if (this.deleted) throw new Error(`[flue] Session "${this.name}" has been deleted.`);
 	}
-	/**
-	* Append the three-message conversational triple that represents a
-	* `session.shell()` call in the message history:
-	*
-	*   1. user        — out-of-band request to run the command
-	*   2. assistant   — synthetic turn whose content is a single bash
-	*                    tool_use block (matching the shape pi-ai's
-	*                    providers produce when the LLM itself calls bash)
-	*   3. toolResult  — the bash output, keyed to the same toolCallId
-	*
-	* This makes a session.shell() call indistinguishable from an
-	* LLM-issued bash tool call when later turns read the transcript.
-	*/
+	/** Append a `session.shell()` call as an LLM-shaped bash tool exchange. */
 	async appendShellTriple(toolCallId, args, toolResult, isError) {
 		const timestamp = Date.now();
 		const userMessage = {
@@ -1271,11 +1356,11 @@ var Session = class {
 		if (!this.createdAt) this.createdAt = now;
 		await this.store.save(this.storageKey, data);
 	}
-	async recordTaskSession(sessionId, storageKey, taskId) {
+	async recordTaskSession(session, storageKey, taskId) {
 		const taskSessions = Array.isArray(this.metadata.taskSessions) ? this.metadata.taskSessions : [];
-		if (!taskSessions.some((task) => task?.sessionId === sessionId)) {
+		if (!taskSessions.some((task) => task?.session === session)) {
 			taskSessions.push({
-				sessionId,
+				session,
 				taskId,
 				storageKey
 			});
@@ -1295,7 +1380,7 @@ var Session = class {
 		if (isContextOverflow(assistantMessage, contextWindow)) {
 			if (this.overflowRecoveryAttempted) return;
 			this.overflowRecoveryAttempted = true;
-			console.error(`[flue:compaction] Overflow detected, compacting and retrying...`);
+			this.internalLog("info", "[flue:compaction] Overflow detected, compacting and retrying...");
 			const messages = this.harness.state.messages;
 			const lastMsg = messages[messages.length - 1];
 			if (lastMsg && lastMsg.role === "assistant") {
@@ -1313,7 +1398,7 @@ var Session = class {
 		if (assistantMessage.stopReason === "error") return;
 		const contextTokens = calculateContextTokens(assistantMessage.usage);
 		if (shouldCompact(contextTokens, contextWindow, this.compactionSettings)) {
-			console.error(`[flue:compaction] Threshold reached — ${contextTokens} tokens used, window ${contextWindow}, reserve ${this.compactionSettings.reserveTokens}, triggering compaction`);
+			this.internalLog("info", `[flue:compaction] Threshold reached — ${contextTokens} tokens used, window ${contextWindow}, reserve ${this.compactionSettings.reserveTokens}, triggering compaction`);
 			await this.runCompaction("threshold", false);
 		}
 	}
@@ -1327,6 +1412,7 @@ var Session = class {
 	async runCompaction(reason, willRetry) {
 		this.compactionAbortController = new AbortController();
 		const messagesBefore = this.harness.state.messages.length;
+		const compactionStartMs = Date.now();
 		try {
 			const model = this.harness.state.model;
 			const contextEntries = this.history.buildContextEntries();
@@ -1338,15 +1424,15 @@ var Session = class {
 				details: latestCompaction.details
 			} : void 0);
 			if (!preparation) {
-				console.error(`[flue:compaction] Nothing to compact (no valid cut point found)`);
+				this.internalLog("info", "[flue:compaction] Nothing to compact (no valid cut point found)");
 				return;
 			}
 			const firstKeptEntry = contextEntries[preparation.firstKeptIndex]?.entry;
 			if (!firstKeptEntry || firstKeptEntry.type !== "message") {
-				console.error(`[flue:compaction] Nothing to compact (first kept message has no entry)`);
+				this.internalLog("info", "[flue:compaction] Nothing to compact (first kept message has no entry)");
 				return;
 			}
-			console.error(`[flue:compaction] Summarizing ${preparation.messagesToSummarize.length} messages` + (preparation.isSplitTurn ? ` (split turn: ${preparation.turnPrefixMessages.length} prefix messages)` : "") + `, keeping messages from index ${preparation.firstKeptIndex}`);
+			this.internalLog("info", `[flue:compaction] Summarizing ${preparation.messagesToSummarize.length} messages` + (preparation.isSplitTurn ? ` (split turn: ${preparation.turnPrefixMessages.length} prefix messages)` : "") + `, keeping messages from index ${preparation.firstKeptIndex}`);
 			const estimatedTokens = preparation.tokensBefore;
 			this.emit({
 				type: "compaction_start",
@@ -1364,18 +1450,20 @@ var Session = class {
 			});
 			this.harness.state.messages = this.history.buildContext();
 			const messagesAfter = this.harness.state.messages.length;
-			console.error(`[flue:compaction] Complete — messages: ${messagesBefore} → ${messagesAfter}, tokens before: ${result.tokensBefore}`);
+			this.internalLog("info", `[flue:compaction] Complete — messages: ${messagesBefore} → ${messagesAfter}, tokens before: ${result.tokensBefore}`);
 			this.emit({
-				type: "compaction_end",
+				type: "compaction",
 				messagesBefore,
-				messagesAfter
+				messagesAfter,
+				durationMs: durationSince(compactionStartMs),
+				usage: result.usage
 			});
 			await this.save();
 			if (willRetry) {
 				const msgs = this.harness.state.messages;
 				const lastMsg = msgs[msgs.length - 1];
 				if (lastMsg?.role === "assistant" && lastMsg.stopReason === "error") this.harness.state.messages = msgs.slice(0, -1);
-				console.error(`[flue:compaction] Retrying after overflow recovery...`);
+				this.internalLog("info", "[flue:compaction] Retrying after overflow recovery...");
 				const beforeRetry = this.harness.state.messages.length;
 				await this.harness.continue();
 				await this.harness.waitForIdle();
@@ -1383,11 +1471,20 @@ var Session = class {
 			}
 		} catch (error) {
 			const errorMessage = error instanceof Error ? error.message : String(error);
-			console.error(`[flue:compaction] Failed: ${errorMessage}`);
+			this.internalLog("error", `[flue:compaction] Failed: ${errorMessage}`, { error });
 		} finally {
 			this.compactionAbortController = void 0;
 		}
 	}
+	internalLog(level, message, attributes) {
+		console.error(message);
+		this.emit({
+			type: "log",
+			level,
+			message,
+			attributes: normalizeLogAttributes(attributes)
+		});
+	}
 	throwIfError(context) {
 		const errorMsg = this.harness.state.errorMessage;
 		if (errorMsg) throw new Error(`[flue] ${context} failed: ${errorMsg}`);
@@ -1530,6 +1627,32 @@ async function deleteSessionTree(store, storageKey, seen = /* @__PURE__ */ new S
 function getErrorMessage(error) {
 	return error instanceof Error ? error.message : String(error);
 }
+function serializeError(error) {
+	if (error instanceof Error) return {
+		name: error.name,
+		message: error.message
+	};
+	return error;
+}
+function normalizeLogAttributes(attributes) {
+	if (!attributes) return void 0;
+	if (!(attributes.error instanceof Error)) return attributes;
+	return {
+		...attributes,
+		error: serializeError(attributes.error)
+	};
+}
+function durationSince(start) {
+	return start === void 0 ? 0 : Date.now() - start;
+}
+function usageFromResult(result) {
+	if (typeof result !== "object" || result === null) return void 0;
+	const usage = result.usage;
+	return isPromptUsage(usage) ? usage : void 0;
+}
+function isPromptUsage(value) {
+	return typeof value === "object" && value !== null && typeof value.input === "number" && typeof value.output === "number" && typeof value.totalTokens === "number";
+}
 function redactEnvValues(env) {
 	return Object.fromEntries(Object.keys(env).map((key) => [key, "<redacted>"]));
 }