@chibitek/chibi 0.1.160 → 0.1.161

package/dist-server/server/drivers/acp/core.js

@@ -48,6 +48,7 @@ import { commandSummary, toolDetailPreview } from "../../tool-summary.js";
 import { extractMcpImages } from "../../mcp-tool-images.js";
 import { mcpToolRefFromLabel } from "../../../shared/mcp-tool-ref.js";
 import { redactSecretsInText } from "../../redact.js";
+import { isBrokenAntigravityCheckpoint, isAntigravityCheckpointReply } from "../../checkpoint-recovery.js";
 import { recoveryPromptFor } from "../../resume-recovery.js";
 import { isModelRejection } from "../retry.js";
 import { engineFailureFromCode, isCredentialDead, isOpaqueRequestRejection, logAuthFailure, parseResetAt, resetHintFromData } from "../../engine-failure.js";
@@ -464,14 +465,15 @@ export function createAcpDriver(support) {
                 // turn synchronously must find this session free
                 session.current = null;
                 active.delete(threadId);
+                if (isAntigravityCheckpointReply(DRIVER_KIND, current.state.text)) {
+                    ok = false;
+                    stopReason = "invalid_checkpoint";
+                    emit({ ...base(threadId, current.turnId), type: "runtime.error", message: current.state.text.trim() });
+                    closeSession(threadId, "invalid-checkpoint");
+                }
                 current.flushAssistantText();
-                // `end_turn` with nothing to show for it — no reply, no image, no
-                // tool result — is a lost turn, not a success. An engine can report
-                // exactly that (a provider may cut a reasoning-only stream and
-                // still answer end_turn), and ok:true would end the thread quietly
-                // while the person's message went unanswered. Keep the completion,
-                // but report it as a failure so terminal chips, incidents and
-                // follow-ups see what happened.
+                // A successful end_turn without a reply or tool result is a lost
+                // turn. Report failure so terminal chips and follow-ups reflect it.
                 let finalOk = ok;
                 let finalStopReason = stopReason;
                 if (finalOk && finalStopReason === null && !current.state.producedItem) {
@@ -1467,7 +1469,9 @@ export function createAcpDriver(support) {
                                 type: "runtime.error",
                                 message: errorMessage,
                             });
-                            settle(threadId, session, false, reason ?? "failed");
+                            if (isBrokenAntigravityCheckpoint(DRIVER_KIND, errorMessage))
+                                closeSession(threadId, "invalid-checkpoint");
+                            settle(threadId, session, false, isBrokenAntigravityCheckpoint(DRIVER_KIND, errorMessage) ? "invalid_checkpoint" : reason ?? "failed");
                         }
                     }
                     catch (e) {
@@ -1492,18 +1496,14 @@ export function createAcpDriver(support) {
                                 ...(needsAuth ? { setup: true } : {}),
                                 ...(failure ? { failure } : {}),
                             });
-                            // Internal RPC failures can leave a live child poisoned just
-                            // like a silent prompt. Evict before completion listeners can
-                            // start the next turn. Never replay this accepted prompt: it
-                            // may already have executed tools. The next explicit turn can
-                            // resume the recorded session on a fresh process.
-                            // An agent refused by its provider mid-prompt is still running
-                            // (retrying on its own): it goes too.
-                            if ((logAuth || (!needsAuth && (stalled || e?.acpSessionFailure === true
+                            // Evict unusable sessions without replaying accepted prompts.
+                            // The harness invalidates broken checkpoints durably so the
+                            // next explicit turn rebuilds from the retained transcript.
+                            if ((logAuth || (!needsAuth && (stalled || isBrokenAntigravityCheckpoint(DRIVER_KIND, message) || e?.acpSessionFailure === true
                                 || code === "upstream_outage"))) && session.child.exitCode === null && !session.closing) {
                                 closeSession(threadId, logAuth ? "provider-auth" : stalled ? "prompt-stall" : "rpc-failure");
                             }
-                            settle(threadId, session, false, needsAuth ? "auth_required" : "rpc_error");
+                            settle(threadId, session, false, needsAuth ? "auth_required" : isBrokenAntigravityCheckpoint(DRIVER_KIND, message) ? "invalid_checkpoint" : "rpc_error");
                         }
                     }
                 })();

package/dist-server/server/engine-failover.js

