@knpkv/relay 0.0.0-stage → 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

@@ -0,0 +1,207 @@
+import { Schema } from "effect";
+/** The products Relay can be about. */
+export declare const RelayProduct: Schema.Literals<readonly ["codecommit", "jcf", "agent-usage", "control-center", "herdr"]>;
+export type RelayProduct = typeof RelayProduct.Type;
+/** A product object a Relay session is about. Relay keeps sessions only for the products it knows. */
+export declare const ObjectRef: Schema.Struct<{
+    readonly product: Schema.Literals<readonly ["codecommit", "jcf", "agent-usage", "control-center", "herdr"]>;
+    readonly kind: Schema.String;
+    readonly id: Schema.String;
+}>;
+export interface ObjectRef extends Schema.Schema.Type<typeof ObjectRef> {
+}
+/** The key a session is stored under. Unique per product, kind and id: JSON-encoded, so no field can contain the separator. */
+export declare const objectRefKey: (ref: ObjectRef) => string;
+/** Who must agree before a capability runs, as the dock lists it. */
+export declare const CapabilityAccess: Schema.Literals<readonly ["read", "write", "host"]>;
+export type CapabilityAccess = typeof CapabilityAccess.Type;
+/** Why a backend can't answer yet, and the one action that fixes it. */
+export declare const BackendUnavailableCause: Schema.Literals<readonly ["NotInstalled", "SignedOut", "Misconfigured", "NoCapability"]>;
+export type BackendUnavailableCause = typeof BackendUnavailableCause.Type;
+/** The backends Relay supports: each runs on the user's own CLI login, never on a token Relay holds. */
+export declare const RelayBackendId: Schema.Literals<readonly ["claude-code", "codex-cli"]>;
+export type RelayBackendId = typeof RelayBackendId.Type;
+/**
+ * What setup shows for one backend. `Unverified` (installed, version known, never answered yet) until a turn
+ * answers (`Ready`) or is refused for sign-in (`Unavailable` with `SignedOut`). Not persisted: every start is
+ * `Unverified` or `Unavailable` again. `fix` is one line the person can act on.
+ */
+export declare const BackendStatus: Schema.TaggedUnion<{
+    readonly Ready: Schema.TaggedStruct<"Ready", {
+        readonly backend: Schema.Literals<readonly ["claude-code", "codex-cli"]>;
+        readonly label: Schema.String;
+        readonly version: Schema.String;
+    }>;
+    readonly Unavailable: Schema.TaggedStruct<"Unavailable", {
+        readonly backend: Schema.Literals<readonly ["claude-code", "codex-cli"]>;
+        readonly label: Schema.String;
+        readonly version: Schema.optionalKey<Schema.String>;
+        readonly cause: Schema.Literals<readonly ["NotInstalled", "SignedOut", "Misconfigured", "NoCapability"]>;
+        readonly fix: Schema.String;
+    }>;
+    readonly Unverified: Schema.TaggedStruct<"Unverified", {
+        readonly backend: Schema.Literals<readonly ["claude-code", "codex-cli"]>;
+        readonly label: Schema.String;
+        readonly version: Schema.String;
+    }>;
+}>;
+export type BackendStatus = typeof BackendStatus.Type;
+/** Why a confirmation can't be answered: answered already, withdrawn with its run, or never asked. */
+export declare const DecisionState: Schema.TaggedUnion<{
+    readonly Decided: Schema.TaggedStruct<"Decided", {
+        readonly allow: Schema.Boolean;
+    }>;
+    readonly Expired: Schema.TaggedStruct<"Expired", {}>;
+    readonly Unknown: Schema.TaggedStruct<"Unknown", {}>;
+}>;
+export type DecisionState = typeof DecisionState.Type;
+/** One tool as the dock lists it for a session. */
+export declare const SessionTool: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly access: Schema.Literals<readonly ["read", "write", "host"]>;
+    readonly available: Schema.Boolean;
+    readonly unavailableReason: Schema.optional<Schema.String>;
+}>;
+export interface SessionTool extends Schema.Schema.Type<typeof SessionTool> {
+}
+/**
+ * What the dock shows for a session: its tools, the backend its next turn runs on, and whether a run can
+ * be stopped (the dock offers Stop only when `cancel` is true).
+ */
+export declare const SessionInfo: Schema.Struct<{
+    readonly tools: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly access: Schema.Literals<readonly ["read", "write", "host"]>;
+        readonly available: Schema.Boolean;
+        readonly unavailableReason: Schema.optional<Schema.String>;
+    }>>;
+    readonly backend: Schema.Literals<readonly ["claude-code", "codex-cli"]>;
+    readonly cancel: Schema.Boolean;
+}>;
+export interface SessionInfo extends Schema.Schema.Type<typeof SessionInfo> {
+}
+/**
+ * What a confirmed write did, as the product projects it: a display-safe line, the provider's id for what
+ * was made, and where to see it.
+ */
+export declare const WriteReceipt: Schema.Struct<{
+    readonly summary: Schema.String;
+    readonly providerId: Schema.String;
+    readonly link: Schema.optionalKey<Schema.String>;
+}>;
+export interface WriteReceipt extends Schema.Schema.Type<typeof WriteReceipt> {
+}
+/** Everything the dock renders. `seq` counts up within one subscription; a reconnect starts from a `Snapshot`. */
+export declare const RelayEvent: 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;
+        }>>;
+        /** 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;
+        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>;
+    }>;
+}>;
+export type RelayEvent = typeof RelayEvent.Type;
+//# sourceMappingURL=model.d.ts.map

package/dist/model.d.ts.map

@@ -0,0 +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;;QAE1C,sGAAsG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoCxG,CAAA;AACF,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC,IAAI,CAAA"}

package/dist/registry.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Capabilities as the harness holds them: one list of `@knpkv/capability` capabilities with their
+ * types closed over, so the harness can run any of them from the model's JSON without `any`.
+ *
+ * Decoding, encoding and failure handling are the capability package's (`invoke`, `describeCall`);
+ * this module only erases types and records what the gate needs.
+ *
+ * @module
+ */
+import { type Capability, type CapabilityEncodingFailed, type CapabilityFailed, type CapabilityInputInvalid, type FailureSchema, type InputSchema, type InvocationResult, type PendingAction, type PlainSchema } from "@knpkv/capability";
+import { Schema } from "effect";
+import type { Effect } from "effect";
+import type * as JsonSchema from "effect/JsonSchema";
+import type { WriteReceipt } from "./model.js";
+/** What a person must agree to before a gated capability runs. */
+export interface Gate {
+    readonly access: "write" | "host";
+    readonly reversible: boolean;
+    readonly describe: (args: Schema.Json) => Effect.Effect<PendingAction, CapabilityInputInvalid | CapabilityEncodingFailed>;
+}
+/** One registered capability, its types erased behind closures. */
+export interface RegisteredCapability<Requirements> {
+    readonly name: string;
+    readonly description: string;
+    /** `undefined` for a read: it runs without anyone agreeing first. */
+    readonly gate: Gate | undefined;
+    /** A short display name, for activity rows. */
+    readonly label: string;
+    /** A display-safe line for one call: a write's action verb, or the label. */
+    readonly summarize: (args: Schema.Json) => string;
+    /** What a completed call made, for writes whose product projects a receipt. */
+    readonly receipt: (result: InvocationResult) => WriteReceipt | undefined;
+    /** JSON Schema of the input, for the model's tool list and argument validation. */
+    readonly parameters: JsonSchema.JsonSchema;
+    /** `args` is the model's JSON for this call; the capability decodes it at the boundary. */
+    readonly run: (args: Schema.Json) => Effect.Effect<InvocationResult, CapabilityInputInvalid | CapabilityFailed | CapabilityEncodingFailed, Requirements>;
+}
+/** How the dock shows a capability's calls. Every field has a default. */
+export interface DisplayOptions<Output extends PlainSchema> {
+    /** Defaults to the capability name with spaces: `get_pull_request` is "get pull request". */
+    readonly label?: string;
+    /** A write's receipt, from its decoded output: a display-safe line, the provider's id, a link. */
+    readonly receipt?: (output: Output["Type"]) => WriteReceipt;
+}
+/** Register a capability for Relay, with how the dock shows its calls. */
+export declare const register: <Name extends string, Input extends InputSchema, Output extends PlainSchema, Failure extends FailureSchema, Requirements>(capability: Capability<Name, Input, Output, Failure, Requirements>, display?: DisplayOptions<Output>) => RegisteredCapability<Requirements>;
+//# sourceMappingURL=registry.d.ts.map

