@knpkv/relay 0.1.0 → 0.2.0

package/dist/messages.d.ts

@@ -0,0 +1,44 @@
+export type MessageEvent = {
+    readonly _tag: "MessageQueued";
+    readonly requestId: string;
+} | {
+    readonly _tag: "MessagePlaced";
+    readonly id: string;
+    readonly requestId: string;
+    readonly text: string;
+} | {
+    readonly _tag: "MessageWithdrawn";
+    readonly requestId: string;
+};
+/** What the tracker reads of a stored message; Pi's messages fit it, and no Pi type leaves the bundle. */
+export interface StoredMessage {
+    readonly role: string;
+    readonly content: string | ReadonlyArray<{
+        readonly type: string;
+        readonly text?: string;
+    }>;
+}
+/** What the tracker reads of a committed entry. */
+export interface CommittedEntry {
+    readonly id: number;
+    readonly kind: string;
+    readonly model?: ReadonlyArray<StoredMessage>;
+}
+/** What the tracker reads of a submission record. */
+export interface SubmissionState {
+    readonly id: number;
+    readonly type: "input" | "write";
+    readonly status: "queued" | "placed" | "done" | "unanswered";
+    readonly requestId?: string;
+    readonly entry?: number;
+}
+/** The visible text of a stored user or assistant entry. */
+export declare const entryText: (messages: ReadonlyArray<StoredMessage> | undefined) => string;
+/** One subscription's tracker: feed it each committed entry and submission record, in stream order. */
+export declare const makeMessageTracker: () => {
+    /** A committed entry; only a person's message can place one. */
+    entry: (entry: CommittedEntry) => ReadonlyArray<MessageEvent>;
+    /** A submission record; Relay submits every input with the dock's requestId, its id is the fallback. */
+    record: (record: SubmissionState) => ReadonlyArray<MessageEvent>;
+};
+//# sourceMappingURL=messages.d.ts.map

package/dist/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../src/messages.ts"],"names":[],"mappings":"AAkBA,MAAM,MAAM,YAAY,GACpB;IAAE,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAC9D;IAAE,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC1G;IAAE,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAA;AAErE,0GAA0G;AAC1G,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,CAAC;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAC5F;AAED,mDAAmD;AACnD,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,KAAK,CAAC,EAAE,aAAa,CAAC,aAAa,CAAC,CAAA;CAC9C;AAED,qDAAqD;AACrD,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAA;IAChC,QAAQ,CAAC,MAAM,EAAE,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,YAAY,CAAA;IAC5D,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CACxB;AAED,4DAA4D;AAC5D,eAAO,MAAM,SAAS,aAAc,aAAa,CAAC,aAAa,CAAC,GAAG,SAAS,KAAG,MAShE,CAAA;AAEf,uGAAuG;AACvG,eAAO,MAAM,kBAAkB;IAc3B,gEAAgE;IAChE,KAAK,UAAU,cAAc,KAAG,aAAa,CAAC,YAAY,CAAC;IAK3D,wGAAwG;IACxG,MAAM,WAAW,eAAe,KAAG,aAAa,CAAC,YAAY,CAAC;CAYjE,CAAA"}

package/dist/model.d.ts

@@ -125,6 +125,23 @@ export declare const RelayEvent: Schema.TaggedUnion<{
         readonly call: Schema.String;
         readonly decision: Schema.Literals<readonly ["confirmed", "declined", "expired"]>;
     }>;
