@flue/client 0.0.5 → 0.0.7

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) {
@@ -49,12 +191,6 @@ async function runShell(command, options) {
 //#endregion
 //#region src/prompt.ts
 /**
-* Checks if a Valibot schema represents a plain string type.
-*/
-function isStringSchema(schema) {
-	return schema.type === "string";
-}
-/**
 * Checks if a skill name is a file path (contains '/' or ends with '.md').
 */
 function isFilePath(name) {
@@ -80,10 +216,9 @@ function buildSkillPrompt(name, args, schema) {
 		isFilePath(name) ? `Read and use the .opencode/skills/${name} skill.` : `Use the ${name} skill.`
 	];
 	if (args && Object.keys(args).length > 0) parts.push(`\nArguments:\n${JSON.stringify(args, null, 2)}`);
-	if (schema) if (isStringSchema(schema)) parts.push("\nWhen complete, output your result between these exact delimiters (the result can contain any content including code blocks):", "---RESULT_START---", "Your text output here", "---RESULT_END---");
-	else {
+	if (schema) {
 		const { $schema: _, ...schemaWithoutMeta } = toJsonSchema(schema, { errorMode: "ignore" });
-		parts.push("\nWhen complete, output your result between these exact delimiters as JSON conforming to this schema:", "```json", JSON.stringify(schemaWithoutMeta, null, 2), "```", "", "Format:", "---RESULT_START---", "{\"key\": \"value\"}", "---RESULT_END---");
+		parts.push("\nWhen complete, you MUST output your result between these exact delimiters conforming to this schema:", "```json", JSON.stringify(schemaWithoutMeta, null, 2), "```", "", "Example: (Object)", "---RESULT_START---", "{\"key\": \"value\"}", "---RESULT_END---", "", "Example: (String)", "---RESULT_START---", "Hello, world!", "---RESULT_END---");
 	}
 	return parts.join("\n");
 }
@@ -113,35 +248,10 @@ function extractResult(parts, schema, sessionId) {
 			rawOutput: allText
 		});
 	}
-	console.log(`[flue] extractResult: found result block (${resultBlock.length} chars, session: ${sessionId})`);
-	if (schema.type === "string") {
-		const parseResult = v.safeParse(schema, resultBlock);
-		if (!parseResult.success) {
-			console.error("[flue] extractResult: string validation failed", parseResult.issues);
-			throw new SkillOutputError("Result validation failed for string schema.", {
-				sessionId,
-				rawOutput: resultBlock,
-				validationErrors: parseResult.issues
-			});
-		}
-		console.log(`[flue] extractResult: validated string result (${resultBlock.length} chars)`);
-		return parseResult.output;
-	}
-	let parsed;
-	try {
-		parsed = JSON.parse(resultBlock);
-	} catch (err) {
-		console.error(`[flue] extractResult: JSON parse failed for block: ${resultBlock.slice(0, 200)}`);
-		throw new SkillOutputError("Failed to parse result block as JSON.", {
-			sessionId,
-			rawOutput: resultBlock,
-			validationErrors: err
-		});
-	}
-	const parseResult = v.safeParse(schema, parsed);
+	const parseResult = v.safeParse(schema, resultBlock);
 	if (!parseResult.success) {
 		console.error("[flue] extractResult: schema validation failed", parseResult.issues);
-		console.error("[flue] extractResult: parsed value was:", JSON.stringify(parsed));
+		console.error("[flue] extractResult: parsed value was:", JSON.stringify(resultBlock));
 		throw new SkillOutputError("Result does not match the expected schema.", {
 			sessionId,
 			rawOutput: resultBlock,
@@ -208,6 +318,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 +326,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 +464,4 @@ var Flue = class {
 };
 
 //#endregion
-export { Flue, SkillOutputError };
+export { Flue, SkillOutputError, transformEvent };

package/package.json

@@ -1,28 +1,28 @@
 {
-	"name": "@flue/client",
-	"version": "0.0.5",
-	"type": "module",
-	"exports": {
-		".": {
-			"types": "./dist/index.d.mts",
-			"import": "./dist/index.mjs"
-		}
-	},
-	"main": "./dist/index.mjs",
-	"types": "./dist/index.d.mts",
-	"files": [
-		"dist"
-	],
-	"scripts": {
-		"build": "tsdown",
-		"check:types": "tsc --noEmit"
-	},
-	"dependencies": {
-		"@opencode-ai/sdk": "latest",
-		"@valibot/to-json-schema": "^1.0.0",
-		"valibot": "^1.0.0"
-	},
-	"devDependencies": {
-		"tsdown": "^0.20.3"
-	}
-}
+  "name": "@flue/client",
+  "version": "0.0.7",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@opencode-ai/sdk": "^1.1.56",
+    "@valibot/to-json-schema": "^1.0.0",
+    "valibot": "^1.0.0"
+  },
+  "devDependencies": {
+    "tsdown": "^0.20.3"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "check:types": "tsc --noEmit"
+  }
+}