@flue/client 0.0.5 → 0.0.6

package/dist/index.d.mts

@@ -15,6 +15,63 @@ declare class SkillOutputError extends Error {
   });
 }
 //#endregion
+//#region src/events.d.ts
+/**
+ * Flue event types and transform utilities.
+ *
+ * Converts raw OpenCode SSE events into a stable, simplified Flue event
+ * format suitable for logging and streaming to external consumers.
+ */
+type FlueEvent = {
+  timestamp: number;
+  sessionId: string;
+} & ({
+  type: 'tool.pending';
+  tool: string;
+  input: string;
+} | {
+  type: 'tool.running';
+  tool: string;
+  input: string;
+} | {
+  type: 'tool.complete';
+  tool: string;
+  input: string;
+  output: string;
+  duration: number;
+} | {
+  type: 'tool.error';
+  tool: string;
+  input: string;
+  error: string;
+  duration: number;
+} | {
+  type: 'text';
+  text: string;
+} | {
+  type: 'status';
+  status: 'busy' | 'idle' | 'compacted' | 'retry';
+  message?: string;
+} | {
+  type: 'step.start';
+} | {
+  type: 'step.finish';
+  reason: string;
+  tokens: {
+    input: number;
+    output: number;
+  };
+  cost: number;
+} | {
+  type: 'error';
+  message: string;
+});
+/**
+ * Attempt to parse a raw OpenCode SSE event and convert it to a FlueEvent.
+ * Returns null if the event should be filtered out (not relevant for logs).
+ */
+declare function transformEvent(raw: any): FlueEvent | null;
+//#endregion
 //#region src/types.d.ts
 interface FlueOptions {
   /** OpenCode server URL (default: 'http://localhost:48765'). */
@@ -101,4 +158,4 @@ declare class Flue {
   close(): Promise<void>;
 }
 //#endregion
-export { Flue, type FlueOptions, type PromptOptions, type ShellOptions, type ShellResult, type SkillOptions, SkillOutputError };
+export { Flue, type FlueEvent, type FlueOptions, type PromptOptions, type ShellOptions, type ShellResult, type SkillOptions, SkillOutputError, transformEvent };

package/dist/index.mjs

@@ -20,6 +20,148 @@ var SkillOutputError = class extends Error {
 	}
 };
 