+    readonly MessagePlaced: Schema.TaggedStruct<"MessagePlaced", {
+        readonly session: Schema.String;
+        readonly seq: Schema.Int;
+        readonly id: Schema.String;
+        readonly requestId: Schema.String;
+        readonly text: Schema.String;
+    }>;
+    readonly MessageQueued: Schema.TaggedStruct<"MessageQueued", {
+        readonly session: Schema.String;
+        readonly seq: Schema.Int;
+        readonly requestId: Schema.String;
+    }>;
+    readonly MessageWithdrawn: Schema.TaggedStruct<"MessageWithdrawn", {
+        readonly session: Schema.String;
+        readonly seq: Schema.Int;
+        readonly requestId: Schema.String;
+    }>;
     readonly RunFailed: Schema.TaggedStruct<"RunFailed", {
         readonly session: Schema.String;
         readonly seq: Schema.Int;
@@ -152,6 +169,8 @@ export declare const RelayEvent: Schema.TaggedUnion<{
         }>>;
         /** The run in flight, empty when idle. */
         readonly runIds: Schema.$Array<Schema.String>;
+        /** Messages accepted but not yet in the transcript, oldest first: they wait for the run in flight. */
+        readonly queued: Schema.$Array<Schema.String>;
     }>;
     readonly TextDelta: Schema.TaggedStruct<"TextDelta", {
         readonly session: Schema.String;

package/dist/model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../src/model.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAI/B,uCAAuC;AACvC,eAAO,MAAM,YAAY,2FAAmF,CAAA;AAC5G,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC,IAAI,CAAA;AAEnD,sGAAsG;AACtG,eAAO,MAAM,SAAS;;;;EAIpB,CAAA;AACF,MAAM,WAAW,SAAU,SAAQ,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,SAAS,CAAC;CAAG;AAE1E,+HAA+H;AAC/H,eAAO,MAAM,YAAY,QAAS,SAAS,KAAG,MAAyD,CAAA;AAEvG,qEAAqE;AACrE,eAAO,MAAM,gBAAgB,qDAA6C,CAAA;AAC1E,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAC,IAAI,CAAA;AAE3D,wEAAwE;AACxE,eAAO,MAAM,uBAAuB,0FAAkF,CAAA;AACtH,MAAM,MAAM,uBAAuB,GAAG,OAAO,uBAAuB,CAAC,IAAI,CAAA;AAEzE,wGAAwG;AACxG,eAAO,MAAM,cAAc,wDAAgD,CAAA;AAC3E,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC,IAAI,CAAA;AAIvD;;;;GAIG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;EASxB,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC,IAAI,CAAA;AAErD,sGAAsG;AACtG,eAAO,MAAM,aAAa;;;;;;EAIxB,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC,IAAI,CAAA;AAErD,mDAAmD;AACnD,eAAO,MAAM,WAAW;;;;;EAKtB,CAAA;AACF,MAAM,WAAW,WAAY,SAAQ,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,WAAW,CAAC;CAAG;AAE9E;;;GAGG;AACH,eAAO,MAAM,WAAW;;;;;;;;;EAItB,CAAA;AACF,MAAM,WAAW,WAAY,SAAQ,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,WAAW,CAAC;CAAG;AAE9E;;;GAGG;AACH,eAAO,MAAM,YAAY;;;;EAIvB,CAAA;AACF,MAAM,WAAW,YAAa,SAAQ,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,YAAY,CAAC;CAAG;AAShF,kHAAkH;AAClH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAMnB,0CAA0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2B5C,CAAA;AACF,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC,IAAI,CAAA"}
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../src/model.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAI/B,uCAAuC;AACvC,eAAO,MAAM,YAAY,2FAAmF,CAAA;AAC5G,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC,IAAI,CAAA;AAEnD,sGAAsG;AACtG,eAAO,MAAM,SAAS;;;;EAIpB,CAAA;AACF,MAAM,WAAW,SAAU,SAAQ,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,SAAS,CAAC;CAAG;AAE1E,+HAA+H;AAC/H,eAAO,MAAM,YAAY,QAAS,SAAS,KAAG,MAAyD,CAAA;AAEvG,qEAAqE;AACrE,eAAO,MAAM,gBAAgB,qDAA6C,CAAA;AAC1E,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAC,IAAI,CAAA;AAE3D,wEAAwE;AACxE,eAAO,MAAM,uBAAuB,0FAAkF,CAAA;AACtH,MAAM,MAAM,uBAAuB,GAAG,OAAO,uBAAuB,CAAC,IAAI,CAAA;AAEzE,wGAAwG;AACxG,eAAO,MAAM,cAAc,wDAAgD,CAAA;AAC3E,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC,IAAI,CAAA;AAIvD;;;;GAIG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;EASxB,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC,IAAI,CAAA;AAErD,sGAAsG;AACtG,eAAO,MAAM,aAAa;;;;;;EAIxB,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC,IAAI,CAAA;AAErD,mDAAmD;AACnD,eAAO,MAAM,WAAW;;;;;EAKtB,CAAA;AACF,MAAM,WAAW,WAAY,SAAQ,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,WAAW,CAAC;CAAG;AAE9E;;;GAGG;AACH,eAAO,MAAM,WAAW;;;;;;;;;EAItB,CAAA;AACF,MAAM,WAAW,WAAY,SAAQ,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,WAAW,CAAC;CAAG;AAE9E;;;GAGG;AACH,eAAO,MAAM,YAAY;;;;EAIvB,CAAA;AACF,MAAM,WAAW,YAAa,SAAQ,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,YAAY,CAAC;CAAG;AAShF,kHAAkH;AAClH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAMnB,0CAA0C;;QAE1C,sGAAsG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoCxG,CAAA;AACF,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC,IAAI,CAAA"}

package/dist/wire.d.ts

@@ -0,0 +1,214 @@
+/**
+ * Relay's wire contract: what a product's `/…/relay` routes accept and send, and what the browser decodes.
+ * Browser-safe: it imports only `effect` and `@knpkv/capability`, never the harness, Pi or SQLite, so a page
+ * can import `@knpkv/relay/wire` without pulling the server in.
+ *
+ * **Mental model**
+ *
+ * - **One stream per conversation.** `GET events?product&kind&id` sends `data: <RelayStreamFrame JSON>`
+ *   frames: a `Snapshot` first, then live {@link RelayEvent}s. `Unauthorized` (the browser's session ended)
+ *   and `StreamFailed` (the server could not read the session's events) end the stream.
+ * - **Writes answer with what happened.** `messages` is 202 {@link RelayMessageAccepted}; `cancel` and
+ *   `decisions` are 204, or 409 {@link RelayConflictError} with the state they found. Every route can be 503
+ *   {@link RelayUnavailableError} with the fix when Relay could not start in that process.
+ *
+ * A product narrows `ref` to its own objects and may add a typed `context` to a message; both are its own
+ * schema built on these.
+ *
+ * @module
+ */
+import { Schema } from "effect";
+export { BackendStatus, BackendUnavailableCause, CapabilityAccess, DecisionState, ObjectRef, objectRefKey, RelayBackendId, RelayEvent, RelayProduct, SessionInfo, SessionTool, WriteReceipt } from "./model.js";
+/** One `data:` frame of the events stream: an event, or why the stream ended. */
+export declare const RelayStreamFrame: Schema.Union<readonly [Schema.TaggedUnion<{
+    readonly ApprovalPending: Schema.TaggedStruct<"ApprovalPending", {
+        readonly session: Schema.String;
+        readonly seq: Schema.Int;
+        readonly call: Schema.String;
+        readonly approvalId: Schema.String;
+    }>;
+    readonly Cancelled: Schema.TaggedStruct<"Cancelled", {
+        readonly session: Schema.String;
+        readonly seq: Schema.Int;
+        readonly runIds: Schema.$Array<Schema.String>;
+    }>;
+    readonly ConfirmationRequired: Schema.TaggedStruct<"ConfirmationRequired", {
+        readonly session: Schema.String;
+        readonly seq: Schema.Int;
+        readonly call: Schema.String;
+        readonly action: Schema.Struct<{
+            readonly verb: Schema.String;
+            readonly target: Schema.Struct<{
+                readonly product: Schema.String;
+                readonly kind: Schema.String;
+                readonly id: Schema.String;
+            }>;
+            readonly args: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>;
+        readonly reversible: Schema.Boolean;
+    }>;
+    readonly ConfirmationResolved: Schema.TaggedStruct<"ConfirmationResolved", {
+        readonly session: Schema.String;
+        readonly seq: Schema.Int;
+        readonly call: Schema.String;
+        readonly decision: Schema.Literals<readonly ["confirmed", "declined", "expired"]>;
+    }>;
+    readonly MessagePlaced: Schema.TaggedStruct<"MessagePlaced", {
+        readonly session: Schema.String;
+        readonly seq: Schema.Int;
+        readonly id: Schema.String;
+        readonly requestId: Schema.String;
+        readonly text: Schema.String;
+    }>;
+    readonly MessageQueued: Schema.TaggedStruct<"MessageQueued", {
+        readonly session: Schema.String;
+        readonly seq: Schema.Int;
+        readonly requestId: Schema.String;
+    }>;
+    readonly MessageWithdrawn: Schema.TaggedStruct<"MessageWithdrawn", {
+        readonly session: Schema.String;
+        readonly seq: Schema.Int;
+        readonly requestId: Schema.String;
+    }>;
+    readonly RunFailed: Schema.TaggedStruct<"RunFailed", {
+        readonly session: Schema.String;
+        readonly seq: Schema.Int;
+        readonly runIds: Schema.$Array<Schema.String>;
+        readonly cause: Schema.String;
+        readonly fix: Schema.String;
+    }>;
+    readonly RunFinished: Schema.TaggedStruct<"RunFinished", {
+        readonly session: Schema.String;
+        readonly seq: Schema.Int;
+        readonly runIds: Schema.$Array<Schema.String>;
+    }>;
+    readonly RunStarted: Schema.TaggedStruct<"RunStarted", {
+        readonly session: Schema.String;
+        readonly seq: Schema.Int;
+        readonly runIds: Schema.$Array<Schema.String>;
+    }>;
+    readonly Snapshot: Schema.TaggedStruct<"Snapshot", {
+        readonly session: Schema.String;
+        readonly seq: Schema.Int;
+        readonly messages: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly role: Schema.Literals<readonly ["user", "relay"]>;
+            readonly text: Schema.String;
+        }>>;
+        readonly runIds: Schema.$Array<Schema.String>;
+        readonly queued: Schema.$Array<Schema.String>;
+    }>;
+    readonly TextDelta: Schema.TaggedStruct<"TextDelta", {
+        readonly session: Schema.String;
+        readonly seq: Schema.Int;
+        readonly text: Schema.String;
+    }>;
+    readonly ToolFinished: Schema.TaggedStruct<"ToolFinished", {
+        readonly session: Schema.String;
+        readonly seq: Schema.Int;
+        readonly call: Schema.String;
+        readonly ok: Schema.Boolean;
+        readonly summary: Schema.String;
+        readonly cites: Schema.$Array<Schema.Struct<{
+            readonly product: Schema.String;
+            readonly kind: Schema.String;
+            readonly id: Schema.String;
+        }>>;
+        readonly receipt: Schema.optionalKey<Schema.Struct<{
+            readonly summary: Schema.String;
+            readonly providerId: Schema.String;
+            readonly link: Schema.optionalKey<Schema.String>;
+        }>>;
+    }>;
+    readonly ToolStarted: Schema.TaggedStruct<"ToolStarted", {
+        readonly session: Schema.String;
+        readonly seq: Schema.Int;
+        readonly call: Schema.String;
+        readonly capability: Schema.String;
+        readonly summary: Schema.String;
+        readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>;
+}>, Schema.TaggedStruct<"Unauthorized", {}>, Schema.TaggedStruct<"StreamFailed", {}>]>;
+export type RelayStreamFrame = typeof RelayStreamFrame.Type;
+/** The text a message may carry. */
+export declare const RelayMessageText: Schema.String;
+/**
+ * `POST messages`. `requestId` is the client's: a retry with the same one lands once, and the run that
+ * answers carries it in `runIds`. `backend` switches the session from its next turn on.
+ */
+export declare const RelayMessageRequest: Schema.Struct<{
+    readonly ref: Schema.Struct<{
+        readonly product: Schema.Literals<readonly ["codecommit", "jcf", "agent-usage", "control-center", "herdr"]>;
+        readonly kind: Schema.String;
+        readonly id: Schema.String;
+    }>;
+    readonly text: Schema.String;
+    readonly requestId: Schema.String;
+    readonly backend: Schema.optionalKey<Schema.Literals<readonly ["claude-code", "codex-cli"]>>;
+}>;
+export interface RelayMessageRequest extends Schema.Schema.Type<typeof RelayMessageRequest> {
+}
+/** `messages` answers 202 with the run id, which is the request id. */
+export declare const RelayMessageAccepted: Schema.Struct<{
+    readonly runId: Schema.String;
+}>;
+export interface RelayMessageAccepted extends Schema.Schema.Type<typeof RelayMessageAccepted> {
+}
+/** `POST cancel`: withdraws a queued message, or stops the run in flight. */
+export declare const RelayCancelRequest: Schema.Struct<{
+    readonly ref: Schema.Struct<{
+        readonly product: Schema.Literals<readonly ["codecommit", "jcf", "agent-usage", "control-center", "herdr"]>;
+        readonly kind: Schema.String;
+        readonly id: Schema.String;
+    }>;
+    readonly runId: Schema.String;
+}>;
+export interface RelayCancelRequest extends Schema.Schema.Type<typeof RelayCancelRequest> {
+}
+/** `POST decisions`: the person's answer to one confirmation card. */
+export declare const RelayDecisionRequest: Schema.Struct<{
+    readonly ref: Schema.Struct<{
+        readonly product: Schema.Literals<readonly ["codecommit", "jcf", "agent-usage", "control-center", "herdr"]>;
+        readonly kind: Schema.String;
+        readonly id: Schema.String;
+    }>;
+    readonly callId: Schema.String;
+    readonly allow: Schema.Boolean;
+}>;
+export interface RelayDecisionRequest extends Schema.Schema.Type<typeof RelayDecisionRequest> {
+}
+/** What a 409 found instead: the run already over, or the confirmation decided, expired or never asked. */
+export declare const RelayConflictState: Schema.Union<readonly [Schema.TaggedUnion<{
+    readonly Decided: Schema.TaggedStruct<"Decided", {
+        readonly allow: Schema.Boolean;
+    }>;
+    readonly Expired: Schema.TaggedStruct<"Expired", {}>;
+    readonly Unknown: Schema.TaggedStruct<"Unknown", {}>;
+}>, Schema.TaggedStruct<"NotRunning", {}>]>;
+export type RelayConflictState = typeof RelayConflictState.Type;
+declare const RelayUnavailableError_base: Schema.Class<RelayUnavailableError, Schema.TaggedStruct<"RelayUnavailableError", {
+    readonly message: Schema.String;
+    readonly fix: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** Relay could not start in this process: another one owns its store, or the store is unreadable. */
+export declare class RelayUnavailableError extends RelayUnavailableError_base {
+}
+declare const RelayConflictError_base: Schema.Class<RelayConflictError, Schema.TaggedStruct<"RelayConflictError", {
+    readonly state: Schema.Union<readonly [Schema.TaggedUnion<{
+        readonly Decided: Schema.TaggedStruct<"Decided", {
+            readonly allow: Schema.Boolean;
+        }>;
+        readonly Expired: Schema.TaggedStruct<"Expired", {}>;
+        readonly Unknown: Schema.TaggedStruct<"Unknown", {}>;
+    }>, Schema.TaggedStruct<"NotRunning", {}>]>;
+}>, import("effect/Cause").YieldableError>;
+/** A run or confirmation is no longer in the state the request assumed; `state` says which it is in. */
+export declare class RelayConflictError extends RelayConflictError_base {
+}
+declare const RelayBadRequestError_base: Schema.Class<RelayBadRequestError, Schema.TaggedStruct<"RelayBadRequestError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The request named a backend this server does not offer, or was otherwise malformed. */
+export declare class RelayBadRequestError extends RelayBadRequestError_base {
+}
+//# sourceMappingURL=wire.d.ts.map

package/dist/wire.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wire.d.ts","sourceRoot":"","sources":["../src/wire.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAG/B,OAAO,EACL,aAAa,EACb,uBAAuB,EACvB,gBAAgB,EAChB,aAAa,EACb,SAAS,EACT,YAAY,EACZ,cAAc,EACd,UAAU,EACV,YAAY,EACZ,WAAW,EACX,WAAW,EACX,YAAY,EACb,MAAM,YAAY,CAAA;AAInB,iFAAiF;AACjF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sFAI3B,CAAA;AACF,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAC,IAAI,CAAA;AAE3D,oCAAoC;AACpC,eAAO,MAAM,gBAAgB,eAAuE,CAAA;AAEpG;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;EAK9B,CAAA;AACF,MAAM,WAAW,mBAAoB,SAAQ,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,mBAAmB,CAAC;CAAG;AAE9F,uEAAuE;AACvE,eAAO,MAAM,oBAAoB;;EAA0C,CAAA;AAC3E,MAAM,WAAW,oBAAqB,SAAQ,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,oBAAoB,CAAC;CAAG;AAEhG,6EAA6E;AAC7E,eAAO,MAAM,kBAAkB;;;;;;;EAAiD,CAAA;AAChF,MAAM,WAAW,kBAAmB,SAAQ,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,kBAAkB,CAAC;CAAG;AAE5F,sEAAsE;AACtE,eAAO,MAAM,oBAAoB;;;;;;;;EAAyE,CAAA;AAC1G,MAAM,WAAW,oBAAqB,SAAQ,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,oBAAoB,CAAC;CAAG;AAEhG,2GAA2G;AAC3G,eAAO,MAAM,kBAAkB;;;;;;2CAAuE,CAAA;AACtG,MAAM,MAAM,kBAAkB,GAAG,OAAO,kBAAkB,CAAC,IAAI,CAAA;;;;;AAE/D,qGAAqG;AACrG,qBAAa,qBAAsB,SAAQ,0BAI1C;CAAG;;;;;;;;;;AAEJ,wGAAwG;AACxG,qBAAa,kBAAmB,SAAQ,uBAIvC;CAAG;;;;AAEJ,0FAA0F;AAC1F,qBAAa,oBAAqB,SAAQ,yBAIzC;CAAG"}

package/dist/wire.js

@@ -0,0 +1,145 @@
+// dist/wire.js
+import { Schema as Schema2 } from "effect";
+
+// dist/model.js
+import * as Capability from "@knpkv/capability";
+import { Schema } from "effect";
+var Name = Schema.String.check(Schema.isTrimmed(), Schema.isNonEmpty(), Schema.isMaxLength(200));
+var RelayProduct = Schema.Literals(["codecommit", "jcf", "agent-usage", "control-center", "herdr"]);
+var ObjectRef2 = Schema.Struct({
+  product: RelayProduct,
+  kind: Name,
+  id: Name
+});
+var objectRefKey = (ref) => JSON.stringify([ref.product, ref.kind, ref.id]);
+var CapabilityAccess = Schema.Literals(["read", "write", "host"]);
+var BackendUnavailableCause = Schema.Literals(["NotInstalled", "SignedOut", "Misconfigured", "NoCapability"]);
+var RelayBackendId = Schema.Literals(["claude-code", "codex-cli"]);
+var backendFields = { backend: RelayBackendId, label: Schema.String };
+var BackendStatus = Schema.TaggedUnion({
+  Unverified: { ...backendFields, version: Schema.String },
+  Ready: { ...backendFields, version: Schema.String },
+  Unavailable: {
+    ...backendFields,
+    version: Schema.optionalKey(Schema.String),
+    cause: BackendUnavailableCause,
+    fix: Schema.String
+  }
+});
+var DecisionState = Schema.TaggedUnion({
+  Decided: { allow: Schema.Boolean },
+  Expired: {},
+  Unknown: {}
+});
+var SessionTool = Schema.Struct({
+  name: Name,
+  access: CapabilityAccess,
+  available: Schema.Boolean,
+  unavailableReason: Schema.optional(Schema.String)
+});
+var SessionInfo = Schema.Struct({
+  tools: Schema.Array(SessionTool),
+  backend: RelayBackendId,
+  cancel: Schema.Boolean
+});
+var WriteReceipt = Schema.Struct({
+  summary: Schema.String,
+  providerId: Schema.String,
+  link: Schema.optionalKey(Schema.String)
+});
+var Seq = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
+var eventFields = { session: Name, seq: Seq };
+var RunIds = Schema.Array(Name);
+var RelayEvent = Schema.TaggedUnion({
+  Snapshot: {
+    ...eventFields,
+    messages: Schema.Array(Schema.Struct({ id: Name, role: Schema.Literals(["user", "relay"]), text: Schema.String })),
+    /** The run in flight, empty when idle. */
+    runIds: RunIds,
+    /** Messages accepted but not yet in the transcript, oldest first: they wait for the run in flight. */
+    queued: RunIds
+  },
+  /**
+   * A message the server accepted that waits for the run in flight. It joins the transcript with its own
+   * `MessagePlaced`, or leaves with `MessageWithdrawn`.
+   */
+  MessageQueued: { ...eventFields, requestId: Name },
+  /** A message the server placed in the transcript; `id` is its transcript id, as a later Snapshot names it. */
+  MessagePlaced: { ...eventFields, id: Name, requestId: Name, text: Schema.String },
+  /** A queued message the person withdrew before any run took it. */
+  MessageWithdrawn: { ...eventFields, requestId: Name },
+  RunStarted: { ...eventFields, runIds: RunIds },
+  TextDelta: { ...eventFields, text: Schema.String },
+  /** `summary` is a server-built, display-safe line; `input` is the call's typed arguments. */
+  ToolStarted: { ...eventFields, call: Name, capability: Name, summary: Schema.String, input: Schema.Json },
+  /** `receipt` is set when a write completed and its capability projects one. */
+  ToolFinished: {
+    ...eventFields,
+    call: Name,
+    ok: Schema.Boolean,
+    summary: Schema.String,
+    cites: Schema.Array(Capability.ObjectRef),
+    receipt: Schema.optionalKey(WriteReceipt)
+  },
+  ConfirmationRequired: { ...eventFields, call: Name, action: Capability.PendingAction, reversible: Schema.Boolean },
+  /** The server's outcome for a confirmation: the card turns to past tense only on this. */
+  ConfirmationResolved: {
+    ...eventFields,
+    call: Name,
+    decision: Schema.Literals(["confirmed", "declined", "expired"])
+  },
+  ApprovalPending: { ...eventFields, call: Name, approvalId: Name },
+  Cancelled: { ...eventFields, runIds: RunIds },
+  RunFinished: { ...eventFields, runIds: RunIds },
+  RunFailed: { ...eventFields, runIds: RunIds, cause: Schema.String, fix: Schema.String }
+});
+
+// dist/wire.js
+var Name2 = Schema2.String.check(Schema2.isTrimmed(), Schema2.isNonEmpty(), Schema2.isMaxLength(200));
+var RelayStreamFrame = Schema2.Union([
+  RelayEvent,
+  Schema2.TaggedStruct("Unauthorized", {}),
+  Schema2.TaggedStruct("StreamFailed", {})
+]);
+var RelayMessageText = Schema2.String.check(Schema2.isNonEmpty(), Schema2.isMaxLength(2e4));
+var RelayMessageRequest = Schema2.Struct({
+  ref: ObjectRef2,
+  text: RelayMessageText,
+  requestId: Name2,
+  backend: Schema2.optionalKey(RelayBackendId)
+});
+var RelayMessageAccepted = Schema2.Struct({ runId: Schema2.String });
+var RelayCancelRequest = Schema2.Struct({ ref: ObjectRef2, runId: Name2 });
+var RelayDecisionRequest = Schema2.Struct({ ref: ObjectRef2, callId: Name2, allow: Schema2.Boolean });
+var RelayConflictState = Schema2.Union([DecisionState, Schema2.TaggedStruct("NotRunning", {})]);
+var RelayUnavailableError = class extends Schema2.TaggedError()("RelayUnavailableError", { message: Schema2.String, fix: Schema2.String }, { httpApiStatus: 503 }) {
+};
+var RelayConflictError = class extends Schema2.TaggedError()("RelayConflictError", { state: RelayConflictState }, { httpApiStatus: 409 }) {
+};
+var RelayBadRequestError = class extends Schema2.TaggedError()("RelayBadRequestError", { message: Schema2.String }, { httpApiStatus: 400 }) {
+};
+export {
+  BackendStatus,
+  BackendUnavailableCause,
+  CapabilityAccess,
+  DecisionState,
+  ObjectRef2 as ObjectRef,
+  RelayBackendId,
+  RelayBadRequestError,
+  RelayCancelRequest,
+  RelayConflictError,
+  RelayConflictState,
+  RelayDecisionRequest,
+  RelayEvent,
+  RelayMessageAccepted,
+  RelayMessageRequest,
+  RelayMessageText,
+  RelayProduct,
+  RelayStreamFrame,
+  RelayUnavailableError,
+  SessionInfo,
+  SessionTool,
+  WriteReceipt,
+  objectRefKey
+};
+//# sourceMappingURL=wire.js.map

package/dist/wire.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/wire.ts", "../src/model.ts"],
+  "sourcesContent": ["/**\n * Relay's wire contract: what a product's `/\u2026/relay` routes accept and send, and what the browser decodes.\n * Browser-safe: it imports only `effect` and `@knpkv/capability`, never the harness, Pi or SQLite, so a page\n * can import `@knpkv/relay/wire` without pulling the server in.\n *\n * **Mental model**\n *\n * - **One stream per conversation.** `GET events?product&kind&id` sends `data: <RelayStreamFrame JSON>`\n *   frames: a `Snapshot` first, then live {@link RelayEvent}s. `Unauthorized` (the browser's session ended)\n *   and `StreamFailed` (the server could not read the session's events) end the stream.\n * - **Writes answer with what happened.** `messages` is 202 {@link RelayMessageAccepted}; `cancel` and\n *   `decisions` are 204, or 409 {@link RelayConflictError} with the state they found. Every route can be 503\n *   {@link RelayUnavailableError} with the fix when Relay could not start in that process.\n *\n * A product narrows `ref` to its own objects and may add a typed `context` to a message; both are its own\n * schema built on these.\n *\n * @module\n */\nimport { Schema } from \"effect\"\nimport { DecisionState, ObjectRef, RelayBackendId, RelayEvent } from \"./model.js\"\n\nexport {\n  BackendStatus,\n  BackendUnavailableCause,\n  CapabilityAccess,\n  DecisionState,\n  ObjectRef,\n  objectRefKey,\n  RelayBackendId,\n  RelayEvent,\n  RelayProduct,\n  SessionInfo,\n  SessionTool,\n  WriteReceipt\n} from \"./model.js\"\n\nconst Name = Schema.String.check(Schema.isTrimmed(), Schema.isNonEmpty(), Schema.isMaxLength(200))\n\n/** One `data:` frame of the events stream: an event, or why the stream ended. */\nexport const RelayStreamFrame = Schema.Union([\n  RelayEvent,\n  Schema.TaggedStruct(\"Unauthorized\", {}),\n  Schema.TaggedStruct(\"StreamFailed\", {})\n])\nexport type RelayStreamFrame = typeof RelayStreamFrame.Type\n\n/** The text a message may carry. */\nexport const RelayMessageText = Schema.String.check(Schema.isNonEmpty(), Schema.isMaxLength(20_000))\n\n/**\n * `POST messages`. `requestId` is the client's: a retry with the same one lands once, and the run that\n * answers carries it in `runIds`. `backend` switches the session from its next turn on.\n */\nexport const RelayMessageRequest = Schema.Struct({\n  ref: ObjectRef,\n  text: RelayMessageText,\n  requestId: Name,\n  backend: Schema.optionalKey(RelayBackendId)\n})\nexport interface RelayMessageRequest extends Schema.Schema.Type<typeof RelayMessageRequest> {}\n\n/** `messages` answers 202 with the run id, which is the request id. */\nexport const RelayMessageAccepted = Schema.Struct({ runId: Schema.String })\nexport interface RelayMessageAccepted extends Schema.Schema.Type<typeof RelayMessageAccepted> {}\n\n/** `POST cancel`: withdraws a queued message, or stops the run in flight. */\nexport const RelayCancelRequest = Schema.Struct({ ref: ObjectRef, runId: Name })\nexport interface RelayCancelRequest extends Schema.Schema.Type<typeof RelayCancelRequest> {}\n\n/** `POST decisions`: the person's answer to one confirmation card. */\nexport const RelayDecisionRequest = Schema.Struct({ ref: ObjectRef, callId: Name, allow: Schema.Boolean })\nexport interface RelayDecisionRequest extends Schema.Schema.Type<typeof RelayDecisionRequest> {}\n\n/** What a 409 found instead: the run already over, or the confirmation decided, expired or never asked. */\nexport const RelayConflictState = Schema.Union([DecisionState, Schema.TaggedStruct(\"NotRunning\", {})])\nexport type RelayConflictState = typeof RelayConflictState.Type\n\n/** Relay could not start in this process: another one owns its store, or the store is unreadable. */\nexport class RelayUnavailableError extends Schema.TaggedError<RelayUnavailableError>()(\n  \"RelayUnavailableError\",\n  { message: Schema.String, fix: Schema.String },\n  { httpApiStatus: 503 }\n) {}\n\n/** A run or confirmation is no longer in the state the request assumed; `state` says which it is in. */\nexport class RelayConflictError extends Schema.TaggedError<RelayConflictError>()(\n  \"RelayConflictError\",\n  { state: RelayConflictState },\n  { httpApiStatus: 409 }\n) {}\n\n/** The request named a backend this server does not offer, or was otherwise malformed. */\nexport class RelayBadRequestError extends Schema.TaggedError<RelayBadRequestError>()(\n  \"RelayBadRequestError\",\n  { message: Schema.String },\n  { httpApiStatus: 400 }\n) {}\n", "/**\n * The Relay contracts every product and the dock share.\n *\n * **Mental model**\n *\n * - **An {@link ObjectRef} is what a conversation is about.** A pull request, a jcf week, a herdr\n *   goal. Relay keeps one durable session per ref, so the same question about the same object finds\n *   its history again.\n * - **A capability (`@knpkv/capability`) is the only way Relay touches a product.** Its contract declares\n *   input, output and failure as Schema, and its access: `read` runs, `write` waits for the person to\n *   confirm the exact action in the dock, `host` waits for a herdr Approval. The harness enforces it; the\n *   product never sees an unconfirmed write.\n * - **A {@link RelayEvent} is the only thing the dock renders.** Every event carries the session and a\n *   `seq` that counts up within one subscription. A dock that reconnects starts a new subscription: a\n *   `Snapshot` first (with any run in flight and any pending confirmation), then live events. `seq` is not\n *   comparable across subscriptions; render the Snapshot rather than deduplicating by `seq`.\n *\n * @module\n */\nimport * as Capability from \"@knpkv/capability\"\nimport { Schema } from \"effect\"\n\nconst Name = Schema.String.check(Schema.isTrimmed(), Schema.isNonEmpty(), Schema.isMaxLength(200))\n\n/** The products Relay can be about. */\nexport const RelayProduct = Schema.Literals([\"codecommit\", \"jcf\", \"agent-usage\", \"control-center\", \"herdr\"])\nexport type RelayProduct = typeof RelayProduct.Type\n\n/** A product object a Relay session is about. Relay keeps sessions only for the products it knows. */\nexport const ObjectRef = Schema.Struct({\n  product: RelayProduct,\n  kind: Name,\n  id: Name\n})\nexport interface ObjectRef extends Schema.Schema.Type<typeof ObjectRef> {}\n\n/** The key a session is stored under. Unique per product, kind and id: JSON-encoded, so no field can contain the separator. */\nexport const objectRefKey = (ref: ObjectRef): string => JSON.stringify([ref.product, ref.kind, ref.id])\n\n/** Who must agree before a capability runs, as the dock lists it. */\nexport const CapabilityAccess = Schema.Literals([\"read\", \"write\", \"host\"])\nexport type CapabilityAccess = typeof CapabilityAccess.Type\n\n/** Why a backend can't answer yet, and the one action that fixes it. */\nexport const BackendUnavailableCause = Schema.Literals([\"NotInstalled\", \"SignedOut\", \"Misconfigured\", \"NoCapability\"])\nexport type BackendUnavailableCause = typeof BackendUnavailableCause.Type\n\n/** The backends Relay supports: each runs on the user's own CLI login, never on a token Relay holds. */\nexport const RelayBackendId = Schema.Literals([\"claude-code\", \"codex-cli\"])\nexport type RelayBackendId = typeof RelayBackendId.Type\n\nconst backendFields = { backend: RelayBackendId, label: Schema.String }\n\n/**\n * What setup shows for one backend. `Unverified` (installed, version known, never answered yet) until a turn\n * answers (`Ready`) or is refused for sign-in (`Unavailable` with `SignedOut`). Not persisted: every start is\n * `Unverified` or `Unavailable` again. `fix` is one line the person can act on.\n */\nexport const BackendStatus = Schema.TaggedUnion({\n  Unverified: { ...backendFields, version: Schema.String },\n  Ready: { ...backendFields, version: Schema.String },\n  Unavailable: {\n    ...backendFields,\n    version: Schema.optionalKey(Schema.String),\n    cause: BackendUnavailableCause,\n    fix: Schema.String\n  }\n})\nexport type BackendStatus = typeof BackendStatus.Type\n\n/** Why a confirmation can't be answered: answered already, withdrawn with its run, or never asked. */\nexport const DecisionState = Schema.TaggedUnion({\n  Decided: { allow: Schema.Boolean },\n  Expired: {},\n  Unknown: {}\n})\nexport type DecisionState = typeof DecisionState.Type\n\n/** One tool as the dock lists it for a session. */\nexport const SessionTool = Schema.Struct({\n  name: Name,\n  access: CapabilityAccess,\n  available: Schema.Boolean,\n  unavailableReason: Schema.optional(Schema.String)\n})\nexport interface SessionTool extends Schema.Schema.Type<typeof SessionTool> {}\n\n/**\n * What the dock shows for a session: its tools, the backend its next turn runs on, and whether a run can\n * be stopped (the dock offers Stop only when `cancel` is true).\n */\nexport const SessionInfo = Schema.Struct({\n  tools: Schema.Array(SessionTool),\n  backend: RelayBackendId,\n  cancel: Schema.Boolean\n})\nexport interface SessionInfo extends Schema.Schema.Type<typeof SessionInfo> {}\n\n/**\n * What a confirmed write did, as the product projects it: a display-safe line, the provider's id for what\n * was made, and where to see it.\n */\nexport const WriteReceipt = Schema.Struct({\n  summary: Schema.String,\n  providerId: Schema.String,\n  link: Schema.optionalKey(Schema.String)\n})\nexport interface WriteReceipt extends Schema.Schema.Type<typeof WriteReceipt> {}\n\nconst Seq = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))\n\nconst eventFields = { session: Name, seq: Seq }\n\n/** The `requestId`s of the messages a run answers: one run can take several queued messages. */\nconst RunIds = Schema.Array(Name)\n\n/** Everything the dock renders. `seq` counts up within one subscription; a reconnect starts from a `Snapshot`. */\nexport const RelayEvent = Schema.TaggedUnion({\n  Snapshot: {\n    ...eventFields,\n    messages: Schema.Array(\n      Schema.Struct({ id: Name, role: Schema.Literals([\"user\", \"relay\"]), text: Schema.String })\n    ),\n    /** The run in flight, empty when idle. */\n    runIds: RunIds,\n    /** Messages accepted but not yet in the transcript, oldest first: they wait for the run in flight. */\n    queued: RunIds\n  },\n  /**\n   * A message the server accepted that waits for the run in flight. It joins the transcript with its own\n   * `MessagePlaced`, or leaves with `MessageWithdrawn`.\n   */\n  MessageQueued: { ...eventFields, requestId: Name },\n  /** A message the server placed in the transcript; `id` is its transcript id, as a later Snapshot names it. */\n  MessagePlaced: { ...eventFields, id: Name, requestId: Name, text: Schema.String },\n  /** A queued message the person withdrew before any run took it. */\n  MessageWithdrawn: { ...eventFields, requestId: Name },\n  RunStarted: { ...eventFields, runIds: RunIds },\n  TextDelta: { ...eventFields, text: Schema.String },\n  /** `summary` is a server-built, display-safe line; `input` is the call's typed arguments. */\n  ToolStarted: { ...eventFields, call: Name, capability: Name, summary: Schema.String, input: Schema.Json },\n  /** `receipt` is set when a write completed and its capability projects one. */\n  ToolFinished: {\n    ...eventFields,\n    call: Name,\n    ok: Schema.Boolean,\n    summary: Schema.String,\n    cites: Schema.Array(Capability.ObjectRef),\n    receipt: Schema.optionalKey(WriteReceipt)\n  },\n  ConfirmationRequired: { ...eventFields, call: Name, action: Capability.PendingAction, reversible: Schema.Boolean },\n  /** The server's outcome for a confirmation: the card turns to past tense only on this. */\n  ConfirmationResolved: {\n    ...eventFields,\n    call: Name,\n    decision: Schema.Literals([\"confirmed\", \"declined\", \"expired\"])\n  },\n  ApprovalPending: { ...eventFields, call: Name, approvalId: Name },\n  Cancelled: { ...eventFields, runIds: RunIds },\n  RunFinished: { ...eventFields, runIds: RunIds },\n  RunFailed: { ...eventFields, runIds: RunIds, cause: Schema.String, fix: Schema.String }\n})\nexport type RelayEvent = typeof RelayEvent.Type\n"],
+  "mappings": "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",
+  "names": ["Schema", "ObjectRef", "Name", "Schema", "ObjectRef"]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knpkv/relay",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Relay agent harness: durable sessions per product object, typed capabilities, a central permission gate, and model turns through the user's own Claude Code or Codex CLI login",
   "license": "MIT",
   "author": "knpkv",
@@ -17,6 +17,10 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./wire": {
+      "types": "./dist/wire.d.ts",
+      "import": "./dist/wire.js"
     }
   },
   "files": [
@@ -37,8 +41,8 @@
     "@libsql/client": "^0.18.0",
     "typebox": "1.3.27",
     "@knpkv/ai-claude": "^0.4.3",
-    "@knpkv/ai-codex": "^0.5.3",
     "@knpkv/ai-runtime": "^0.5.2",
+    "@knpkv/ai-codex": "^0.5.3",
     "@knpkv/capability": "^0.1.0"
   },
   "devDependencies": {