@code-yeongyu/senpi 2026.6.6-3 → 2026.6.10-2

package/examples/extensions/custom-provider-gitlab-duo/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-extension-custom-provider-gitlab-duo",
   "private": true,
-  "version": "0.78.1",
+  "version": "0.79.1",
   "type": "module",
   "scripts": {
     "clean": "echo 'nothing to clean'",

package/examples/extensions/gondolin/package-lock.json

@@ -1,12 +1,12 @@
 {
 	"name": "pi-extension-gondolin",
-	"version": "0.78.1",
+	"version": "0.79.1",
 	"lockfileVersion": 3,
 	"requires": true,
 	"packages": {
 		"": {
 			"name": "pi-extension-gondolin",
-			"version": "0.78.1",
+			"version": "0.79.1",
 			"dependencies": {
 				"@earendil-works/gondolin": "0.12.0"
 			}

package/examples/extensions/gondolin/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "pi-extension-gondolin",
 	"private": true,
-	"version": "0.78.1",
+	"version": "0.79.1",
 	"type": "module",
 	"scripts": {
 		"clean": "echo 'nothing to clean'",

package/examples/extensions/project-trust.ts

@@ -0,0 +1,64 @@
+/**
+ * Project Trust Extension
+ *
+ * Demonstrates the project_trust event. Install globally or pass via -e:
+ *
+ *   mkdir -p ~/.pi/agent/extensions
+ *   cp packages/coding-agent/examples/extensions/project-trust.ts ~/.pi/agent/extensions/
+ *
+ * Or:
+ *
+ *   pi -e packages/coding-agent/examples/extensions/project-trust.ts
+ *
+ * Try it in a project containing .pi, AGENTS.md/CLAUDE.md, or .agents/skills.
+ */
+
+import type { ExtensionAPI, ProjectTrustEventResult } from "@earendil-works/pi-coding-agent";
+
+export default function (pi: ExtensionAPI) {
+	let loadCount = 0;
+	loadCount++;
+
+	// Multiple handlers in one extension are allowed. The first handler that returns
+	// { trusted: "yes" } or { trusted: "no" } wins and suppresses the built-in
+	// trust prompt. Return { trusted: "undecided" } to let another handler or the
+	// built-in flow decide.
+	pi.on("project_trust", async (event, ctx): Promise<ProjectTrustEventResult> => {
+		ctx.ui.notify(`project_trust fired for ${event.cwd} (mode: ${ctx.mode}, load: ${loadCount})`, "info");
+
+		if (!ctx.hasUI) {
+			return { trusted: "undecided" };
+		}
+
+		const choice = await ctx.ui.select(`Project trust for:\n${event.cwd}`, [
+			"Trust and remember",
+			"Trust with note and remember",
+			"Trust this session",
+			"Do not trust this session",
+			"Let built-in prompt decide",
+		]);
+
+		if (choice === "Trust with note and remember") {
+			const note = await ctx.ui.input("Project trust note", "Optional note for this demo");
+			ctx.ui.notify(note ? `Recorded demo note: ${note}` : "No demo note entered", "info");
+			return { trusted: "yes", remember: true };
+		}
+		if (choice === "Trust and remember") {
+			return { trusted: "yes", remember: true };
+		}
+		if (choice === "Trust this session") {
+			return { trusted: "yes" };
+		}
+		if (choice === "Do not trust this session") {
+			return { trusted: "no" };
+		}
+		if (choice === "Let built-in prompt decide") {
+			return { trusted: "undecided" };
+		}
+		return { trusted: "undecided" };
+	});
+
+	pi.on("session_start", (_event, ctx) => {
+		ctx.ui.notify(`project-trust example loaded after trust resolution in ${ctx.cwd}`, "info");
+	});
+}

package/examples/extensions/sandbox/package-lock.json

@@ -1,12 +1,12 @@
 {
 	"name": "pi-extension-sandbox",
-	"version": "1.8.1",
+	"version": "1.9.1",
 	"lockfileVersion": 3,
 	"requires": true,
 	"packages": {
 		"": {
 			"name": "pi-extension-sandbox",
-			"version": "1.8.1",
+			"version": "1.9.1",
 			"dependencies": {
 				"@anthropic-ai/sandbox-runtime": "^0.0.26"
 			}

package/examples/extensions/sandbox/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "pi-extension-sandbox",
 	"private": true,
-	"version": "1.8.1",
+	"version": "1.9.1",
 	"type": "module",
 	"scripts": {
 		"clean": "echo 'nothing to clean'",

package/examples/extensions/with-deps/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "pi-extension-with-deps",
-  "version": "0.78.1",
+  "version": "0.79.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pi-extension-with-deps",
-      "version": "0.78.1",
+      "version": "0.79.1",
       "dependencies": {
         "ms": "^2.1.3"
       },

package/examples/extensions/with-deps/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-extension-with-deps",
   "private": true,
-  "version": "0.78.1",
+  "version": "0.79.1",
   "type": "module",
   "scripts": {
     "clean": "echo 'nothing to clean'",

package/node_modules/@earendil-works/pi-agent-core/README.md

@@ -106,7 +106,7 @@ Tool execution mode is configurable:
 
 In parallel mode, tool completion events follow tool completion order, but persisted toolResult messages still follow assistant source order.
 
-The mode can be set globally via `toolExecution` in the agent config, or per-tool via `executionMode` on `AgentTool`. If any tool call in a batch targets a tool with `executionMode: "sequential"`, the entire batch executes sequentially regardless of the global setting.
+The mode can be set globally via `toolExecution` in the agent config, or per-tool via `executionMode` on `AgentTool`. In parallel mode, a tool call targeting a tool with `executionMode: "sequential"` runs as an exclusive barrier: it waits for all previously scheduled calls in the batch to finish, and later calls wait for it to complete. Parallel tools before or after the barrier still execute concurrently with each other.
 
 The `beforeToolCall` hook runs after `tool_execution_start` and validated argument parsing. It can block execution. The `afterToolCall` hook runs after tool execution finishes and before `tool_execution_end` and final tool result message events are emitted.
 
@@ -164,7 +164,7 @@ const agent = new Agent({
   initialState: {
     systemPrompt: string,
     model: Model<any>,
-    thinkingLevel: "off" | "minimal" | "low" | "medium" | "high" | "xhigh",
+    thinkingLevel: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max", // "max" is Anthropic-only adaptive thinking effort
     tools: AgentTool<any>[],
     messages: AgentMessage[],
   },
@@ -391,7 +391,8 @@ const readFileTool: AgentTool = {
     path: Type.String({ description: "File path" }),
   }),
   // Override execution mode for this tool (optional).
-  // "sequential" forces the entire batch to run one at a time.
+  // "sequential" makes this tool an exclusive barrier in parallel batches:
+  // it runs alone, but parallel tools before or after it still run concurrently.
   // "parallel" allows concurrent execution with other tool calls.
   // If omitted, the global toolExecution config applies.
   executionMode: "sequential",

package/node_modules/@earendil-works/pi-agent-core/dist/agent-loop.js

@@ -213,54 +213,60 @@ async function streamAssistantResponse(context, config, signal, emit, streamFn)
             signal,
         });
         const iterator = response[Symbol.asyncIterator]();
-        while (true) {
-            const next = await readNextAssistantEvent(iterator, config.timeoutMs, signal);
-            if (next.done)
-                break;
-            const event = next.value;
-            switch (event.type) {
-                case "start":
-                    partialMessage = event.partial;
-                    context.messages.push(partialMessage);
-                    addedPartial = true;
-                    await emit({ type: "message_start", message: { ...partialMessage } });
+        const eventReader = createAssistantEventReader(iterator, config.timeoutMs, signal);
+        try {
+            while (true) {
+                const next = await eventReader.next();
+                if (next.done)
                     break;
-                case "text_start":
-                case "text_delta":
-                case "text_end":
-                case "thinking_start":
-                case "thinking_delta":
-                case "thinking_end":
-                case "toolcall_start":
-                case "toolcall_delta":
-                case "toolcall_end":
-                    if (partialMessage) {
+                const event = next.value;
+                switch (event.type) {
+                    case "start":
                         partialMessage = event.partial;
-                        context.messages[context.messages.length - 1] = partialMessage;
-                        await emit({
-                            type: "message_update",
-                            assistantMessageEvent: event,
-                            message: { ...partialMessage },
-                        });
-                    }
-                    break;
-                case "done":
-                case "error": {
-                    const finalMessage = normalizeTerminalAssistantMessage(await response.result(), event);
-                    if (addedPartial) {
-                        context.messages[context.messages.length - 1] = finalMessage;
+                        context.messages.push(partialMessage);
+                        addedPartial = true;
+                        await emit({ type: "message_start", message: { ...partialMessage } });
+                        break;
+                    case "text_start":
+                    case "text_delta":
+                    case "text_end":
+                    case "thinking_start":
+                    case "thinking_delta":
+                    case "thinking_end":
+                    case "toolcall_start":
+                    case "toolcall_delta":
+                    case "toolcall_end":
+                        if (partialMessage) {
+                            partialMessage = event.partial;
+                            context.messages[context.messages.length - 1] = partialMessage;
+                            await emit({
+                                type: "message_update",
+                                assistantMessageEvent: event,
+                                message: { ...partialMessage },
+                            });
+                        }
+                        break;
+                    case "done":
+                    case "error": {
+                        const finalMessage = normalizeTerminalAssistantMessage(await response.result(), event);
+                        if (addedPartial) {
+                            context.messages[context.messages.length - 1] = finalMessage;
+                        }
+                        else {
+                            context.messages.push(finalMessage);
+                        }
+                        if (!addedPartial) {
+                            await emit({ type: "message_start", message: { ...finalMessage } });
+                        }
+                        await emit({ type: "message_end", message: finalMessage });
+                        return finalMessage;
                     }
-                    else {
-                        context.messages.push(finalMessage);
-                    }
-                    if (!addedPartial) {
-                        await emit({ type: "message_start", message: { ...finalMessage } });
-                    }
-                    await emit({ type: "message_end", message: finalMessage });
-                    return finalMessage;
                 }
             }
         }
+        finally {
+            eventReader.dispose();
+        }
         const finalMessage = await response.result();
         if (addedPartial) {
             context.messages[context.messages.length - 1] = finalMessage;
@@ -285,16 +291,39 @@ async function streamAssistantResponse(context, config, signal, emit, streamFn)
         return finalMessage;
     }
 }
-async function readNextAssistantEvent(iterator, timeoutMs, signal) {
+const ABORTED = Symbol("aborted");
+function createAssistantEventReader(iterator, timeoutMs, signal) {
     const idleTimeoutMs = typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : undefined;
-    if (idleTimeoutMs === undefined && signal === undefined) {
-        return iterator.next();
+    let removeAbortListener;
+    let abortPromise;
+    if (signal !== undefined) {
+        if (signal.aborted) {
+            abortPromise = Promise.resolve(ABORTED);
+        }
+        else {
+            abortPromise = new Promise((resolve) => {
+                const abortHandler = () => resolve(ABORTED);
+                signal.addEventListener("abort", abortHandler, { once: true });
+                removeAbortListener = () => signal.removeEventListener("abort", abortHandler);
+            });
+        }
     }
-    if (signal?.aborted) {
-        throw new Error("Request was aborted");
+    return {
+        next: () => {
+            if (signal?.aborted) {
+                void iterator.return?.();
+                return Promise.reject(new Error("Request was aborted"));
+            }
+            return readNextAssistantEvent(iterator, idleTimeoutMs, abortPromise);
+        },
+        dispose: () => removeAbortListener?.(),
+    };
+}
+async function readNextAssistantEvent(iterator, idleTimeoutMs, abortPromise) {
+    if (idleTimeoutMs === undefined && abortPromise === undefined) {
+        return iterator.next();
     }
     let timeout;
-    let abortHandler;
     let settled = false;
     return new Promise((resolve, reject) => {
         const settle = (complete) => {
@@ -304,9 +333,6 @@ async function readNextAssistantEvent(iterator, timeoutMs, signal) {
             if (timeout !== undefined) {
                 clearTimeout(timeout);
             }
-            if (abortHandler !== undefined) {
-                signal?.removeEventListener("abort", abortHandler);
-            }
             complete();
         };
         if (idleTimeoutMs !== undefined) {
@@ -315,14 +341,15 @@ async function readNextAssistantEvent(iterator, timeoutMs, signal) {
                 settle(() => reject(new StreamIdleTimeoutError(idleTimeoutMs)));
             }, idleTimeoutMs);
         }
-        if (signal !== undefined) {
-            abortHandler = () => {
+        const next = abortPromise ? Promise.race([iterator.next(), abortPromise]) : iterator.next();
+        void next.then((result) => {
+            if (result === ABORTED) {
                 void iterator.return?.();
                 settle(() => reject(new Error("Request was aborted")));
-            };
-            signal.addEventListener("abort", abortHandler, { once: true });
-        }
-        void iterator.next().then((result) => settle(() => resolve(result)), (error) => settle(() => reject(error)));
+                return;
+            }
+            settle(() => resolve(result));
+        }, (error) => settle(() => reject(error)));
     });
 }
 /**
@@ -330,8 +357,7 @@ async function readNextAssistantEvent(iterator, timeoutMs, signal) {
  */
 async function executeToolCalls(currentContext, assistantMessage, config, signal, emit) {
     const toolCalls = assistantMessage.content.filter((c) => c.type === "toolCall");
-    const hasSequentialToolCall = toolCalls.some((tc) => currentContext.tools?.find((t) => t.name === tc.name)?.executionMode === "sequential");
-    if (config.toolExecution === "sequential" || hasSequentialToolCall) {
+    if (config.toolExecution === "sequential") {
         return executeToolCallsSequential(currentContext, assistantMessage, toolCalls, config, signal, emit);
     }
     return executeToolCallsParallel(currentContext, assistantMessage, toolCalls, config, signal, emit);
@@ -406,6 +432,8 @@ async function executeToolCallsSequential(currentContext, assistantMessage, tool
 }
 async function executeToolCallsParallel(currentContext, assistantMessage, toolCalls, config, signal, emit) {
     const finalizedCalls = [];
+    let lastSequentialCall;
+    let currentParallelWave = [];
     for (const toolCall of toolCalls) {
         await emit({
             type: "tool_execution_start",
@@ -414,30 +442,31 @@ async function executeToolCallsParallel(currentContext, assistantMessage, toolCa
             args: toolCall.arguments,
         });
         const preparation = await prepareToolCall(currentContext, assistantMessage, toolCall, config, signal);
-        if (preparation.kind === "immediate") {
-            const finalized = {
-                toolCall,
-                result: preparation.result,
-                isError: preparation.isError,
-            };
-            await emitToolExecutionEnd(finalized, emit);
-            finalizedCalls.push(finalized);
-            if (signal?.aborted) {
-                break;
-            }
-            continue;
-        }
-        finalizedCalls.push(async () => {
-            const executed = await executePreparedToolCall(preparation, signal, emit);
-            const finalized = await finalizeExecutedToolCall(currentContext, assistantMessage, preparation, executed, config, signal);
+        const isSequential = isSequentialToolCall(currentContext, toolCall);
+        const dependencies = isSequential
+            ? [...(lastSequentialCall ? [lastSequentialCall] : []), ...currentParallelWave]
+            : lastSequentialCall
+                ? [lastSequentialCall]
+                : [];
+        const finalizedCall = (async () => {
+            await Promise.all(dependencies);
+            const finalized = await runPreparedToolCall(currentContext, assistantMessage, preparation, config, signal, emit);
             await emitToolExecutionEnd(finalized, emit);
             return finalized;
-        });
+        })();
+        finalizedCalls.push(finalizedCall);
+        if (isSequential) {
+            lastSequentialCall = finalizedCall;
+            currentParallelWave = [];
+        }
+        else {
+            currentParallelWave.push(finalizedCall);
+        }
         if (signal?.aborted) {
             break;
         }
     }
-    const orderedFinalizedCalls = await Promise.all(finalizedCalls.map((entry) => (typeof entry === "function" ? entry() : Promise.resolve(entry))));
+    const orderedFinalizedCalls = await Promise.all(finalizedCalls);
     const messages = [];
     for (const finalized of orderedFinalizedCalls) {
         const toolResultMessage = createToolResultMessage(finalized);
@@ -449,6 +478,20 @@ async function executeToolCallsParallel(currentContext, assistantMessage, toolCa
         terminate: shouldTerminateToolBatch(orderedFinalizedCalls),
     };
 }
+async function runPreparedToolCall(currentContext, assistantMessage, preparation, config, signal, emit) {
+    if (preparation.kind === "immediate") {
+        return {
+            toolCall: preparation.toolCall,
+            result: preparation.result,
+            isError: preparation.isError,
+        };
+    }
+    const executed = await executePreparedToolCall(preparation, signal, emit);
+    return finalizeExecutedToolCall(currentContext, assistantMessage, preparation, executed, config, signal);
+}
+function isSequentialToolCall(currentContext, toolCall) {
+    return currentContext.tools?.find((tool) => tool.name === toolCall.name)?.executionMode === "sequential";
+}
 function shouldTerminateToolBatch(finalizedCalls) {
     return finalizedCalls.length > 0 && finalizedCalls.every((finalized) => finalized.result.terminate === true);
 }
@@ -470,6 +513,7 @@ async function prepareToolCall(currentContext, assistantMessage, toolCall, confi
     if (!tool) {
         return {
             kind: "immediate",
+            toolCall,
             result: createErrorToolResult(`Tool ${toolCall.name} not found`),
             isError: true,
         };
@@ -487,6 +531,7 @@ async function prepareToolCall(currentContext, assistantMessage, toolCall, confi
             if (signal?.aborted) {
                 return {
                     kind: "immediate",
+                    toolCall,
                     result: createErrorToolResult("Operation aborted"),
                     isError: true,
                 };
@@ -494,6 +539,7 @@ async function prepareToolCall(currentContext, assistantMessage, toolCall, confi
             if (beforeResult?.block) {
                 return {
                     kind: "immediate",
+                    toolCall,
                     result: createErrorToolResult(beforeResult.reason || "Tool execution was blocked"),
                     isError: true,
                 };
@@ -502,6 +548,7 @@ async function prepareToolCall(currentContext, assistantMessage, toolCall, confi
         if (signal?.aborted) {
             return {
                 kind: "immediate",
+                toolCall,
                 result: createErrorToolResult("Operation aborted"),
                 isError: true,
             };
@@ -516,6 +563,7 @@ async function prepareToolCall(currentContext, assistantMessage, toolCall, confi
     catch (error) {
         return {
             kind: "immediate",
+            toolCall,
             result: createErrorToolResult(error instanceof Error ? error.message : String(error)),
             isError: true,
         };