@cjhyy/code-shell-capability-coding 0.9.29 → 0.9.31

package/dist/external-runtimes/claude-code/runtime.d.ts

@@ -29,12 +29,11 @@ export declare class ClaudeCodeRuntime {
     private readonly hooks;
     readonly kind: "claude-code";
     private readonly log;
-    private translator;
     private child?;
     private claudeSessionId?;
     private closed;
     private firstTurn;
-    private terminalSeen;
+    private turnCount;
     constructor(options: ClaudeRuntimeOptions, hooks?: ClaudeRuntimeHooks);
     /** Claude session id, once the first turn has reported it. Resume key only. */
     get runtimeSessionId(): string | undefined;
@@ -46,7 +45,7 @@ export declare class ClaudeCodeRuntime {
      * positional prompt after it is swallowed as another config value (measured),
      * and a prompt on the command line would also be visible in `ps`.
      */
-    send(input: ExternalRuntimeTurnInput): Promise<ClaudeTurnHandle>;
+    send(input: ExternalRuntimeTurnInput, onEvent?: (event: StreamEvent) => void): Promise<ClaudeTurnHandle>;
     private onLine;
     private emit;
     /**

package/dist/external-runtimes/claude-code/runtime.js

@@ -25,20 +25,15 @@ export class ClaudeCodeRuntime {
     hooks;
     kind = "claude-code";
     log;
-    translator;
     child;
     claudeSessionId;
     closed = false;
     firstTurn = true;
-    terminalSeen = false;
+    turnCount = 0;
     constructor(options, hooks = {}) {
         this.options = options;
         this.hooks = hooks;
         this.log = options.log ?? (() => { });
-        this.translator = new ClaudeEventTranslator({
-            sessionId: options.businessSessionId,
-            codeshellServerName: options.serverName ?? CLAUDE_MCP_SERVER_NAME,
-        });
         this.claudeSessionId = options.resumeRuntimeSessionId;
     }
     /** Claude session id, once the first turn has reported it. Resume key only. */
@@ -53,13 +48,18 @@ export class ClaudeCodeRuntime {
      * positional prompt after it is swallowed as another config value (measured),
      * and a prompt on the command line would also be visible in `ps`.
      */
-    async send(input) {
+    async send(input, onEvent) {
         if (this.closed)
             throw new Error("ClaudeCodeRuntime is closed");
         if (this.child)
             throw new Error("a turn is already running");
-        this.terminalSeen = false;
-        this.translator.beginTurn();
+        let terminalSeen = false;
+        const turnNumber = ++this.turnCount;
+        const translator = new ClaudeEventTranslator({
+            sessionId: this.options.businessSessionId,
+            codeshellServerName: this.options.serverName ?? CLAUDE_MCP_SERVER_NAME,
+        });
+        translator.beginTurn();
         const wiring = claudeBridgeArgs({
             bridge: this.options.bridge,
             exposedToolNames: this.options.exposedToolNames,
@@ -93,7 +93,13 @@ export class ClaudeCodeRuntime {
         this.child = child;
         child.stdout.setEncoding("utf8");
         const lines = createInterface({ input: child.stdout, crlfDelay: Infinity });
-        lines.on("line", (line) => this.onLine(line));
+        lines.on("line", (line) => {
+            this.onLine(line, translator, (event) => {
+                if (event.type === "turn_complete")
+                    terminalSeen = true;
+                this.emit(event.type === "stream_request_start" ? { ...event, turnNumber } : event, onEvent);
+            });
+        });
         child.stderr.setEncoding("utf8");
         child.stderr.on("data", (chunk) => {
             const trimmed = chunk.trim();
@@ -116,11 +122,11 @@ export class ClaudeCodeRuntime {
                 // Clean up the config file that carried the bearer token.
                 wiring.cleanup();
                 this.child = undefined;
-                if (!this.terminalSeen) {
+                if (!terminalSeen) {
                     const detail = error?.message ??
                         `Claude Code exited without a terminal result (code ${code ?? "unknown"})`;
-                    this.emit({ type: "error", error: detail });
-                    this.emit({ type: "turn_complete", reason: "model_error" });
+                    this.emit({ type: "error", error: detail }, onEvent);
+                    this.emit({ type: "turn_complete", reason: "model_error" }, onEvent);
                 }
                 resolve();
             };
@@ -132,7 +138,7 @@ export class ClaudeCodeRuntime {
         });
         return { done };
     }
-    onLine(line) {
+    onLine(line, translator, emit) {
         if (!line.trim())
             return;
         let parsed;
@@ -144,22 +150,19 @@ export class ClaudeCodeRuntime {
             this.log("claude.unparsable_line", { bytes: line.length });
             return;
         }
-        for (const event of this.translator.translate(parsed)) {
-            if (event.type === "turn_complete")
-                this.terminalSeen = true;
-            this.emit(event);
-        }
-        if (!this.claudeSessionId && this.translator.runtimeSessionId) {
-            this.claudeSessionId = this.translator.runtimeSessionId;
+        for (const event of translator.translate(parsed))
+            emit(event);
+        if (!this.claudeSessionId && translator.runtimeSessionId) {
+            this.claudeSessionId = translator.runtimeSessionId;
             this.log("claude.session_started", {
                 businessSessionId: this.options.businessSessionId,
                 runtimeSessionIdPrefix: this.claudeSessionId.slice(0, 8),
             });
         }
     }
-    emit(event) {
+    emit(event, onEvent) {
         try {
-            this.hooks.onEvent?.(event);
+            (onEvent ?? this.hooks.onEvent)?.(event);
         }
         catch (error) {
             this.log("claude.event_handler_failed", {
@@ -186,9 +189,6 @@ export class ClaudeCodeRuntime {
     /** Start a fresh conversation on the next `send()`, discarding resume state. */
     resetConversation() {
         this.claudeSessionId = undefined;
-        this.translator = new ClaudeEventTranslator({
-            sessionId: this.options.businessSessionId,
-            codeshellServerName: this.options.serverName ?? CLAUDE_MCP_SERVER_NAME,
-        });
+        this.turnCount = 0;
     }
 }

package/dist/external-runtimes/codex/runtime.d.ts

@@ -101,7 +101,7 @@ export declare class CodexRuntime {
      * tombstones are what keep a late `turn/started` from reactivating a session
      * that already reported terminal.
      */
-    send(input: ExternalRuntimeTurnInput): Promise<CodexTurnHandle>;
+    send(input: ExternalRuntimeTurnInput, onEvent?: (event: StreamEvent) => void): Promise<CodexTurnHandle>;
     /**
      * Interrupt the active turn.
      *

package/dist/external-runtimes/codex/runtime.js

@@ -122,12 +122,12 @@ export class CodexRuntime {
      * tombstones are what keep a late `turn/started` from reactivating a session
      * that already reported terminal.
      */
-    async send(input) {
+    async send(input, onEvent) {
         if (!this.threadId)
             throw new Error("CodexRuntime.send() before start()");
         let resolveDone;
         const done = new Promise((resolve) => (resolveDone = resolve));
-        this.activeTurn = { resolve: resolveDone };
+        this.activeTurn = { resolve: resolveDone, onEvent };
         let text = textWithAttachmentReferences(input);
         if (this.firstTurn && !this.resumed && this.options.initialContext) {
             text = `${this.options.initialContext}\n\n<current_user_request>\n${text}\n</current_user_request>`;
@@ -201,7 +201,7 @@ export class CodexRuntime {
     }
     emitEvent(event) {
         try {
-            this.hooks.onEvent?.(event);
+            (this.activeTurn?.onEvent ?? this.hooks.onEvent)?.(event);
         }
         catch (error) {
             this.log("runtime.event_handler_failed", {

package/dist/external-runtimes/session-factory.d.ts

@@ -19,7 +19,7 @@
  * Teardown reverses it, and unregisters before disposing the host so a late
  * request finds nothing rather than a disposed host (§13.4).
  */
-import type { PermissionRule, ToolDefinition } from "@cjhyy/code-shell-core/extension";
+import type { PermissionRule, StreamEvent, ToolDefinition } from "@cjhyy/code-shell-core/extension";
 import { createSessionToolHost, type ExternalToolExposurePolicy, type ToolVisibilityInputs } from "@cjhyy/code-shell-core/extension";
 import { type CodexRuntimeHooks, type CodexRuntimeOptions } from "./codex/runtime.js";
 import { type ClaudeRuntimeHooks } from "./claude-code/runtime.js";
@@ -83,7 +83,7 @@ export interface ExternalRuntimeSession {
     readonly runtimeSessionId: string | undefined;
     /** Tools actually exposed, after the allowlist and visibility guards. */
     listTools(): readonly ToolDefinition[];
-    send(input: ExternalRuntimeTurnInput): Promise<{
+    send(input: ExternalRuntimeTurnInput, onEvent?: (event: StreamEvent) => void): Promise<{
         done: Promise<void>;
     }>;
     interrupt(): Promise<void>;

package/dist/external-runtimes/session-factory.js

@@ -28,6 +28,7 @@ export async function startExternalRuntimeSession(options) {
     let host;
     let runtime;
     let closed = false;
+    let turnSink;
     const close = async () => {
         if (closed)
             return;
@@ -53,6 +54,9 @@ export async function startExternalRuntimeSession(options) {
             visibility: options.visibility,
             ...(options.approvalBackend ? { approvalBackend: options.approvalBackend } : {}),
             ...(options.contextOverrides ? { contextOverrides: options.contextOverrides } : {}),
+            // Outside a concrete provider call there is no run output owner. Never
+            // capture the lifetime callback and let it borrow a later active turn.
+            getStreamCallback: () => turnSink,
             ...(options.settingsScope ? { settingsScope: options.settingsScope } : {}),
         });
         // 3. Register before the runtime starts, so a tool call on the very first
@@ -116,7 +120,26 @@ export async function startExternalRuntimeSession(options) {
             return activeRuntime.runtimeSessionId;
         },
         listTools: () => activeHost.listTools(),
-        send: (input) => activeRuntime.send(input),
+        send: async (input, onEvent) => {
+            if (turnSink)
+                throw new Error("An external runtime turn is already running");
+            const sink = onEvent ?? options.hooks?.onEvent;
+            turnSink = sink;
+            try {
+                const turn = await activeRuntime.send(input, sink);
+                return {
+                    done: turn.done.finally(() => {
+                        if (turnSink === sink)
+                            turnSink = undefined;
+                    }),
+                };
+            }
+            catch (error) {
+                if (turnSink === sink)
+                    turnSink = undefined;
+                throw error;
+            }
+        },
         interrupt: () => activeRuntime.interrupt(),
         close,
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cjhyy/code-shell-capability-coding",
-  "version": "0.9.29",
+  "version": "0.9.31",
   "description": "Coding capability pack for the generic code-shell agent core.",
   "type": "module",
   "main": "./dist/index.js",
@@ -39,7 +39,7 @@
     "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\""
   },
   "dependencies": {
-    "@cjhyy/code-shell-core": "0.9.29"
+    "@cjhyy/code-shell-core": "0.9.31"
   },
   "engines": {
     "node": ">=20.10"