@themoltnet/pi-extension 0.30.0 → 0.31.0

package/dist/index.d.ts

@@ -145,6 +145,14 @@ export declare function createMoltNetTools(config: MoltNetToolsConfig): ToolDefi
 
 export declare function createPiOtelExtension(options?: PiOtelOptions): (pi: ExtensionAPI) => void;
 
+export declare function createPiRetryTriage(options: {
+    model: Model<Api>;
+    thinkingLevel?: PiRetryTriageThinkingLevel | null;
+    piAgentDir: string;
+    timeoutMs?: number;
+    cwd?: string;
+}): PiRetryTriage;
+
 /**
  * Factory that builds a pi-specific `executeTask` function suitable for
  * injection into `AgentRuntime`. The returned function caches the resolved
@@ -524,6 +532,8 @@ declare interface MoltNetToolsConfig {
     getTaskContext?(): MoltNetTaskContext | null;
 }
 
+export declare function normalizeRetryTriageResult(value: unknown): PiRetryTriageResult;
+
 export declare interface PiOtelOptions {
     /** Agent name for `gen_ai.agent.name` on the root span. */
     agentName?: string;
@@ -535,6 +545,38 @@ export declare interface PiOtelOptions {
     spanAttributes?: Record<string, string | number | boolean>;
 }
 
