agent-sh 0.3.0 → 0.3.1

package/dist/acp-client.js

@@ -21,7 +21,7 @@ export class AcpClient {
     terminalDonePromises = new Map();
     terminalCounter = 0;
     fileWatcher;
-    pendingToolCalls = new Map(); // toolCallId → title
+    pendingToolCalls = new Map();
     autoCancelled = false;
     pendingToolCounter = 0;
     agentInfo = null;
@@ -146,19 +146,15 @@ export class AcpClient {
         const contextBlock = this.contextManager.getContext();
         try {
             this.log("sending prompt...");
-            const promptTimeoutMs = 300000; // 5 minutes timeout for LLM response
-            const response = await Promise.race([
-                this.connection.prompt({
-                    sessionId: this.sessionId,
-                    prompt: [
-                        {
-                            type: "text",
-                            text: contextBlock + "\n" + query,
-                        },
-                    ],
-                }),
-                new Promise((_, reject) => setTimeout(() => reject(new Error(`Prompt timeout after ${promptTimeoutMs}ms`)), promptTimeoutMs)),
-            ]);
+            const response = await this.connection.prompt({
+                sessionId: this.sessionId,
+                prompt: [
+                    {
+                        type: "text",
+                        text: contextBlock + "\n" + query,
+                    },
+                ],
+            });
             this.log(`prompt resolved: stopReason=${response.stopReason}`);
             if (response.stopReason === "cancelled") {
                 cancelled = true;
@@ -176,7 +172,7 @@ export class AcpClient {
         finally {
             this.log("restoring shell mode");
             if (!cancelled) {
-                this.bus.emit("agent:response-done", {
+                this.bus.emitTransform("agent:response-done", {
                     response: this.currentResponseText,
                 });
             }
@@ -327,8 +323,15 @@ export class AcpClient {
     createClientHandler() {
         return {
             // Required: handle session update notifications (streaming)
+            // Errors must not propagate — the ACP SDK returns them as error
+            // responses to the agent, which can stall the stream.
             sessionUpdate: async (params) => {
-                this.handleSessionUpdate(params);
+                try {
+                    this.handleSessionUpdate(params);
+                }
+                catch (err) {
+                    this.log(`Error in sessionUpdate handler: ${err instanceof Error ? err.stack : err}`);
+                }
             },
             // Required: handle permission requests
             requestPermission: async (params) => {
@@ -370,40 +373,53 @@ export class AcpClient {
                 const content = update.content;
                 if (content.type === "text") {
                     this.currentResponseText += content.text;
-                    this.bus.emit("agent:response-chunk", { text: content.text });
+                    this.bus.emitTransform("agent:response-chunk", { text: content.text });
                 }
                 break;
             }
             case "agent_thought_chunk": {
                 const thought = update.content;
                 if (thought.type === "text" && thought.text) {
-                    this.bus.emit("agent:thinking-chunk", { text: thought.text });
+                    this.bus.emitTransform("agent:thinking-chunk", { text: thought.text });
                 }
                 break;
             }
             case "tool_call": {
                 const toolId = update.toolCallId || `tool-${this.pendingToolCounter++}`;
-                this.pendingToolCalls.set(toolId, update.title ?? "");
-                this.bus.emit("agent:tool-started", {
+                const payload = {
                     title: update.title,
                     toolCallId: toolId,
                     kind: update.kind ?? undefined,
                     locations: update.locations?.map((l) => ({ path: l.path, line: l.line })),
                     rawInput: update.rawInput,
+                };
+                const defer = this.pendingToolCalls.size > 0;
+                this.pendingToolCalls.set(toolId, {
+                    title: update.title ?? "",
+                    deferredPayload: defer ? payload : undefined,
                 });
+                if (!defer) {
+                    this.bus.emit("agent:tool-started", payload);
+                }
                 break;
             }
             case "tool_call_update": {
                 const toolId = update.toolCallId;
-                const toolTitle = toolId ? this.pendingToolCalls.get(toolId) : undefined;
+                const toolInfo = toolId ? this.pendingToolCalls.get(toolId) : undefined;
+                const toolTitle = toolInfo?.title;
                 if (update.status === "completed" || update.status === "failed") {
+                    // Emit deferred tool-started before output (parallel tools)
+                    if (toolInfo?.deferredPayload) {
+                        this.bus.emit("agent:tool-started", toolInfo.deferredPayload);
+                        toolInfo.deferredPayload = undefined;
+                    }
                     // Show content only on final status. Skip tools whose output the
                     // user already sees (user_shell → PTY) or is agent-only (shell_recall).
                     const skipOutput = toolTitle === "user_shell" || toolTitle === "shell_recall";
                     if (!skipOutput && update.content && Array.isArray(update.content)) {
                         for (const block of update.content) {
                             if (block.type === "content" && block.content?.type === "text" && block.content.text) {
-                                this.bus.emit("agent:tool-output-chunk", { chunk: block.content.text });
+                                this.bus.emitTransform("agent:tool-output-chunk", { chunk: block.content.text });
                             }
                         }
                     }

package/dist/core.js

@@ -20,11 +20,15 @@ import { EventBus } from "./event-bus.js";
 import { ContextManager } from "./context-manager.js";
 import { AcpClient } from "./acp-client.js";
 import { setPalette } from "./utils/palette.js";
+import * as streamTransform from "./utils/stream-transform.js";
+import * as settingsMod from "./settings.js";
+import { HandlerRegistry } from "./utils/handler-registry.js";
 // Re-export types that library consumers need
 export { EventBus } from "./event-bus.js";
 export { palette, setPalette, resetPalette } from "./utils/palette.js";
 export function createCore(config) {
     const bus = new EventBus();
+    const handlers = new HandlerRegistry();
     const contextManager = new ContextManager(bus);
     const client = new AcpClient({ bus, contextManager, config });
     let connected = false;
@@ -67,6 +71,12 @@ export function createCore(config) {
                 getAcpClient: () => client,
                 quit: opts.quit,
                 setPalette,
+                createBlockTransform: (o) => streamTransform.createBlockTransform(bus, o),
+                createFencedBlockTransform: (o) => streamTransform.createFencedBlockTransform(bus, o),
+                getExtensionSettings: settingsMod.getExtensionSettings,
+                define: (name, fn) => handlers.define(name, fn),
+                advise: (name, wrapper) => handlers.advise(name, wrapper),
+                call: (name, ...args) => handlers.call(name, ...args),
             };
         },
         kill() {

package/dist/event-bus.d.ts

@@ -32,6 +32,7 @@ export interface ShellEvents {
     };
     "agent:response-chunk": {
         text: string;
+        blocks?: ContentBlock[];
     };
     "agent:response-done": {
         response: string;
@@ -126,6 +127,20 @@ export interface ShellEvents {
         }[];
     };
 }
+export type ContentBlock = {
+    type: "text";
+    text: string;
+} | {
+    type: "code-block";
+    language: string;
+    code: string;
+} | {
+    type: "image";
+    data: Buffer;
+} | {
+    type: "raw";
+    escape: string;
+};
 type Listener<T> = (payload: T) => void;
 type PipeListener<T> = (payload: T) => T;
 type AsyncPipeListener<T> = (payload: T) => T | Promise<T>;
@@ -145,6 +160,13 @@ export declare class EventBus {
     off<K extends keyof ShellEvents>(event: K, fn: Listener<ShellEvents[K]>): void;
     /** Emit a fire-and-forget event. */
     emit<K extends keyof ShellEvents>(event: K, payload: ShellEvents[K]): void;
+    /**
+     * Transform-then-notify: run the payload through any registered pipe
+     * listeners (transforms), then emit the final result to regular `on`
+     * listeners (renderers). This enables content pipelines where extensions
+     * modify data (e.g. render LaTeX → terminal image) before renderers see it.
+     */
+    emitTransform<K extends keyof ShellEvents>(event: K, payload: ShellEvents[K]): void;
     /** Register a transform listener for a pipeline event. */
     onPipe<K extends keyof ShellEvents>(event: K, fn: PipeListener<ShellEvents[K]>): void;
     /**

package/dist/event-bus.js

@@ -21,6 +21,16 @@ export class EventBus {
     emit(event, payload) {
         this.emitter.emit(event, payload);
     }
+    /**
+     * Transform-then-notify: run the payload through any registered pipe
+     * listeners (transforms), then emit the final result to regular `on`
+     * listeners (renderers). This enables content pipelines where extensions
+     * modify data (e.g. render LaTeX → terminal image) before renderers see it.
+     */
+    emitTransform(event, payload) {
+        const transformed = this.emitPipe(event, payload);
+        this.emitter.emit(event, transformed);
+    }
     /** Register a transform listener for a pipeline event. */
     onPipe(event, fn) {
         let listeners = this.pipeListeners.get(event);

package/dist/extensions/tui-renderer.d.ts

@@ -1,2 +1,2 @@
 import type { ExtensionContext } from "../types.js";
-export default function activate({ bus, getAcpClient }: ExtensionContext): void;
+export default function activate(ctx: ExtensionContext): void;