+//#endregion
+//#region src/events.ts
+/**
+* Summarize tool input into a short human-readable string.
+*/
+function summarizeInput(tool, input) {
+	if (input.command) return String(input.command).slice(0, 500);
+	if (input.filePath) return String(input.filePath);
+	if (input.pattern) return String(input.pattern);
+	if (input.url) return String(input.url);
+	if (input.name) return String(input.name);
+	return tool;
+}
+/**
+* Attempt to parse a raw OpenCode SSE event and convert it to a FlueEvent.
+* Returns null if the event should be filtered out (not relevant for logs).
+*/
+function transformEvent(raw) {
+	const type = raw?.type;
+	if (!type) return null;
+	const now = Date.now();
+	if (type === "message.part.updated") {
+		const part = raw.properties?.part;
+		if (!part) return null;
+		const sessionId = part.sessionID ?? "";
+		if (part.type === "tool") {
+			const tool = part.tool ?? "?";
+			const state = part.state;
+			if (!state) return null;
+			const input = summarizeInput(tool, state.input ?? {});
+			switch (state.status) {
+				case "pending": return {
+					timestamp: now,
+					sessionId,
+					type: "tool.pending",
+					tool,
+					input
+				};
+				case "running": return {
+					timestamp: now,
+					sessionId,
+					type: "tool.running",
+					tool,
+					input
+				};
+				case "completed": return {
+					timestamp: now,
+					sessionId,
+					type: "tool.complete",
+					tool,
+					input,
+					output: (state.output ?? "").slice(0, 1e3),
+					duration: state.time?.end && state.time?.start ? state.time.end - state.time.start : 0
+				};
+				case "error": {
+					const duration = state.time?.end && state.time?.start ? state.time.end - state.time.start : 0;
+					return {
+						timestamp: now,
+						sessionId,
+						type: "tool.error",
+						tool,
+						input,
+						error: state.error ?? "unknown error",
+						duration
+					};
+				}
+			}
+			return null;
+		}
+		if (part.type === "text") {
+			const delta = raw.properties?.delta;
+			if (delta) return {
+				timestamp: now,
+				sessionId,
+				type: "text",
+				text: delta
+			};
+			return null;
+		}
+		if (part.type === "step-start") return {
+			timestamp: now,
+			sessionId: part.sessionID ?? "",
+			type: "step.start"
+		};
+		if (part.type === "step-finish") return {
+			timestamp: now,
+			sessionId: part.sessionID ?? "",
+			type: "step.finish",
+			reason: part.reason ?? "",
+			tokens: {
+				input: part.tokens?.input ?? 0,
+				output: part.tokens?.output ?? 0
+			},
+			cost: part.cost ?? 0
+		};
+		return null;
+	}
+	if (type === "session.status") {
+		const sessionId = raw.properties?.sessionID ?? "";
+		const status = raw.properties?.status;
+		if (status?.type === "busy") return {
+			timestamp: now,
+			sessionId,
+			type: "status",
+			status: "busy"
+		};
+		if (status?.type === "idle") return {
+			timestamp: now,
+			sessionId,
+			type: "status",
+			status: "idle"
+		};
+		if (status?.type === "retry") return {
+			timestamp: now,
+			sessionId,
+			type: "status",
+			status: "retry",
+			message: status.message
+		};
+		return null;
+	}
+	if (type === "session.idle") return {
+		timestamp: now,
+		sessionId: raw.properties?.sessionID ?? "",
+		type: "status",
+		status: "idle"
+	};
+	if (type === "session.compacted") return {
+		timestamp: now,
+		sessionId: raw.properties?.sessionID ?? "",
+		type: "status",
+		status: "compacted"
+	};
+	if (type === "session.error") return {
+		timestamp: now,
+		sessionId: raw.properties?.sessionID ?? "",
+		type: "error",
+		message: raw.properties?.error ?? "unknown error"
+	};
+	return null;
+}
+
 //#endregion
 //#region src/shell.ts
 async function runShell(command, options) {
@@ -208,6 +350,7 @@ async function runSkill(client, workdir, name, options) {
 		data: asyncResult.data
 	});
 	if (asyncResult.error) throw new Error(`Failed to send prompt for skill "${name}" (session ${sessionId}): ${JSON.stringify(asyncResult.error)}`);
+	await confirmSessionStarted(client, sessionId, workdir, name);
 	console.log(`[flue] skill("${name}"): starting polling`);
 	const parts = await pollUntilIdle(client, sessionId, workdir, name, promptStart);
 	const promptElapsed = ((Date.now() - promptStart) / 1e3).toFixed(1);
@@ -215,6 +358,30 @@ async function runSkill(client, workdir, name, options) {
 	if (!schema) return;
 	return extractResult(parts, schema, sessionId);
 }
+/**
+* After promptAsync, confirm that OpenCode actually started processing the session.
+* Polls quickly (1s) to detect the session appearing as "busy" or a user message being recorded.
+* Fails fast (~15s) instead of letting the poll loop run for 5 minutes.
+*/
+async function confirmSessionStarted(client, sessionId, workdir, skillName) {
+	const maxAttempts = 15;
+	for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+		await sleep(1e3);
+		if (((await client.session.status({ query: { directory: workdir } })).data?.[sessionId])?.type === "busy") {
+			console.log(`[flue] skill("${skillName}"): session confirmed running`);
+			return;
+		}
+		const messages = (await client.session.messages({
+			path: { id: sessionId },
+			query: { directory: workdir }
+		})).data;
+		if (messages && messages.length > 0) {
+			console.log(`[flue] skill("${skillName}"): session confirmed (${messages.length} messages)`);
+			return;
+		}
+	}
+	throw new Error(`Skill "${skillName}" failed to start: session ${sessionId} has no messages after 15s.\nThe prompt was accepted but OpenCode never began processing it.\nThis usually means no model is configured. Pass --model to the flue CLI or set "model" in opencode.json.`);
+}
 async function pollUntilIdle(client, sessionId, workdir, skillName, startTime) {
 	let emptyPolls = 0;
 	let pollCount = 0;
@@ -329,4 +496,4 @@ var Flue = class {
 };
 
 //#endregion
-export { Flue, SkillOutputError };
+export { Flue, SkillOutputError, transformEvent };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@flue/client",
-	"version": "0.0.5",
+	"version": "0.0.6",
 	"type": "module",
 	"exports": {
 		".": {