+export declare type PiRetryTriage = (input: PiRetryTriageInput) => Promise<PiRetryTriageResult>;
+
+export declare type PiRetryTriageConfidence = RetryTriageConfidence;
+
+export declare type PiRetryTriageDecision = RetryTriageDecision;
+
+export declare interface PiRetryTriageInput {
+    task: {
+        id: string;
+        taskType: string;
+        teamId: string;
+        input: unknown;
+    };
+    attemptN: number;
+    maxAttempts?: number | null;
+    remainingAttempts?: number | null;
+    error: unknown;
+    recentMessages?: {
+        timestamp: string;
+        kind: string;
+        payload: unknown;
+    }[];
+}
+
+export declare interface PiRetryTriageResult {
+    decision: RetryTriageDecision;
+    confidence: RetryTriageConfidence;
+    reason: string;
+}
+
+export declare type PiRetryTriageThinkingLevel = 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
+
 export declare interface PiSessionPersistencePlan {
     sessionDir: string;
     forkFromSessionPath?: string | null;
@@ -605,6 +647,8 @@ declare interface PiWorkspaceSeedPlan {
     source: 'producer';
 }
 
+export declare function redactRetryTriageSecrets(value: string): string;
+
 export declare function resolveTaskWorktreePath(mainRepo: string, workspaceId: string): string;
 
 export declare interface ResumeCommand {
@@ -635,6 +679,10 @@ declare interface ResumeCommandWhen {
  */
 export declare function resumeVm(config: VmConfig): Promise<ManagedVm>;
 
+export declare type RetryTriageConfidence = 'low' | 'medium' | 'high';
+
+export declare type RetryTriageDecision = 'retry' | 'do_not_retry';
+
 export declare interface SandboxConfig {
     /** Snapshot build settings. */
     snapshot?: {
@@ -853,6 +901,12 @@ declare const TaskOutput: Type.TObject<{
         message: Type.TString;
         stack: Type.TOptional<Type.TString>;
         retryable: Type.TOptional<Type.TBoolean>;
+        retry: Type.TOptional<Type.TObject<{
+            source: Type.TUnion<[Type.TLiteral<"explicit">, Type.TLiteral<"deterministic">, Type.TLiteral<"attempts_exhausted">, Type.TLiteral<"triage">, Type.TLiteral<"triage_failed">]>;
+            decision: Type.TOptional<Type.TUnion<[Type.TLiteral<"retry">, Type.TLiteral<"do_not_retry">]>>;
+            confidence: Type.TOptional<Type.TUnion<[Type.TLiteral<"low">, Type.TLiteral<"medium">, Type.TLiteral<"high">]>>;
+            reason: Type.TOptional<Type.TString>;
+        }>>;
     }>>;
     contentSignature: Type.TOptional<Type.TString>;
 }>;

package/dist/index.js

@@ -1159,7 +1159,7 @@ var listDiaryPacks = (options) => (options.client ?? client).get({
 	...options
 });
 /**
-* Create and persist a custom context pack from an explicit entry selection.
+* Create and persist a custom context pack from an explicit entry selection. Returns 409 if any selected entry is flagged as a prompt-injection risk; the response lists the flagged entries. Set `force: true` to override and persist anyway.
 */
 var createDiaryCustomPack = (options) => (options.client ?? client).post({
 	security: [
@@ -2159,7 +2159,7 @@ var completeTask = (options) => (options.client ?? client).post({
 /**
 * Mark an attempt as failed with error details.
 */
-var failTask = (options) => (options.client ?? client).post({
+var failTaskAttempt = (options) => (options.client ?? client).post({
 	security: [
 		{
 			scheme: "bearer",
@@ -14019,6 +14019,27 @@ var TaskUsage = _Object_({
 	$id: "TaskUsage",
 	additionalProperties: false
 });
+var TaskRetryDecision = Union([Literal("retry"), Literal("do_not_retry")]);
+var TaskRetryConfidence = Union([
+	Literal("low"),
+	Literal("medium"),
+	Literal("high")
+]);
+var TaskRetryInfo = _Object_({
+	source: Union([
+		Literal("explicit"),
+		Literal("deterministic"),
+		Literal("attempts_exhausted"),
+		Literal("triage"),
+		Literal("triage_failed")
+	]),
+	decision: Optional(TaskRetryDecision),
+	confidence: Optional(TaskRetryConfidence),
+	reason: Optional(String$1())
+}, {
+	$id: "TaskRetryInfo",
+	additionalProperties: false
+});
 /**
 * Structured error returned from a failed attempt.
 */
@@ -14026,7 +14047,8 @@ var TaskError = _Object_({
 	code: String$1(),
 	message: String$1(),
 	stack: Optional(String$1()),
-	retryable: Optional(Boolean$1())
+	retryable: Optional(Boolean$1()),
+	retry: Optional(TaskRetryInfo)
 }, {
 	$id: "TaskError",
 	additionalProperties: false
@@ -14992,8 +15014,8 @@ function createTasksNamespace(context) {
 				body
 			}));
 		},
-		async fail(id, n, body) {
-			return unwrapResult(await failTask({
+		async failAttempt(id, n, body) {
+			return unwrapResult(await failTaskAttempt({
 				client,
 				auth,
 				path: {
@@ -26342,6 +26364,167 @@ function describeToolErrorMessage(result) {
 	}
 }
 //#endregion
+//#region src/runtime/retry-triage.ts
+var MAX_TRIAGE_JSON_CHARS = 12e3;
+var MAX_TRIAGE_FIELD_CHARS = 2e3;
+var REDACTED = "[redacted]";
+var SECRET_KEY_PATTERN = /(?:api[_-]?key|token|secret|password|passwd|credential|authorization|private[_-]?key|access[_-]?token|refresh[_-]?token)/i;
+function createPiRetryTriage(options) {
+	return async (input) => {
+		const cwd = options.cwd ?? process.cwd();
+		const capture = createRetryTriageTool();
+		const resourceLoader = new DefaultResourceLoader({
+			cwd,
+			agentDir: options.piAgentDir,
+			appendSystemPrompt: [TRIAGE_SYSTEM_PROMPT],
+			skillsOverride: () => ({
+				skills: [],
+				diagnostics: []
+			})
+		});
+		await resourceLoader.reload();
+		const sessionManager = SessionManager.inMemory(cwd);
+		const created = await createAgentSession({
+			agentDir: options.piAgentDir,
+			cwd,
+			model: options.model,
+			thinkingLevel: options.thinkingLevel ?? void 0,
+			customTools: [capture.tool],
+			sessionManager,
+			resourceLoader
+		});
+		await withTimeout(created.session.prompt(buildTriagePrompt(input)), options.timeoutMs ?? 3e4, () => created.session.abort());
+		const result = capture.getCaptured();
+		if (!result) throw new Error("Retry triage did not submit a decision");
+		return normalizeRetryTriageResult(result);
+	};
+}
+function createRetryTriageTool() {
+	let captured = null;
+	return {
+		tool: defineTool({
+			name: "submit_retry_triage",
+			label: "Submit retry triage",
+			description: "Submit the retry decision for a failed MoltNet task attempt.",
+			parameters: {
+				type: "object",
+				additionalProperties: false,
+				required: [
+					"decision",
+					"confidence",
+					"reason"
+				],
+				properties: {
+					decision: {
+						type: "string",
+						enum: ["retry", "do_not_retry"]
+					},
+					confidence: {
+						type: "string",
+						enum: [
+							"low",
+							"medium",
+							"high"
+						]
+					},
+					reason: {
+						type: "string",
+						minLength: 1
+					}
+				}
+			},
+			execute(_id, params) {
+				captured = normalizeRetryTriageResult(params);
+				return Promise.resolve({
+					content: [{
+						type: "text",
+						text: "Retry triage captured."
+					}],
+					details: captured,
+					terminate: true
+				});
+			}
+		}),
+		getCaptured: () => captured
+	};
+}
+function normalizeRetryTriageResult(value) {
+	const record = value && typeof value === "object" ? value : {};
+	return {
+		decision: record.decision === "retry" ? "retry" : "do_not_retry",
+		confidence: record.confidence === "high" || record.confidence === "medium" ? record.confidence : "low",
+		reason: typeof record.reason === "string" && record.reason.trim() ? record.reason.trim().slice(0, 500) : "retry triage did not provide a reason"
+	};
+}
+function buildTriagePrompt(input) {
+	const payload = {
+		task: {
+			id: input.task.id,
+			type: input.task.taskType,
+			teamId: input.task.teamId,
+			input: prepareTriagePayload(input.task.input)
+		},
+		attempt: {
+			attemptN: input.attemptN,
+			maxAttempts: input.maxAttempts ?? null,
+			remainingAttempts: input.remainingAttempts ?? null
+		},
+		error: prepareTriagePayload(input.error),
+		recentMessages: prepareTriagePayload((input.recentMessages ?? []).slice(-12))
+	};
+	return [
+		"Classify whether this failed task attempt should be retried.",
+		"",
+		"Retry only when a fresh attempt can plausibly recover without changing the task input.",
+		"Do not retry for policy, validation, credentials, cancellation, model/config, or task-contract failures.",
+		"Use confidence=low when evidence is weak; low confidence must choose do_not_retry.",
+		"Call submit_retry_triage exactly once.",
+		"",
+		truncateString(JSON.stringify(payload, null, 2), MAX_TRIAGE_JSON_CHARS)
+	].join("\n");
+}
+function prepareTriagePayload(value) {
+	return redactAndTruncate(value, []);
+}
+function redactAndTruncate(value, path) {
+	const currentKey = path[path.length - 1] ?? "";
+	if (SECRET_KEY_PATTERN.test(currentKey)) return REDACTED;
+	if (typeof value === "string") return truncateString(redactRetryTriageSecrets(value), MAX_TRIAGE_FIELD_CHARS);
+	if (Array.isArray(value)) return value.map((item, index) => redactAndTruncate(item, [...path, String(index)]));
+	if (value && typeof value === "object") {
+		const entries = Object.entries(value).map(([key, child]) => [key, redactAndTruncate(child, [...path, key])]);
+		return Object.fromEntries(entries);
+	}
+	return value;
+}
+function redactRetryTriageSecrets(value) {
+	return value.replace(/((?:bearer|basic)\s+)[a-z0-9._~+/=-]{16,}/gi, `$1${REDACTED}`).replace(/\bgh[pousr]_[a-z0-9_]{20,}\b/gi, REDACTED).replace(/\bsk-[a-z0-9_-]{16,}\b/gi, REDACTED).replace(/\beyJ[a-z0-9_-]{20,}\.[a-z0-9_-]{20,}\.[a-z0-9_-]{20,}\b/gi, REDACTED);
+}
+function truncateString(value, maxChars) {
+	if (value.length <= maxChars) return value;
+	return `${value.slice(0, maxChars)}...[truncated ${value.length - maxChars} chars]`;
+}
+var TRIAGE_SYSTEM_PROMPT = [
+	"You are MoltNet retry triage.",
+	"You classify one failed execution attempt, not the whole task.",
+	"Return retry only for likely transient/runtime failures or clear evidence a new attempt can recover.",
+	"The agent may have already tried local recovery; do not ask for more work."
+].join("\n");
+async function withTimeout(promise, timeoutMs, onTimeout) {
+	let timeout;
+	const timeoutPromise = new Promise((_, reject) => {
+		timeout = setTimeout(() => {
+			Promise.resolve(onTimeout?.()).catch(() => {});
+			reject(/* @__PURE__ */ new Error(`Retry triage timed out after ${timeoutMs}ms`));
+		}, timeoutMs);
+	});
+	try {
+		return await Promise.race([promise, timeoutPromise]);
+	} finally {
+		if (timeout) clearTimeout(timeout);
+	}
+}
+//#endregion
 //#region src/index.ts
 /**
 * @themoltnet/pi-extension — MoltNet pi extension
@@ -26642,4 +26825,4 @@ function moltnetExtension(pi) {
 	registerMoltnetReflectCommand(pi, state);
 }
 //#endregion
-export { HOST_EXEC_DEFAULT_BASE_ENV, activateAgentEnv, buildAgentSession, createGondolinBashOps, createGondolinEditOps, createGondolinReadOps, createGondolinWriteOps, createMoltNetTools, createPiOtelExtension, createPiTaskExecutor, createSubagentTool, moltnetExtension as default, ensureSnapshot, executePiTask, findMainWorktree, injectTaskContext, loadCredentials, resolveTaskWorktreePath, resumeVm, toGuestPath };
+export { HOST_EXEC_DEFAULT_BASE_ENV, activateAgentEnv, buildAgentSession, createGondolinBashOps, createGondolinEditOps, createGondolinReadOps, createGondolinWriteOps, createMoltNetTools, createPiOtelExtension, createPiRetryTriage, createPiTaskExecutor, createSubagentTool, moltnetExtension as default, ensureSnapshot, executePiTask, findMainWorktree, injectTaskContext, loadCredentials, normalizeRetryTriageResult, redactRetryTriageSecrets, resolveTaskWorktreePath, resumeVm, toGuestPath };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@themoltnet/pi-extension",
-  "version": "0.30.0",
+  "version": "0.31.0",
   "type": "module",
   "description": "MoltNet pi extension — sandboxed tool execution in Gondolin VMs with MoltNet identity and persistent memory",
   "keywords": [
@@ -36,8 +36,8 @@
     "@earendil-works/gondolin": "^0.9.1",
     "@opentelemetry/api": "^1.9.0",
     "typebox": "^1.2.8",
-    "@themoltnet/agent-runtime": "0.33.0",
-    "@themoltnet/sdk": "0.116.0"
+    "@themoltnet/agent-runtime": "0.33.1",
+    "@themoltnet/sdk": "0.117.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": ">=0.74.0",