@@ -49,10 +49,10 @@ export const NO_ANSWER_FAILURE = "The engine ended the turn without an answer.";
 function unrecognisedFailure(turn) {
     return { kind: "provider_error", message: turn.lastError ?? NO_ANSWER_FAILURE };
 }
-/** Ways a turn ends failed that are not the engine's fault: the person (or
- * the harness on their behalf) stopped it. Every other failed end moves the
- * turn to the next engine. */
-const NOT_A_PROVIDER_FAILURE = new Set(["interrupted", "cancelled"]);
+/** Stops that must not dispatch the request again: cancellation or a broken
+ * checkpoint whose accepted prompt may already have executed actions.
+ * The next explicit turn rebuilds that checkpoint from retained history. */
+const NOT_A_PROVIDER_FAILURE = new Set(["interrupted", "cancelled", "invalid_checkpoint"]);
 export class FailoverGate {
     turns = new Map();
     onFailure;

package/dist-server/server/index.js

@@ -1,3 +1,4 @@
+import { invalidateBrokenCheckpoint } from "./checkpoint-recovery.js";
 import { createModelExpectation, ModelEvidenceLedger } from "./model-evidence-context.js";
 import { reactToMessage } from "./message-reactions.js";
 import { hasUnboundGoalGuard, goalGuardForEvent, addGoalGuard, removeGoalGuard, runPersonalGoalTurn, updatePersonalGoalReceipt } from "./personal-goal-turn.js";
@@ -8170,22 +8171,20 @@ bus.subscribe((event) => {
             });
             break;
         case "runtime.error":
+            if (bot)
+                invalidateBrokenCheckpoint(store, bot.id, event.providerInstanceId ? registry.get(event.providerInstanceId)?.driverKind : undefined, event);
             if (event.message?.trim())
                 lastTurnError.set(event.threadId, event.message.trim().slice(0, 300));
             pushMessage({
                 role: "bot",
                 kind: "activity",
-                // The category travels with the line so every surface words it the
-                // same way; an error line is never a lost connection either way.
+                // Keep the category consistent across surfaces.
                 // The harness's own stop line is kept whole: it ends with where to fix
                 // the account, which a 160-character cut would drop.
                 tool: { name: `error: ${event.message.slice(0, event.category === "account" || event.category === "failover_exhausted" ? 600 : 160)}`, ok: false, setup: event.setup, ...(event.terminal ? { terminal: true } : {}),
                     ...(event.category ? { errorCategory: event.category } : {}) },
             });
-            // a setup error means the engine could not even start: the bot is
-            // dead until something changes, not merely idle. The next successful
-            // dispatch moves it to working; turn.completed (which follows a setup
-            // failure) is told to leave "dead" alone.
+            // Setup failures remain dead until a later successful dispatch.
             if (event.setup && bot)
                 store.setTaskActivity(bot.id, event.threadId, "dead");
             break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chibitek/chibi",
-  "version": "0.1.160",
+  "version": "0.1.161",
   "description": "Atomic by Chibitek: run your AI team's server anywhere and pair your devices to it",
   "license": "Apache-2.0",
   "type": "module",

package/dist/assets/channel-Lp7erhx-.js

@@ -1 +0,0 @@
-import{U as a,C as n}from"./mermaid.core-DlSzuDKt.js";const t=(r,o)=>a.lang.round(n.parse(r)[o]);export{t as c};

package/dist/assets/swimlanesDiagram-TC7HE7FX-C6wGgYKP.js

@@ -1,8 +0,0 @@
-import{c as r,s as e}from"./flowDiagram-KWPJA3E3-dtD6wm3G.js";import{_ as a}from"./mermaid.core-DlSzuDKt.js";import"./chunk-5VM5RSS4-QMK3iFBF.js";import"./chunk-XXDRQBXY-D7ocO3VN.js";import"./chunk-WEXAMYUT-CZslD_VF.js";import"./chunk-GWA4HPMP-DWvOhTaO.js";import"./channel-Lp7erhx-.js";import"./index-BIcziktH.js";var o=a(t=>`${e(t)}
-  .swimlane.cluster:not([data-color-id]) rect {
-    stroke: ${t.clusterBorder} !important;
-  }
-  [data-look="neo"].cluster rect {
-    filter: none;
-  }
-`,"getStyles"),s=o,u=r({styles:s});export{u as diagram};

package/dist-server/connector-proxy.js

@@ -1,205 +0,0 @@
-// server/connector-proxy.ts
-import readline from "node:readline";
-import { randomUUID } from "node:crypto";
-var UPSTREAM = process.env.OMB_CONNECTOR_UPSTREAM_URL ?? "";
-var HARNESS = process.env.OMB_HARNESS_URL ?? "http://127.0.0.1:8799";
-var BOT_ID = process.env.OMB_BOT_ID ?? "";
-var THREAD_ID = process.env.OMB_THREAD_ID ?? "";
-var TOKEN = process.env.OMB_CONNECTOR_TOKEN ?? process.env.OMB_COMMS_TOKEN ?? "";
-var MAX_RESPONSE_BYTES = 20 * 1024 * 1024;
-var INITIALIZE_RELAY_TIMEOUT_MS = 1e3;
-var RELAY_TIMEOUT_MS = 10 * 6e4;
-function parsedHeaders() {
-  try {
-    const value = JSON.parse(process.env.OMB_CONNECTOR_UPSTREAM_HEADERS ?? "{}");
-    if (!value || typeof value !== "object" || Array.isArray(value)) return {};
-    return Object.fromEntries(
-      Object.entries(value).filter((entry) => typeof entry[1] === "string")
-    );
-  } catch {
-    return {};
-  }
-}
-var upstreamHeaders = parsedHeaders();
-var upstreamSessionId = "";
-var send = (message) => process.stdout.write(`${JSON.stringify(message)}
-`);
-function textResult(id, text, isError = false) {
-  return { jsonrpc: "2.0", id, result: { content: [{ type: "text", text }], ...isError ? { isError: true } : {} } };
-}
-function jsonRpcError(id, message) {
-  return { jsonrpc: "2.0", id, error: { code: -32e3, message } };
-}
-function initializeResult(id, protocolVersion) {
-  return {
-    jsonrpc: "2.0",
-    id,
-    result: {
-      protocolVersion: typeof protocolVersion === "string" && protocolVersion ? protocolVersion : "2024-11-05",
-      capabilities: { tools: {} },
-      serverInfo: { name: "openmausbot-connectors", version: "1" }
-    }
-  };
-}
-async function readBounded(response) {
-  const declared = Number(response.headers.get("content-length") ?? "0");
-  if (declared > MAX_RESPONSE_BYTES) throw new Error("connector response exceeded 20 MB");
-  if (!response.body) return "";
-  const reader = response.body.getReader();
-  const decoder = new TextDecoder();
-  let size = 0;
-  let text = "";
-  for (; ; ) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    size += value.byteLength;
-    if (size > MAX_RESPONSE_BYTES) {
-      await reader.cancel();
-      throw new Error("connector response exceeded 20 MB");
-    }
-    text += decoder.decode(value, { stream: true });
-  }
-  return text + decoder.decode();
-}
-function parseUpstream(text, id) {
-  const trimmed = text.trim();
-  if (!trimmed) return null;
-  if (trimmed.startsWith("{")) return JSON.parse(trimmed);
-  const frames = trimmed.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trim()).filter((line) => line && line !== "[DONE]").flatMap((line) => {
-    try {
-      return [JSON.parse(line)];
-    } catch {
-      return [];
-    }
-  });
-  return frames.findLast((frame) => frame.id === id) ?? frames.at(-1) ?? null;
-}
-async function relay(message, timeoutMs = RELAY_TIMEOUT_MS) {
-  if (!UPSTREAM) throw new Error("connected apps are unavailable");
-  const response = await fetch(UPSTREAM, {
-    method: "POST",
-    headers: {
-      "content-type": "application/json",
-      accept: "application/json, text/event-stream",
-      ...upstreamHeaders,
-      ...upstreamSessionId ? { "mcp-session-id": upstreamSessionId } : {}
-    },
-    body: JSON.stringify(message),
-    signal: AbortSignal.timeout(timeoutMs)
-  });
-  const nextSession = response.headers.get("mcp-session-id");
-  if (nextSession) upstreamSessionId = nextSession;
-  if (!response.ok) throw new Error(`connector service returned HTTP ${response.status}`);
-  return parseUpstream(await readBounded(response), message.id);
-}
-function connectorAdds(args) {
-  if (!args || typeof args !== "object" || Array.isArray(args)) return [];
-  const toolkits = args.toolkits;
-  if (!Array.isArray(toolkits)) return [];
-  const seen = /* @__PURE__ */ new Set();
-  const requests = [];
-  for (const item of toolkits) {
-    if (typeof item === "string") {
-      const slug2 = item.trim().toLowerCase();
-      const key2 = JSON.stringify([slug2, ""]);
-      if (!seen.has(key2)) {
-        seen.add(key2);
-        requests.push({ slug: slug2 });
-      }
-      continue;
-    }
-    if (!item || typeof item !== "object" || Array.isArray(item)) continue;
-    const row = item;
-    const action = String(row.action ?? "add").toLowerCase();
-    if (!["add", "connect", "initiate"].includes(action)) continue;
-    const slug = typeof row.toolkit === "string" ? row.toolkit : row.name;
-    if (typeof slug !== "string") continue;
-    const normalized = slug.trim().toLowerCase();
-    const alias = (typeof row.alias === "string" ? row.alias : typeof row.account === "string" ? row.account : "").trim();
-    const key = JSON.stringify([normalized, alias.toLowerCase()]);
-    if (seen.has(key)) continue;
-    seen.add(key);
-    requests.push({ slug: normalized, ...alias ? { alias } : {} });
-  }
-  return requests;
-}
-async function showConnectorCards(items) {
-  const response = await fetch(`${HARNESS}/api/internal/connectors/request`, {
-    method: "POST",
-    headers: { "content-type": "application/json", authorization: `Bearer ${TOKEN}` },
-    body: JSON.stringify({ botId: BOT_ID, threadId: THREAD_ID, items, resumeKey: randomUUID() }),
-    signal: AbortSignal.timeout(3e4)
-  });
-  if (!response.ok) {
-    const body = await response.json().catch(() => ({}));
-    throw new Error(String(body.error ?? `could not show connection card (HTTP ${response.status})`));
-  }
-}
-async function handle(message) {
-  const id = message.id;
-  const method = String(message.method ?? "");
-  if (method === "notifications/initialized" || method === "initialized") {
-    if (UPSTREAM) void relay(message).catch(() => {
-    });
-    return;
-  }
-  if (method === "initialize") {
-    if (UPSTREAM) {
-      try {
-        await relay(message, INITIALIZE_RELAY_TIMEOUT_MS);
-      } catch {
-      }
-    }
-    if (id !== void 0) {
-      const params = message.params ?? {};
-      send(initializeResult(id, params.protocolVersion));
-    }
-    return;
-  }
-  if (method === "tools/call") {
-    const params = message.params ?? {};
-    const name = String(params.name ?? "");
-    const requests = /MANAGE_CONNECTIONS$/i.test(name) ? connectorAdds(params.arguments) : [];
-    if (requests.length) {
-      await showConnectorCards(requests);
-      const labels = requests.map((r) => r.alias ? `${r.slug} (${r.alias})` : r.slug).join(", ");
-      send(textResult(
-        id,
-        `Atomic showed the user a secure connection card for ${labels}. End this turn now. The app will continue the task automatically after the connection finishes.`
-      ));
-      return;
-    }
-    if (/WAIT_FOR_CONNECTIONS$/i.test(name)) {
-      send(textResult(id, "Atomic is handling connection completion and will continue the task automatically."));
-      return;
-    }
-  }
-  try {
-    const response = await relay(message);
-    if (response && id !== void 0) send(response);
-  } catch (error) {
-    if (id === void 0) return;
-    const messageText = error instanceof Error ? error.message : String(error);
-    if (method === "tools/call") send(textResult(id, messageText, true));
-    else send(jsonRpcError(id, messageText));
-  }
-}
-var input = readline.createInterface({ input: process.stdin, terminal: false });
-input.on("line", (line) => {
-  const trimmed = line.trim();
-  if (!trimmed) return;
-  let message;
-  try {
-    message = JSON.parse(trimmed);
-  } catch {
-    return;
-  }
-  void handle(message).catch((error) => {
-    if (message.id === void 0) return;
-    const method = String(message.method ?? "");
-    const messageText = error instanceof Error ? error.message : String(error);
-    if (method === "tools/call") send(textResult(message.id, messageText, true));
-    else send(jsonRpcError(message.id, messageText));
-  });
-});
-input.on("close", () => process.exit(0));