package/dist/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EACL,KAAK,UAAU,EACf,KAAK,wBAAwB,EAC7B,KAAK,gBAAgB,EACrB,KAAK,sBAAsB,EAE3B,KAAK,aAAa,EAElB,KAAK,WAAW,EAChB,KAAK,gBAAgB,EAErB,KAAK,aAAa,EAClB,KAAK,WAAW,EACjB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EAAU,MAAM,EAAE,MAAM,QAAQ,CAAA;AACvC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AACpC,OAAO,KAAK,KAAK,UAAU,MAAM,mBAAmB,CAAA;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAE9C,kEAAkE;AAClE,MAAM,WAAW,IAAI;IACnB,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAAA;IACjC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAA;IAC5B,QAAQ,CAAC,QAAQ,EAAE,CACjB,IAAI,EAAE,MAAM,CAAC,IAAI,KACd,MAAM,CAAC,MAAM,CAAC,aAAa,EAAE,sBAAsB,GAAG,wBAAwB,CAAC,CAAA;CACrF;AAED,mEAAmE;AACnE,MAAM,WAAW,oBAAoB,CAAC,YAAY;IAChD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,qEAAqE;IACrE,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,SAAS,CAAA;IAC/B,+CAA+C;IAC/C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,6EAA6E;IAC7E,QAAQ,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,KAAK,MAAM,CAAA;IACjD,+EAA+E;IAC/E,QAAQ,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,gBAAgB,KAAK,YAAY,GAAG,SAAS,CAAA;IACxE,mFAAmF;IACnF,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC,UAAU,CAAA;IAC1C,2FAA2F;IAC3F,QAAQ,CAAC,GAAG,EAAE,CACZ,IAAI,EAAE,MAAM,CAAC,IAAI,KACd,MAAM,CAAC,MAAM,CAChB,gBAAgB,EAChB,sBAAsB,GAAG,gBAAgB,GAAG,wBAAwB,EACpE,YAAY,CACb,CAAA;CACF;AAED,0EAA0E;AAC1E,MAAM,WAAW,cAAc,CAAC,MAAM,SAAS,WAAW;IACxD,6FAA6F;IAC7F,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;IACvB,kGAAkG;IAClG,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,KAAK,YAAY,CAAA;CAC5D;AAED,0EAA0E;AAC1E,eAAO,MAAM,QAAQ,GACnB,IAAI,SAAS,MAAM,EACnB,KAAK,SAAS,WAAW,EACzB,MAAM,SAAS,WAAW,EAC1B,OAAO,SAAS,aAAa,EAC7B,YAAY,cAEA,UAAU,CAAC,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,CAAC,YACzD,cAAc,CAAC,MAAM,CAAC,KAC9B,oBAAoB,CAAC,YAAY,CA0BnC,CAAA"}

