@frockbot/plugin-authoring 0.3.4 → 0.3.6

package/frockbot.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 3,
   "id": "authoring",
-  "displayName": "Package Authoring",
+  "displayName": "Plugin authoring",
   "version": "0.0.1",
   "compatibility": {
     "frockbot": ">=0.0.1"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frockbot/plugin-authoring",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "private": false,
   "type": "module",
   "exports": {
@@ -21,7 +21,7 @@
     "typecheck": "tsc --noEmit -p tsconfig.json"
   },
   "dependencies": {
-    "@frockbot/kernel-contracts": "0.3.4",
+    "@frockbot/kernel-contracts": "0.3.6",
     "cordis": "4.0.0-rc.8"
   },
   "devDependencies": {

package/src/agent.test.ts

@@ -172,6 +172,56 @@ describe("the package_author tool", () => {
     await dispose();
   });
 
+  test("every refusal and every throw closes the intent with a failure event", async () => {
+    // F12: `package/author-intent` was written, the host refused, and the run
+    // reached `turn/end` with no `package/authored` and no failure event of
+    // any kind — the session log said an effect was intended and never said
+    // how it ended (user `packages-4`, Bot `maker-2351d56c`, run `e015c05e`).
+    for (const scenario of [
+      {
+        host: stubHost({
+          status: "refused" as const,
+          reason: "the Package bundler could not be reached",
+          failureId: "authoring-failure-2",
+        }),
+        expected: {
+          effect: "author",
+          reason: "the Package bundler could not be reached",
+          failureId: "authoring-failure-2",
+        },
+      },
+      {
+        // An unmodelled throw escaped `execute` the same way.
+        host: {
+          ...stubHost({
+            status: "refused" as const,
+            reason: "unused",
+            failureId: "unused",
+          }),
+          author: () => Promise.reject(new Error("storage is unavailable")),
+        },
+        expected: { effect: "author", reason: "storage is unavailable" },
+      },
+    ]) {
+      const { session, sessions, dispose } = await openSession();
+      const tool = createPackageAuthorTool(scenario.host as never, sessions);
+
+      const result = await tool.execute(INPUT, CONTEXT);
+
+      expect(result.isError).toBe(true);
+      const types = session.events.map((event) => event.type);
+      expect(types).toContain("package/author-intent");
+      expect(types).not.toContain("package/authored");
+      expect(types.at(-1)).toBe("package/effect-failed");
+      expect(session.events.at(-1)).toMatchObject({
+        ...scenario.expected,
+        turn: 4,
+        step: 2,
+      });
+      await dispose();
+    }
+  });
+
   test("a refusal leaves the intent recorded and no authored event", async () => {
     const { session, sessions, dispose } = await openSession();
     const tool = createPackageAuthorTool(

package/src/agent.ts

@@ -98,6 +98,41 @@ function refusalText(
   ].join(" ");
 }
 
+/**
+ * Close an open `package/*-intent` with the failure that ended it, then answer
+ * the model. The pair is the proof the effect happened at all, so the failure
+ * event is flushed before the tool result is returned; a failure to record the
+ * failure is not allowed to hide the original one.
+ */
+async function closeWithFailure(
+  session: Session,
+  position: AuthoringTurnPositionV1,
+  failure: {
+    effectId: string;
+    effect: "author" | "undo" | "catalog-change";
+    reason: string;
+    failureId?: string;
+    content: string;
+  },
+): Promise<{ content: string; isError: true }> {
+  try {
+    session.append({
+      type: "package/effect-failed",
+      ...position,
+      effectId: failure.effectId,
+      effect: failure.effect,
+      reason: failure.reason,
+      ...(failure.failureId === undefined
+        ? {}
+        : { failureId: failure.failureId }),
+    });
+    await session.flush();
+  } catch {
+    // Deliberately swallowed: the model still gets the real reason.
+  }
+  return { content: failure.content, isError: true };
+}
+
 function authoredText(
   outcome: Extract<AuthorPackageOutcomeV1, { status: "authored" }>,
 ): string {
@@ -181,15 +216,34 @@ export function createPackageAuthorTool(
       });
       await session.flush();
 
-      const outcome = await host.author({
-        input: decoded,
-        sourceHash,
-        effectId,
-        sessionId: context.sessionId,
-        position,
-      });
+      let outcome: AuthorPackageOutcomeV1;
+      try {
+        outcome = await host.author({
+          input: decoded,
+          sourceHash,
+          effectId,
+          sessionId: context.sessionId,
+          position,
+        });
+      } catch (error) {
+        // An unmodelled throw — a storage error, a quota RPC rejection, a
+        // manifest that will not decode — used to escape `execute` and leave
+        // the intent with no outcome of any kind (F12).
+        return closeWithFailure(session, position, {
+          effectId,
+          effect: "author",
+          reason: errorMessage(error),
+          content: `package_author failed: ${errorMessage(error)} Nothing was activated.`,
+        });
+      }
       if (outcome.status === "refused") {
-        return { content: refusalText(outcome), isError: true };
+        return closeWithFailure(session, position, {
+          effectId,
+          effect: "author",
+          reason: outcome.reason,
+          failureId: outcome.failureId,
+          content: refusalText(outcome),
+        });
       }
       session.append({
         type: "package/authored",
@@ -255,17 +309,30 @@ export function createPackageUndoTool(
           : {}),
       });
       await session.flush();
-      const outcome = await host.undo({
-        input: decoded,
-        effectId,
-        sessionId: context.sessionId,
-        position,
-      });
+      let outcome: PackageUndoOutcomeV1;
+      try {
+        outcome = await host.undo({
+          input: decoded,
+          effectId,
+          sessionId: context.sessionId,
+          position,
+        });
+      } catch (error) {
+        return closeWithFailure(session, position, {
+          effectId,
+          effect: "undo",
+          reason: errorMessage(error),
+          content: `package_undo failed: ${errorMessage(error)} No connection action was undone.`,
+        });
+      }
       if (outcome.status === "refused") {
-        return {
+        return closeWithFailure(session, position, {
+          effectId,
+          effect: "undo",
+          reason: outcome.reason,
+          failureId: outcome.failureId,
           content: `Package undo was refused: ${outcome.reason} A durable failure record "${outcome.failureId}" was written. No connection action was undone.`,
-          isError: true,
-        };
+        });
       }
       session.append({
         type: "package/undo-recorded",

package/src/records.ts

@@ -190,6 +190,20 @@ export type AuthoringEffectOutcomeV1 =
       effectId: string;
       failureId: string;
       reason: string;
+    }
+  /**
+   * The bundler was never reached — unreachable, or past its deadline before
+   * it answered. Nothing ran, so nothing is uncertain: the effect is as good
+   * as unstarted and an identical retry may proceed. Without this an outage
+   * poisoned that exact `effectId` (run + Package + source hash) for the rest
+   * of the run, so retrying the same source could never succeed (F11).
+   */
+  | {
+      schemaVersion: 1;
+      status: "unreachable";
+      effectId: string;
+      failureId: string;
+      reason: string;
     };
 
 export type AuthoringEffectClassificationV1 =
@@ -225,13 +239,16 @@ export function classifyAuthoringEffectV1(input: {
           "an authoring outcome is recorded for an effect with no recorded intent",
       };
     }
-    return input.outcome.status === "bundled"
-      ? { kind: "settled", outcome: input.outcome }
-      : {
-          kind: "failed",
-          failureId: input.outcome.failureId,
-          reason: input.outcome.reason,
-        };
+    if (input.outcome.status === "bundled") {
+      return { kind: "settled", outcome: input.outcome };
+    }
+    // Nothing ran, so the effect may run: `fresh`, not `unknown`.
+    if (input.outcome.status === "unreachable") return { kind: "fresh" };
+    return {
+      kind: "failed",
+      failureId: input.outcome.failureId,
+      reason: input.outcome.reason,
+    };
   }
   if (!input.intent) return { kind: "fresh" };
   return {