@code-yeongyu/senpi-agent-core 2026.9.3 → 2026.9.4-3

package/dist/agent-loop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-loop.d.ts","sourceRoot":"","sources":["../src/agent-loop.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAIN,KAAK,OAAO,EAEZ,WAAW,EAIX,MAAM,uBAAuB,CAAC;AAU/B,OAAO,KAAK,EACX,YAAY,EACZ,UAAU,EACV,eAAe,EAEf,YAAY,EACZ,SAAS,EACT,aAAa,EAEb,QAAQ,EACR,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,cAAc,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAEzE;;;GAGG;AACH,wBAAgB,SAAS,CACxB,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CAiBzC;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAChC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CAwBzC;AAED,wBAAsB,YAAY,CACjC,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,OAAO,CAAC,YAAY,EAAE,CAAC,CAgBzB;AAED,wBAAsB,oBAAoB,CACzC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,OAAO,CAAC,YAAY,EAAE,CAAC,CAiBzB;AAmBD,qBAAa,uBAAwB,SAAQ,KAAK;gBACrC,SAAS,EAAE,MAAM;CAM7B;AAqPD,uGAAuG;AACvG,wBAAsB,oBAAoB,CACzC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,IAAI,CAAC,eAAe,EAAE,cAAc,GAAG,kBAAkB,CAAC,EAClE,MAAM,CAAC,EAAE,WAAW,GAClB,OAAO,CAAC,OAAO,CAAC,CAgBlB;AA+lBD,MAAM,WAAW,qBAAqB;IACrC,QAAQ,EAAE,aAAa,CAAC;IACxB,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,OAAO,CAAC;CACd;AAED,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,aAAa,GAAG,aAAa,CAYrG;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,aAAa,GAAG,qBAAqB,CAOpG"}
+{"version":3,"file":"agent-loop.d.ts","sourceRoot":"","sources":["../src/agent-loop.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAIN,KAAK,OAAO,EAEZ,WAAW,EAIX,MAAM,uBAAuB,CAAC;AAU/B,OAAO,KAAK,EACX,YAAY,EACZ,UAAU,EACV,eAAe,EAEf,YAAY,EACZ,SAAS,EACT,aAAa,EAEb,QAAQ,EACR,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,cAAc,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAEzE;;;GAGG;AACH,wBAAgB,SAAS,CACxB,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CAiBzC;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAChC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CAwBzC;AAED,wBAAsB,YAAY,CACjC,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,OAAO,CAAC,YAAY,EAAE,CAAC,CAgBzB;AAED,wBAAsB,oBAAoB,CACzC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,OAAO,CAAC,YAAY,EAAE,CAAC,CAiBzB;AAmBD,qBAAa,uBAAwB,SAAQ,KAAK;gBACrC,SAAS,EAAE,MAAM;CAM7B;AA2ND,uGAAuG;AACvG,wBAAsB,oBAAoB,CACzC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,IAAI,CAAC,eAAe,EAAE,cAAc,GAAG,kBAAkB,CAAC,EAClE,MAAM,CAAC,EAAE,WAAW,GAClB,OAAO,CAAC,OAAO,CAAC,CAIlB;AA+mBD,MAAM,WAAW,qBAAqB;IACrC,QAAQ,EAAE,aAAa,CAAC;IACxB,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,OAAO,CAAC;CACd;AAED,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,aAAa,GAAG,aAAa,CAYrG;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,aAAa,GAAG,qBAAqB,CAOpG"}

package/dist/agent-loop.js

@@ -96,9 +96,8 @@ async function runLoop(initialContext, newMessages, initialConfig, signal, emit,
     let config = initialConfig;
     let firstTurn = true;
     let firstProviderRequest = true;
-    // Check for steering messages at start (user may have typed while waiting)
-    let pendingMessages = (await config.getSteeringMessages?.()) || [];
     let drainedTerminatingQueue;
+    let turnStartAlreadyEmitted = false;
     const refreshTerminatingQueueDrain = async () => {
         if (!drainedTerminatingQueue || !config.restorePendingMessages)
             return;
@@ -110,12 +109,17 @@ async function runLoop(initialContext, newMessages, initialConfig, signal, emit,
             drainedTerminatingQueue = pendingMessages.length > 0 ? "followUp" : undefined;
         }
     };
+    // Check for steering messages at start (user may have typed while waiting)
+    let pendingMessages = (await config.getSteeringMessages?.()) || [];
     // Outer loop: continues when queued follow-up messages arrive after agent would stop
     while (true) {
         let hasMoreToolCalls = true;
         // Inner loop: process tool calls and steering messages
         while (hasMoreToolCalls || pendingMessages.length > 0) {
-            if (!firstTurn) {
+            if (turnStartAlreadyEmitted) {
+                turnStartAlreadyEmitted = false;
+            }
+            else if (!firstTurn) {
                 await emit({ type: "turn_start" });
             }
             else {
@@ -139,10 +143,7 @@ async function runLoop(initialContext, newMessages, initialConfig, signal, emit,
                 }
                 pendingMessages = [];
             }
-            // Stream assistant response. Continuation-scoped overrides apply to one
-            // provider request only. Once that request emits its first event, the
-            // configured idle timeout resumes so healthy reasoning gaps are not bound
-            // by the short liveness probe.
+            // Stream assistant response
             const isInitialProviderRequest = firstProviderRequest;
             firstProviderRequest = false;
             const requestConfig = isInitialProviderRequest
@@ -152,16 +153,10 @@ async function runLoop(initialContext, newMessages, initialConfig, signal, emit,
                     streamStartTimeoutMs: config.initialRequestStreamStartTimeoutMs ?? config.streamStartTimeoutMs,
                 }
                 : config;
-            const streamIdleTimeoutMs = isInitialProviderRequest ? config.timeoutMs : requestConfig.timeoutMs;
-            const streamed = await streamAssistantResponse(currentContext, requestConfig, signal, emit, withEmptyAssistantRecovery(requestConfig.model, streamFunction), streamIdleTimeoutMs);
+            const streamed = await streamAssistantResponse(currentContext, requestConfig, signal, emit, withEmptyAssistantRecovery(requestConfig.model, streamFunction), isInitialProviderRequest ? config.timeoutMs : requestConfig.timeoutMs);
             const message = promoteStopWithPendingToolCalls(streamed.message);
             const providerToolResults = streamed.providerToolResults;
             newMessages.push(message);
-            // Provider-resolved (Cursor exec-channel) tool results pair with
-            // already-resolved toolCall blocks in the assistant message. They are
-            // appended right after it — including on terminal error/abort paths,
-            // where dropping them would leave resolved calls unpaired and strip
-            // the interaction from every rebuilt transcript.
             const toolResults = [];
             for (const result of providerToolResults) {
                 await emit({ type: "message_start", message: result });
@@ -175,18 +170,14 @@ async function runLoop(initialContext, newMessages, initialConfig, signal, emit,
                 await emit({ type: "agent_end", messages: newMessages });
                 return;
             }
-            // Check for tool calls. Blocks stamped `kCursorExecResolved` were
-            // already executed by Cursor's exec channel mid-stream (their results
-            // arrived via `providerToolResults`); running them here again would
-            // duplicate side-effecting tools.
+            // Check for tool calls
             const toolCalls = message.content.filter((c) => c.type === "toolCall" && !isCursorExecResolved(c));
             hasMoreToolCalls = false;
             let toolBatchTerminated = false;
             if (toolCalls.length > 0) {
-                // A native "length" stop means the output was cut off by the token limit,
-                // so every tool call in the message may carry truncated arguments. Text
-                // tool-call middleware finalizes its calls as "toolUse", leaving only
-                // native, unwrapped length responses for this message-wide safeguard.
+                // A "length" stop means the output was cut off by the token limit, so
+                // every tool call in the message may carry truncated arguments. Fail
+                // them all instead of executing potentially borked calls.
                 const executedToolBatch = message.stopReason === "length"
                     ? await failToolCallsFromTruncatedMessage(toolCalls, emit)
                     : await executeToolCalls(currentContext, message, config, signal, emit);
@@ -209,34 +200,35 @@ async function runLoop(initialContext, newMessages, initialConfig, signal, emit,
                 context: currentContext,
                 newMessages,
             };
+            if (await config.shouldStopAfterTurn?.(nextTurnContext)) {
+                await emit({ type: "agent_end", messages: newMessages });
+                return;
+            }
             if (toolBatchTerminated) {
-                if (await config.shouldStopAfterTurn?.(nextTurnContext)) {
-                    await emit({ type: "agent_end", messages: newMessages });
-                    return;
-                }
                 pendingMessages = (await config.getSteeringMessages?.()) || [];
-                if (pendingMessages.length > 0) {
+                if (pendingMessages.length > 0)
                     drainedTerminatingQueue = "steering";
-                }
                 if (pendingMessages.length === 0) {
                     pendingMessages = (await config.getFollowUpMessages?.()) || [];
-                    if (pendingMessages.length > 0) {
+                    if (pendingMessages.length > 0)
                         drainedTerminatingQueue = "followUp";
-                    }
                 }
                 if (pendingMessages.length === 0) {
                     await emit({ type: "agent_end", messages: newMessages });
                     return;
                 }
+                // Give queue owners a boundary before preparation refreshes the drained
+                // snapshot, so a clear or replacement wins before admission.
+                await emit({ type: "turn_start" });
+                turnStartAlreadyEmitted = true;
             }
             let nextTurnSnapshot;
             try {
                 nextTurnSnapshot = await config.prepareNextTurn?.(nextTurnContext);
             }
             catch (error) {
-                if (drainedTerminatingQueue) {
+                if (drainedTerminatingQueue)
                     await config.restorePendingMessages?.(drainedTerminatingQueue, pendingMessages);
-                }
                 throw error;
             }
             if (nextTurnSnapshot) {
@@ -256,9 +248,8 @@ async function runLoop(initialContext, newMessages, initialConfig, signal, emit,
                 };
             }
             if (signal?.aborted) {
-                if (drainedTerminatingQueue) {
+                if (drainedTerminatingQueue)
                     await config.restorePendingMessages?.(drainedTerminatingQueue, pendingMessages);
-                }
                 await emit({ type: "agent_end", messages: newMessages });
                 return;
             }
@@ -268,16 +259,7 @@ async function runLoop(initialContext, newMessages, initialConfig, signal, emit,
                     await emit({ type: "agent_end", messages: newMessages });
                     return;
                 }
-            }
-            if (!toolBatchTerminated &&
-                (await config.shouldStopAfterTurn?.({
-                    message,
-                    toolResults,
-                    context: currentContext,
-                    newMessages,
-                }))) {
-                await emit({ type: "agent_end", messages: newMessages });
-                return;
+                drainedTerminatingQueue = undefined;
             }
             if (!toolBatchTerminated) {
                 pendingMessages = (await config.getSteeringMessages?.()) || [];
@@ -297,19 +279,10 @@ async function runLoop(initialContext, newMessages, initialConfig, signal, emit,
 }
 /** Build the provider context using the same transform and conversion pipeline as an agent request. */
 export async function buildProviderContext(context, config, signal) {
-    // Apply context transform if configured (AgentMessage[] → AgentMessage[])
     let messages = context.messages;
-    if (config.transformContext) {
+    if (config.transformContext)
         messages = await config.transformContext(messages, signal);
-    }
-    // Convert to LLM-compatible messages (AgentMessage[] → Message[])
-    const llmMessages = await config.convertToLlm(messages);
-    // Build LLM context
-    return {
-        systemPrompt: context.systemPrompt,
-        messages: llmMessages,
-        tools: context.tools,
-    };
+    return { systemPrompt: context.systemPrompt, messages: await config.convertToLlm(messages), tools: context.tools };
 }
 /**
  * Stream an assistant response from the LLM.
@@ -695,6 +668,7 @@ async function executeToolCallsSequential(currentContext, assistantMessage, tool
 }
 async function executeToolCallsParallel(currentContext, assistantMessage, toolCalls, config, signal, emit) {
     const finalizedCalls = [];
+    const preparedCalls = [];
     let lastSequentialCall;
     let currentParallelWave = [];
     for (const toolCall of toolCalls) {
@@ -711,24 +685,44 @@ async function executeToolCallsParallel(currentContext, assistantMessage, toolCa
             : 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);
+        preparedCalls.push({ preparation, isSequential, dependencies });
         if (isSequential) {
-            lastSequentialCall = finalizedCall;
+            // Dependencies are assigned in the second phase after all preflight hooks
+            // have completed, so a later preflight abort vetoes every execution.
+            lastSequentialCall = undefined;
             currentParallelWave = [];
         }
         else {
-            currentParallelWave.push(finalizedCall);
+            currentParallelWave.push(Promise.resolve(undefined));
         }
         if (signal?.aborted) {
             break;
         }
     }
+    let previousSequential;
+    let previousWave = [];
+    for (const { preparation, isSequential } of preparedCalls) {
+        const dependencies = isSequential
+            ? [...(previousSequential ? [previousSequential] : []), ...previousWave]
+            : previousSequential
+                ? [previousSequential]
+                : [];
+        const finalizedCall = (async () => {
+            await Promise.all(dependencies);
+            const finalized = signal?.aborted
+                ? { toolCall: preparation.toolCall, result: createErrorToolResult("Operation aborted"), isError: true }
+                : await runPreparedToolCall(currentContext, assistantMessage, preparation, config, signal, emit);
+            await emitToolExecutionEnd(finalized, emit);
+            return finalized;
+        })();
+        finalizedCalls.push(finalizedCall);
+        if (isSequential) {
+            previousSequential = finalizedCall;
+            previousWave = [];
+        }
+        else
+            previousWave.push(finalizedCall);
+    }
     const orderedFinalizedCalls = await Promise.all(finalizedCalls);
     const messages = [];
     for (const finalized of orderedFinalizedCalls) {