package/dist/turn.d.ts

@@ -0,0 +1,68 @@
+/**
+ * One model turn over a CLI-backed `LanguageModel`, with tool calls carried in a JSON schema.
+ *
+ * **Mental model**
+ *
+ * - **The CLI never runs tools.** `claude --print` and `codex exec` are asked for one structured
+ *   answer: either tool calls or a final reply. The harness runs the tools, behind its gate, and the
+ *   next turn sees their results. That keeps the user's own CLI login as the only credential and the
+ *   permission gate as the only path to a product.
+ * - **The transcript is rendered, not replayed into provider sessions.** Each turn gets the whole
+ *   visible transcript, so switching backends mid-session needs no provider state.
+ *
+ * @module
+ */
+import { Effect, Schema } from "effect";
+import { LanguageModel } from "effect/ai";
+/** A tool as the model is told about it. */
+export interface TurnTool {
+    readonly name: string;
+    readonly description: string;
+    readonly parameters: Schema.Json;
+}
+/** One transcript line as the model reads it. */
+export type TurnLine = {
+    readonly _tag: "User";
+    readonly text: string;
+} | {
+    readonly _tag: "Relay";
+    readonly text: string;
+} | {
+    readonly _tag: "ToolCall";
+    readonly id: string;
+    readonly name: string;
+    readonly arguments: Schema.Json;
+} | {
+    readonly _tag: "ToolResult";
+    readonly id: string;
+    readonly name: string;
+    readonly text: string;
+    readonly isError: boolean;
+};
+export interface TurnRequest {
+    readonly instructions: string;
+    readonly tools: ReadonlyArray<TurnTool>;
+    readonly transcript: ReadonlyArray<TurnLine>;
+}
+/** What the model returns for one turn. An empty `toolCalls` means `reply` is the final answer. */
+export declare const Turn: Schema.Struct<{
+    readonly reply: Schema.String;
+    readonly toolCalls: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly arguments: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    }>>;
+}>;
+export type Turn = typeof Turn.Type;
+/** The prompt one turn sends: instructions, the tool list with schemas, the transcript, the answer rule. */
+export declare const renderTurnPrompt: (request: TurnRequest) => string;
+/** Run one turn on whatever `LanguageModel` is provided: the user's Claude Code or Codex CLI. */
+export declare const runTurn: (request: TurnRequest) => Effect.Effect<{
+    readonly reply: string;
+    readonly toolCalls: readonly {
+        readonly name: string;
+        readonly arguments: {
+            readonly [x: string]: Schema.Json;
+        };
+    }[];
+}, import("effect/ai/AiError").AiError, LanguageModel.LanguageModel>;
+//# sourceMappingURL=turn.d.ts.map

package/dist/turn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"turn.d.ts","sourceRoot":"","sources":["../src/turn.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AACvC,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAEzC,4CAA4C;AAC5C,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,IAAI,CAAA;CACjC;AAED,iDAAiD;AACjD,MAAM,MAAM,QAAQ,GAChB;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAChD;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACjD;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,IAAI,CAAA;CAAE,GAC1G;IACA,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;IAC3B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CAC1B,CAAA;AAEH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAA;IACvC,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAA;CAC7C;AAED,mGAAmG;AACnG,eAAO,MAAM,IAAI;;;;;;EAGf,CAAA;AACF,MAAM,MAAM,IAAI,GAAG,OAAO,IAAI,CAAC,IAAI,CAAA;AAenC,4GAA4G;AAC5G,eAAO,MAAM,gBAAgB,YAAa,WAAW,KAAG,MAmB1C,CAAA;AAEd,iGAAiG;AACjG,eAAO,MAAM,OAAO;;;;;;;;oEAOlB,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"}