@frockbot/kernel-agent-loop 0.3.6 → 0.3.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frockbot/kernel-agent-loop",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "private": false,
   "type": "module",
   "exports": {
@@ -12,13 +12,13 @@
     "typecheck": "tsc --noEmit -p tsconfig.json"
   },
   "dependencies": {
-    "@frockbot/kernel-contracts": "0.3.6",
+    "@frockbot/kernel-contracts": "0.3.8",
     "cordis": "4.0.0-rc.8"
   },
   "devDependencies": {
-    "@frockbot/plugin-models": "0.3.6",
-    "@frockbot/plugin-prompt": "0.3.6",
-    "@frockbot/plugin-tools": "0.3.6",
+    "@frockbot/plugin-models": "0.3.8",
+    "@frockbot/plugin-prompt": "0.3.8",
+    "@frockbot/plugin-tools": "0.3.8",
     "@types/bun": "1.4.0",
     "@types/node": "26.2.0",
     "typescript": "^7.0.2"

package/src/index.test.ts

@@ -1223,7 +1223,7 @@ describe("AgentLoop", () => {
     ).toBe(false);
   });
 
-  test("keeps an unretrievable provider effect open without repeating it", async () => {
+  test("settles a turn whose provider cannot retrieve the effect", async () => {
     let streams = 0;
     const provider: LlmProvider = {
       id: "unretrievable",
@@ -1279,28 +1279,26 @@ describe("AgentLoop", () => {
       model: "model-1",
     });
 
-    handle.agent.resume();
-    await handle.agent.whenIdle();
     handle.agent.resume();
     await handle.agent.whenIdle();
 
+    // A provider that declares no retrieval will never grow one, so the run
+    // settles as a model error rather than parking on a reconciliation that
+    // can never happen (and throwing out of the Durable Object).
     expect(streams).toBe(0);
-    expect(
-      handle.agent.session.events.filter(
-        (event) => event.type === "model/reconciliation-required",
-      ),
-    ).toEqual([
-      expect.objectContaining({
-        requestId: "unretrievable-effect-1",
-        reason:
-          'LLM provider "unretrievable" does not support provider-bound retrieval',
-      }),
-    ]);
     expect(
       handle.agent.session.events.some(
-        (event) => event.type === "step/end" || event.type === "turn/end",
+        (event) => event.type === "model/reconciliation-required",
       ),
     ).toBe(false);
+    const turnEnd = handle.agent.session.events.findLast(
+      (event) => event.type === "turn/end",
+    );
+    expect(turnEnd).toMatchObject({
+      outcome: "model-error",
+      reason:
+        'LLM provider "unretrievable" does not support provider-bound retrieval',
+    });
   });
 
   test("keeps an ambiguous dispatched effect open for provider reconciliation", async () => {

package/src/index.ts

@@ -71,7 +71,8 @@ interface ModelResponse {
 
 type ModelReconciliation =
   | { status: "recovered"; response: ModelResponse }
-  | { status: "unavailable"; reason: string };
+  | { status: "unavailable"; reason: string }
+  | { status: "not-retrievable"; reason: string };
 
 class ModelEffectReconciliationRequiredError extends Error {
   constructor(
@@ -473,6 +474,19 @@ class LoopAgent implements Agent {
           latestStep,
           signal,
         );
+        if (reconciliation.status === "not-retrievable") {
+          // No later attempt can retrieve this effect, so the run settles now.
+          // The chunks already journaled stay in the session, so whatever the
+          // model produced before the interruption is still shown.
+          await this.#notifyModelOutcome(
+            unresolvedRequest.requestId,
+            "not-started",
+          );
+          turnOutcome = "model-error";
+          turnReason = turnEndReason(reconciliation.reason);
+          this.#ctx.emit("agent/error", this, new Error(reconciliation.reason));
+          return;
+        }
         if (reconciliation.status === "unavailable") {
           const existing = this.session.events.findLast(
             (event) =>
@@ -1126,7 +1140,7 @@ class LoopAgent implements Agent {
     signal: AbortSignal,
   ): Promise<ModelReconciliation> {
     const reconciliation = await this.#ctx.llm.reconcile(request, signal);
-    if (reconciliation.status === "unavailable") return reconciliation;
+    if (reconciliation.status !== "recovered") return reconciliation;
     const durablePrefix = this.session.events.flatMap((event) =>
       event.type === "assistant/chunk" &&
       event.turn === turn &&