@themoltnet/pi-extension 0.6.0 → 0.7.0

package/dist/index.d.ts

@@ -52,6 +52,8 @@ export declare function createGondolinWriteOps(vm: VM, localCwd: string): WriteO
  */
 export declare function createMoltNetTools(config: MoltNetToolsConfig): ToolDefinition<any, any>[];
 
+export declare function createPiOtelExtension(options?: PiOtelOptions): (pi: ExtensionAPI) => void;
+
 /**
  * Factory that builds a pi-specific `executeTask` function suitable for
  * injection into `AgentRuntime`. The returned function caches the resolved
@@ -186,6 +188,17 @@ declare interface PiJudgeRecipeVersions {
     sdk: string | null;
 }
 
+export declare interface PiOtelOptions {
+    /** Agent name for `gen_ai.agent.name` on the root span. */
+    agentName?: string;
+    /**
+     * Extra attributes merged onto every span. Use MoltNet-specific keys
+     * like `moltnet.task.id` — any `gen_ai.*` keys here are filtered out
+     * since the extension is authoritative for those.
+     */
+    spanAttributes?: Record<string, string | number | boolean>;
+}
+
 export declare function resolvePiJudgeRecipeVersions(): PiJudgeRecipeVersions;
 
 /**

package/dist/index.js

@@ -11,6 +11,7 @@ import { Type, complete, getModel } from "@mariozechner/pi-ai";
 import { RealFSProvider, ShadowProvider, VM, VmCheckpoint, createHttpHooks, createShadowPathPredicate, ensureImageSelector, loadGuestAssets } from "@earendil-works/gondolin";
 import { parseEnv } from "node:util";
 import { fileURLToPath } from "node:url";
+import { SpanStatusCode, context, trace } from "@opentelemetry/api";
 import { FormatRegistry, Type as Type$1 } from "@sinclair/typebox";
 import { Value } from "@sinclair/typebox/value";
 //#region ../api-client/src/generated/core/bodySerializer.gen.ts
@@ -8600,6 +8601,143 @@ function computePiJudgeRecipeCid(inputs) {
 	};
 }
 //#endregion
+//#region src/otel/index.ts
+var TRACER_NAME = "@themoltnet/pi-extension/otel";
+function stripReservedAttrs(attrs) {
+	const out = {};
+	for (const [k, v] of Object.entries(attrs)) {
+		if (k.startsWith("gen_ai.")) continue;
+		out[k] = v;
+	}
+	return out;
+}
+function createPiOtelExtension(options = {}) {
+	return function piOtelExtension(pi) {
+		const tracer = trace.getTracer(TRACER_NAME);
+		const extraAttrs = stripReservedAttrs(options.spanAttributes ?? {});
+		let sessionSpan;
+		let sessionCtx = context.active();
+		let turnSpan;
+		let turnCtx = context.active();
+		let currentModel;
+		const toolSpans = /* @__PURE__ */ new Map();
+		function drainToolSpans(reason) {
+			for (const [, entry] of toolSpans) {
+				entry.span.setStatus({
+					code: SpanStatusCode.ERROR,
+					message: reason
+				});
+				entry.span.end();
+			}
+			toolSpans.clear();
+		}
+		function endTurnSpan() {
+			if (!turnSpan) return;
+			drainToolSpans("tool span not closed before turn end");
+			turnSpan.end();
+			turnSpan = void 0;
+			turnCtx = sessionCtx;
+		}
+		function endSessionSpan() {
+			drainToolSpans("tool span not closed before session shutdown");
+			endTurnSpan();
+			if (sessionSpan) {
+				sessionSpan.setStatus({ code: SpanStatusCode.OK });
+				sessionSpan.end();
+				sessionSpan = void 0;
+				sessionCtx = context.active();
+			}
+			currentModel = void 0;
+		}
+		pi.on("session_start", (event, ctx) => {
+			endSessionSpan();
+			const agentName = options.agentName ?? "pi";
+			sessionSpan = tracer.startSpan(`invoke_agent ${agentName}`, { attributes: {
+				...extraAttrs,
+				"gen_ai.operation.name": "invoke_agent",
+				"gen_ai.agent.name": agentName,
+				"session.reason": event.reason,
+				"session.cwd": ctx.cwd
+			} }, context.active());
+			sessionCtx = trace.setSpan(context.active(), sessionSpan);
+			turnCtx = sessionCtx;
+		});
+		pi.on("session_shutdown", () => {
+			endSessionSpan();
+		});
+		pi.on("model_select", (event) => {
+			currentModel = {
+				provider: event.model.provider,
+				id: event.model.id
+			};
+			if (sessionSpan) {
+				sessionSpan.setAttribute("gen_ai.request.model", event.model.id);
+				sessionSpan.setAttribute("gen_ai.provider.name", event.model.provider);
+			}
+		});
+		pi.on("turn_start", (event) => {
+			if (!sessionSpan) return;
+			const modelLabel = currentModel?.id ?? "unknown";
+			turnSpan = tracer.startSpan(`chat ${modelLabel}`, { attributes: {
+				...extraAttrs,
+				"gen_ai.operation.name": "chat",
+				"gen_ai.request.model": currentModel?.id ?? "unknown",
+				"gen_ai.provider.name": currentModel?.provider ?? "unknown",
+				"turn.index": event.turnIndex
+			} }, sessionCtx);
+			turnCtx = trace.setSpan(sessionCtx, turnSpan);
+		});
+		pi.on("turn_end", (event) => {
+			if (!turnSpan) return;
+			const usage = extractUsage(event.message);
+			if (usage) {
+				turnSpan.setAttribute("gen_ai.usage.input_tokens", usage.input);
+				turnSpan.setAttribute("gen_ai.usage.output_tokens", usage.output);
+			}
+			turnSpan.setAttribute("turn.tool_results", event.toolResults?.length ?? 0);
+			turnSpan.setStatus({ code: SpanStatusCode.OK });
+			endTurnSpan();
+		});
+		pi.on("tool_execution_start", (event) => {
+			const parentCtx = turnSpan ? turnCtx : sessionCtx;
+			const span = tracer.startSpan(`execute_tool ${event.toolName}`, { attributes: {
+				...extraAttrs,
+				"gen_ai.operation.name": "execute_tool",
+				"gen_ai.tool.name": event.toolName,
+				"gen_ai.tool.call.id": event.toolCallId
+			} }, parentCtx);
+			toolSpans.set(event.toolCallId, {
+				span,
+				startedAt: Date.now()
+			});
+		});
+		pi.on("tool_execution_end", (event) => {
+			const entry = toolSpans.get(event.toolCallId);
+			if (!entry) return;
+			const durationMs = Date.now() - entry.startedAt;
+			entry.span.setAttribute("tool.duration_ms", durationMs);
+			if (event.isError) {
+				entry.span.setAttribute("error.type", "tool_execution_error");
+				entry.span.setStatus({
+					code: SpanStatusCode.ERROR,
+					message: "tool execution failed"
+				});
+			} else entry.span.setStatus({ code: SpanStatusCode.OK });
+			entry.span.end();
+			toolSpans.delete(event.toolCallId);
+		});
+	};
+}
+function extractUsage(message) {
+	if (!message || typeof message !== "object" || !("usage" in message) || !("role" in message)) return null;
+	const msg = message;
+	if (msg.role !== "assistant" || !msg.usage) return null;
+	return {
+		input: msg.usage.input ?? 0,
+		output: msg.usage.output ?? 0
+	};
+}
+//#endregion
 //#region ../tasks/src/formats.ts
 /**
 * Register TypeBox string formats used across Task / TaskOutput / task-type
@@ -9977,7 +10115,15 @@ async function executePiTask(claimedTask, reporter, opts) {
 			const modelHandle = getModel(opts.provider, opts.model);
 			const resourceLoader = new DefaultResourceLoader({
 				cwd: mountPath,
-				agentDir: piAuthDir
+				agentDir: piAuthDir,
+				extensionFactories: [createPiOtelExtension({
+					agentName: opts.agentName,
+					spanAttributes: {
+						"moltnet.task.id": task.id,
+						"moltnet.task.attempt": attemptN,
+						"moltnet.task.type": task.taskType
+					}
+				})]
 			});
 			await resourceLoader.reload();
 			session = (await createAgentSession({
@@ -10094,10 +10240,16 @@ async function executePiTask(claimedTask, reporter, opts) {
 		if (reporterOpen) {
 			try {
 				await reporter.finalize(finalUsage);
-			} catch {}
+			} catch (err) {
+				const detail = err instanceof Error ? err.message : String(err);
+				console.error(`executePiTask: reporter.finalize() failed for task ${task.id} attempt ${attemptN}: ${detail}`);
+			}
 			try {
 				await reporter.close();
-			} catch {}
+			} catch (err) {
+				const detail = err instanceof Error ? err.message : String(err);
+				console.error(`executePiTask: reporter.close() failed for task ${task.id} attempt ${attemptN}: ${detail}`);
+			}
 		}
 		await managed.vm.close();
 	}
@@ -10415,4 +10567,4 @@ function moltnetExtension(pi) {
 	registerMoltnetReflectCommand(pi, state);
 }
 //#endregion
-export { HOST_EXEC_DEFAULT_BASE_ENV, activateAgentEnv, buildPiJudgeRecipeManifest, computePiJudgeRecipeCid, createGondolinBashOps, createGondolinEditOps, createGondolinReadOps, createGondolinWriteOps, createMoltNetTools, createPiTaskExecutor, moltnetExtension as default, ensureSnapshot, executePiTask, findMainWorktree, loadCredentials, resolvePiJudgeRecipeVersions, resumeVm, toGuestPath };
+export { HOST_EXEC_DEFAULT_BASE_ENV, activateAgentEnv, buildPiJudgeRecipeManifest, computePiJudgeRecipeCid, createGondolinBashOps, createGondolinEditOps, createGondolinReadOps, createGondolinWriteOps, createMoltNetTools, createPiOtelExtension, createPiTaskExecutor, moltnetExtension as default, ensureSnapshot, executePiTask, findMainWorktree, loadCredentials, resolvePiJudgeRecipeVersions, resumeVm, toGuestPath };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@themoltnet/pi-extension",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "type": "module",
   "description": "MoltNet pi extension — sandboxed tool execution in Gondolin VMs with MoltNet identity and persistent memory",
   "license": "MIT",
@@ -29,8 +29,9 @@
   },
   "dependencies": {
     "@earendil-works/gondolin": "^0.7.0",
+    "@opentelemetry/api": "^1.9.0",
     "@sinclair/typebox": "^0.34.0",
-    "@themoltnet/agent-runtime": "0.2.1",
+    "@themoltnet/agent-runtime": "0.3.0",
     "@themoltnet/sdk": "0.95.0"
   },
   "peerDependencies": {
@@ -48,6 +49,7 @@
   "devDependencies": {
     "@mariozechner/pi-ai": "^0.67.68",
     "@mariozechner/pi-coding-agent": "^0.67.68",
+    "@opentelemetry/sdk-trace-base": "^2.5.1",
     "@types/node": "^20.11.0",
     "typescript": "^5.3.3",
     "vite": "^8.0.0",