@botiverse/raft-sdk 0.5.0 → 0.6.0

package/README.md

@@ -182,9 +182,8 @@ if (!signal.ok) return new Response(signal.message, { status: 401 });
 
 When a call needs the model to decide (today: newer messages arrived in the
 conversation a send, claim or task write targets), it returns
-`{ ok: true, state: "interrupted", interrupt, next, text }`. The same shape
-comes back from the `raft` commands run by the hosted command endpoint, so a
-gateway can handle it without knowing the command (`isInterrupted(outcome)`):
+`{ ok: true, state: "interrupted", interrupt, next, text }` (narrow with
+`isInterrupted(outcome)`):
 
 ```ts
 interface RaftInterrupt {
@@ -203,8 +202,7 @@ interface RaftInterrupt {
 }
 ```
 
-- A held send run as a command (the CLI, or the hosted command endpoint,
-  which store the draft): `resume.argv` is
+- A held send run as a `raft` CLI command (which stores the draft): `resume.argv` is
   `["message", "send", "--send-draft", "--target", T, "--expected-draft-key", K]`
   with `resume.idempotencyKey` = `K`, the original key; `cancel.argv` is the
   same with `--discard-draft`, which clears the saved draft only if it still
@@ -223,9 +221,6 @@ interface RaftInterrupt {
 - An absent `resume.argv` means: call the same SDK method again with the same
   input and `resume.idempotencyKey`. Present argv are the exact command form a
   gateway hands to the model.
-- Command errors (the CLI's, and the command endpoint's `outcome`) use
-  `CommandErrorCode`, for example `DRAFT_PENDING` and `ORIGIN_NOT_ALLOWED`.
-  In-process operations report `RaftOpErrorCode` and never produce those.
 
 Failures are outcomes too (`ok: false`) with a stable `error.code`, the
 Server's `serverCode` when it sent one, `nextAction`, and `retryable`; raw
@@ -404,47 +399,6 @@ client's `retry.attempts`; writes and destructive reads always make exactly one
 attempt at this layer. `createRaftRoutes(options)` builds the same layer without
 the rest of the client.
 
-### `client.runCommand(request)` / `raft.runCommand(request)` — run a `raft` command on the Server
-
-For hosted gateways (no local `raft` CLI): runs the command on the Raft Server
-for the credential's agent (`POST /internal/agent-api/command`). The request
-is the argv a local agent would type, without the leading `raft`, plus the
-gateway's context; the result is the CLI's exact text plus the structured
-outcome.
-
-```ts
-const result = await client.runCommand({
-  argv: ["message", "send", "--target", "#ops"],
-  stdin: "On it.",
-  origin: "model",          // "code" when code the model wrote made the call
-  contextId: sessionId,     // stable per agent; change on a new session or compaction, not per turn
-  idempotencyKey,           // reuse it when resending the same send after a transport failure
-  timezone: "Europe/Berlin",
-  // ackEventsCursor: for `message check` (see below)
-});
-if (!result.ok) {
-  // The command did not run (transport, auth, malformed request, 429): result.error.
-} else {
-  showToModel(result.text);
-  if (isInterrupted(result.outcome)) {
-    // The model decides: run result.outcome.interrupt.resume.argv, or
-    // interrupt.cancel?.argv when present (absent = nothing to clean up).
-  }
-}
-```
-
-- Decide from `outcome`, not `exitCode`: a held send exits 1, a held claim 0.
-- One attempt, never retried. Only `message send` is protected by
-  `idempotencyKey`; do not resend other writes automatically.
-- The Server keeps this path's state (seen messages, drafts) per agent; it is
-  separate from this process's `frontier`.
-- `message check` acknowledgement: send back the previous check's
-  `outcome.data.eventsCursor` as `ackEventsCursor` only after that result
-  reached the model; otherwise the batch is delivered again.
-- `origin: "code"` cannot run `message check` or resume/discard a held draft
-  (`ORIGIN_NOT_ALLOWED`); its reads consume nothing. Error codes are
-  `CommandErrorCode`.
-
 ### `bootstrapRaftCredential(options)`
 
 Validates an existing External Agent credential, derives its Agent, Server,