@frockbot/kernel-do 0.3.38 → 0.3.40

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frockbot/kernel-do",
-  "version": "0.3.38",
+  "version": "0.3.40",
   "private": false,
   "type": "module",
   "exports": {
@@ -12,8 +12,8 @@
     "typecheck": "tsc --noEmit -p tsconfig.json"
   },
   "dependencies": {
-    "@frockbot/kernel-composition": "0.3.38",
-    "@frockbot/kernel-contracts": "0.3.38",
+    "@frockbot/kernel-composition": "0.3.40",
+    "@frockbot/kernel-contracts": "0.3.40",
     "cordis": "4.0.0-rc.8"
   },
   "devDependencies": {

package/src/authority.ts

@@ -5,6 +5,7 @@
 // detail here; everything above them is Package policy behind narrow hooks.
 import {
   decodeSessionEvent,
+  validateToolOccurrenceJournal,
   type NormalizedModelRequest,
   type SessionEvent,
 } from "@frockbot/kernel-contracts";
@@ -1982,7 +1983,14 @@ export class BotDurableAuthority<Snapshot> {
   ): Promise<BotTurnCompletion | undefined> {
     const provider = latestModelRequestProviderV1(events);
     const reconciles = this.hooks.providerReconciles ?? (() => true);
-    if (provider === undefined || reconciles(provider)) {
+    // A model's retrieval policy says nothing about an unresolved tool effect.
+    // Preserve its intent for the tool reconciliation path (ADR 0028).
+    const unresolvedTool =
+      events.some((event) => event.type === "tool/call") &&
+      [...validateToolOccurrenceJournal(events).values()].some(
+        (entry) => entry.intent && !entry.result,
+      );
+    if (unresolvedTool || provider === undefined || reconciles(provider)) {
       await this.requireRunReconciliation(runId, previous, events, reason);
       return undefined;
     }

package/src/model-timeout-settlement.test.ts

@@ -77,7 +77,11 @@ function command(runId: string, text: string): OwnedBotTurnCommand {
 function createAuthority(
   storage: MemoryStorage,
   provider: string,
-  options: { providerReconciles?: boolean; refuseWith?: string } = {},
+  options: {
+    providerReconciles?: boolean;
+    refuseWith?: string;
+    toolEffect?: boolean;
+  } = {},
 ): BotDurableAuthority<undefined> {
   const hooks: BotDurableAuthorityHooks<undefined> = {
     resolveAdmissionSnapshot: () => Promise.resolve(undefined),
@@ -164,6 +168,30 @@ function createAuthority(
           appended,
         );
       }
+      if (options.toolEffect) {
+        await persist(
+          {
+            type: "assistant/message",
+            turn: 1,
+            step: 1,
+            requestId: "request-1",
+            text: "",
+            toolCalls: [{ id: "call-one", name: "external_action", input: {} }],
+          } as never,
+          {
+            type: "tool/call",
+            turn: 1,
+            step: 1,
+            occurrenceId: "tool:1:1:0",
+            name: "external_action",
+            input: {},
+          } as never,
+        );
+        throw new BotTurnReconciliationRequiredError(
+          "Tool effect outcome is unknown",
+          appended,
+        );
+      }
       const reason = `Model response outcome is uncertain: ${MODEL_FIRST_BYTE_DEADLINE_REASON_V1}`;
       await persist({
         type: "model/reconciliation-required",
@@ -263,3 +291,26 @@ describe("a model request that ran out of time", () => {
     expect(storage.values.get("active-run")).toBeUndefined();
   });
 });
+
+test("a non-retrieving model never terminalizes an unresolved tool effect", async () => {
+  const storage = new MemoryStorage();
+  const authority = createAuthority(storage, "flock-ai", { toolEffect: true });
+  await expect(
+    authority.run(command("run-tool", "perform an action")),
+  ).rejects.toThrow();
+  const run = await storedRun(authority, "run-tool");
+  expect(run.status).toBe("reconciliation-required");
+  expect(
+    run.events.some(
+      (event) => event.type === "tool/result" || event.type === "turn/end",
+    ),
+  ).toBe(false);
+  expect(storage.values.get("active-run")).toBe("run-tool");
+  const reconstructed = createAuthority(storage, "flock-ai", {
+    toolEffect: true,
+  });
+  await reconstructed.recoverActiveRun();
+  expect((await storedRun(reconstructed, "run-tool")).status).toBe(
+    "reconciliation-required",
+  );
+});