@crewhaus/gateway-protocol 0.1.4 → 0.1.6

package/dist/index.d.ts

@@ -0,0 +1,249 @@
+/**
+ * Catalog R16 `gateway-protocol` — wire contract for the managed-daemon
+ * gateway.
+ *
+ * Every request and response is wrapped in a versioned envelope so
+ * future protocol revisions can fan out on `protocol`. v1 carries:
+ *
+ *   { protocol: "crewhaus.v1", id: <opaque>, method: <string>, params: <obj> }
+ *
+ * All schemas are exported as Zod runtime validators; the inferred
+ * types are the canonical TS API. Reference clients (TS, Python) ship
+ * alongside this package — see `clients/` for snippets external app
+ * servers can paste into their own build.
+ *
+ * Methods (v1):
+ *   runs.create        — start a new run, return runId
+ *   runs.continue      — append a user turn to an existing session
+ *   runs.cancel        — abort an in-flight run
+ *   runs.subscribe     — SSE stream of trace events for a runId
+ *   sessions.list      — list per-tenant sessions
+ *   sessions.fork      — branch a session at a specific event
+ *   audit.tail         — stream the per-tenant audit log
+ *
+ * Layer R16. Pairs with `gateway-server` (R16 — Bun.serve daemon) and
+ * `target-managed` (F2 — codegen).
+ */
+import { CrewhausError } from "@crewhaus/errors";
+import { z } from "zod";
+export declare const PROTOCOL_VERSION: "crewhaus.v1";
+export declare class GatewayProtocolError extends CrewhausError {
+    readonly name = "GatewayProtocolError";
+    constructor(message: string, cause?: unknown);
+}
+export declare const ResponseEnvelope: z.ZodUnion<[z.ZodObject<{
+    protocol: z.ZodLiteral<"crewhaus.v1">;
+    id: z.ZodString;
+    result: z.ZodUnknown;
+}, "strict", z.ZodTypeAny, {
+    protocol: "crewhaus.v1";
+    id: string;
+    result?: unknown;
+}, {
+    protocol: "crewhaus.v1";
+    id: string;
+    result?: unknown;
+}>, z.ZodObject<{
+    protocol: z.ZodLiteral<"crewhaus.v1">;
+    id: z.ZodString;
+    error: z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        data: z.ZodOptional<z.ZodUnknown>;
+    }, "strict", z.ZodTypeAny, {
+        code: string;
+        message: string;
+        data?: unknown;
+    }, {
+        code: string;
+        message: string;
+        data?: unknown;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    protocol: "crewhaus.v1";
+    id: string;
+    error: {
+        code: string;
+        message: string;
+        data?: unknown;
+    };
+}, {
+    protocol: "crewhaus.v1";
+    id: string;
+    error: {
+        code: string;
+        message: string;
+        data?: unknown;
+    };
+}>]>;
+export declare const RequestEnvelope: z.ZodObject<{
+    protocol: z.ZodLiteral<"crewhaus.v1">;
+    id: z.ZodString;
+    method: z.ZodString;
+    params: z.ZodUnknown;
+}, "strict", z.ZodTypeAny, {
+    protocol: "crewhaus.v1";
+    id: string;
+    method: string;
+    params?: unknown;
+}, {
+    protocol: "crewhaus.v1";
+    id: string;
+    method: string;
+    params?: unknown;
+}>;
+export type RequestEnvelopeT = z.infer<typeof RequestEnvelope>;
+export type ResponseEnvelopeT = z.infer<typeof ResponseEnvelope>;
+export declare const RunsCreateParams: z.ZodObject<{
+    spec: z.ZodString;
+    input: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    spec: string;
+    input: string;
+    sessionId?: string | undefined;
+}, {
+    spec: string;
+    input: string;
+    sessionId?: string | undefined;
+}>;
+export declare const RunsCreateResult: z.ZodObject<{
+    runId: z.ZodString;
+    sessionId: z.ZodString;
+    tenantId: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    sessionId: string;
+    runId: string;
+    tenantId: string;
+}, {
+    sessionId: string;
+    runId: string;
+    tenantId: string;
+}>;
+export type RunsCreateParamsT = z.infer<typeof RunsCreateParams>;
+export type RunsCreateResultT = z.infer<typeof RunsCreateResult>;
+export declare const RunsContinueParams: z.ZodObject<{
+    sessionId: z.ZodString;
+    input: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    input: string;
+    sessionId: string;
+}, {
+    input: string;
+    sessionId: string;
+}>;
+export declare const RunsContinueResult: z.ZodObject<{
+    runId: z.ZodString;
+    sessionId: z.ZodString;
+    tenantId: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    sessionId: string;
+    runId: string;
+    tenantId: string;
+}, {
+    sessionId: string;
+    runId: string;
+    tenantId: string;
+}>;
+export type RunsContinueParamsT = z.infer<typeof RunsContinueParams>;
+export type RunsContinueResultT = z.infer<typeof RunsContinueResult>;
+export declare const RunsCancelParams: z.ZodObject<{
+    runId: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    runId: string;
+}, {
+    runId: string;
+}>;
+export declare const RunsCancelResult: z.ZodObject<{
+    ok: z.ZodBoolean;
+}, "strict", z.ZodTypeAny, {
+    ok: boolean;
+}, {
+    ok: boolean;
+}>;
+export type RunsCancelParamsT = z.infer<typeof RunsCancelParams>;
+export type RunsCancelResultT = z.infer<typeof RunsCancelResult>;
+export declare const RunsSubscribeParams: z.ZodObject<{
+    runId: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    runId: string;
+}, {
+    runId: string;
+}>;
+export type RunsSubscribeParamsT = z.infer<typeof RunsSubscribeParams>;
+export declare const SessionsListParams: z.ZodObject<{}, "strict", z.ZodTypeAny, {}, {}>;
+export declare const SessionsListResult: z.ZodObject<{
+    sessions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        tenantId: z.ZodString;
+        updatedAt: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        tenantId: string;
+        updatedAt: string;
+    }, {
+        id: string;
+        tenantId: string;
+        updatedAt: string;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    sessions: {
+        id: string;
+        tenantId: string;
+        updatedAt: string;
+    }[];
+}, {
+    sessions: {
+        id: string;
+        tenantId: string;
+        updatedAt: string;
+    }[];
+}>;
+export type SessionsListParamsT = z.infer<typeof SessionsListParams>;
+export type SessionsListResultT = z.infer<typeof SessionsListResult>;
+export declare const SessionsForkParams: z.ZodObject<{
+    sessionId: z.ZodString;
+    atEventTs: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    sessionId: string;
+    atEventTs: number;
+}, {
+    sessionId: string;
+    atEventTs: number;
+}>;
+export declare const SessionsForkResult: z.ZodObject<{
+    newSessionId: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    newSessionId: string;
+}, {
+    newSessionId: string;
+}>;
+export type SessionsForkParamsT = z.infer<typeof SessionsForkParams>;
+export type SessionsForkResultT = z.infer<typeof SessionsForkResult>;
+export declare const AuditTailParams: z.ZodObject<{
+    tenantId: z.ZodString;
+    sinceTs: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    tenantId: string;
+    sinceTs?: number | undefined;
+}, {
+    tenantId: string;
+    sinceTs?: number | undefined;
+}>;
+export type AuditTailParamsT = z.infer<typeof AuditTailParams>;
+export declare const Method: z.ZodEnum<["runs.create", "runs.continue", "runs.cancel", "runs.subscribe", "sessions.list", "sessions.fork", "audit.tail"]>;
+export type MethodT = z.infer<typeof Method>;
+export declare function decodeRequest(raw: unknown): RequestEnvelopeT & {
+    method: MethodT;
+};
+export declare function encodeSuccess(id: string, result: unknown): ResponseEnvelopeT;
+export declare function encodeError(id: string, code: string, message: string, data?: unknown): ResponseEnvelopeT;
+export declare const ErrorCode: {
+    readonly Unauthorized: "unauthorized";
+    readonly Forbidden: "forbidden";
+    readonly NotFound: "not_found";
+    readonly BadRequest: "bad_request";
+    readonly BudgetExceeded: "budget_exceeded";
+    readonly InternalError: "internal_error";
+};
+export type ErrorCodeT = (typeof ErrorCode)[keyof typeof ErrorCode];

package/dist/index.js

@@ -0,0 +1,177 @@
+/**
+ * Catalog R16 `gateway-protocol` — wire contract for the managed-daemon
+ * gateway.
+ *
+ * Every request and response is wrapped in a versioned envelope so
+ * future protocol revisions can fan out on `protocol`. v1 carries:
+ *
+ *   { protocol: "crewhaus.v1", id: <opaque>, method: <string>, params: <obj> }
+ *
+ * All schemas are exported as Zod runtime validators; the inferred
+ * types are the canonical TS API. Reference clients (TS, Python) ship
+ * alongside this package — see `clients/` for snippets external app
+ * servers can paste into their own build.
+ *
+ * Methods (v1):
+ *   runs.create        — start a new run, return runId
+ *   runs.continue      — append a user turn to an existing session
+ *   runs.cancel        — abort an in-flight run
+ *   runs.subscribe     — SSE stream of trace events for a runId
+ *   sessions.list      — list per-tenant sessions
+ *   sessions.fork      — branch a session at a specific event
+ *   audit.tail         — stream the per-tenant audit log
+ *
+ * Layer R16. Pairs with `gateway-server` (R16 — Bun.serve daemon) and
+ * `target-managed` (F2 — codegen).
+ */
+import { CrewhausError } from "@crewhaus/errors";
+import { z } from "zod";
+export const PROTOCOL_VERSION = "crewhaus.v1";
+export class GatewayProtocolError extends CrewhausError {
+    name = "GatewayProtocolError";
+    constructor(message, cause) {
+        super("config", message, cause);
+    }
+}
+const protocolField = z.literal(PROTOCOL_VERSION);
+const requestEnvelope = z
+    .object({
+    protocol: protocolField,
+    id: z.string().min(1),
+    method: z.string().min(1),
+    params: z.unknown(),
+})
+    .strict();
+const successEnvelope = z
+    .object({
+    protocol: protocolField,
+    id: z.string().min(1),
+    result: z.unknown(),
+})
+    .strict();
+const errorEnvelope = z
+    .object({
+    protocol: protocolField,
+    id: z.string().min(1),
+    error: z
+        .object({
+        code: z.string().min(1),
+        message: z.string().min(1),
+        data: z.unknown().optional(),
+    })
+        .strict(),
+})
+    .strict();
+export const ResponseEnvelope = z.union([successEnvelope, errorEnvelope]);
+export const RequestEnvelope = requestEnvelope;
+// ---------------------------------------------------------------------------
+// Method-specific schemas.
+// ---------------------------------------------------------------------------
+export const RunsCreateParams = z
+    .object({
+    spec: z.string().min(1),
+    input: z.string(),
+    sessionId: z.string().min(1).optional(),
+})
+    .strict();
+export const RunsCreateResult = z
+    .object({
+    runId: z.string().min(1),
+    sessionId: z.string().min(1),
+    tenantId: z.string().min(1),
+})
+    .strict();
+export const RunsContinueParams = z
+    .object({
+    sessionId: z.string().min(1),
+    input: z.string(),
+})
+    .strict();
+export const RunsContinueResult = z
+    .object({
+    runId: z.string().min(1),
+    sessionId: z.string().min(1),
+    tenantId: z.string().min(1),
+})
+    .strict();
+export const RunsCancelParams = z.object({ runId: z.string().min(1) }).strict();
+export const RunsCancelResult = z.object({ ok: z.boolean() }).strict();
+export const RunsSubscribeParams = z.object({ runId: z.string().min(1) }).strict();
+export const SessionsListParams = z.object({}).strict();
+export const SessionsListResult = z
+    .object({
+    sessions: z.array(z
+        .object({
+        id: z.string().min(1),
+        tenantId: z.string().min(1),
+        updatedAt: z.string().min(1),
+    })
+        .strict()),
+})
+    .strict();
+export const SessionsForkParams = z
+    .object({ sessionId: z.string().min(1), atEventTs: z.number().int().nonnegative() })
+    .strict();
+export const SessionsForkResult = z.object({ newSessionId: z.string().min(1) }).strict();
+export const AuditTailParams = z
+    .object({ tenantId: z.string().min(1), sinceTs: z.number().int().nonnegative().optional() })
+    .strict();
+export const Method = z.enum([
+    "runs.create",
+    "runs.continue",
+    "runs.cancel",
+    "runs.subscribe",
+    "sessions.list",
+    "sessions.fork",
+    "audit.tail",
+]);
+const PARAM_SCHEMAS = {
+    "runs.create": RunsCreateParams,
+    "runs.continue": RunsContinueParams,
+    "runs.cancel": RunsCancelParams,
+    "runs.subscribe": RunsSubscribeParams,
+    "sessions.list": SessionsListParams,
+    "sessions.fork": SessionsForkParams,
+    "audit.tail": AuditTailParams,
+};
+export function decodeRequest(raw) {
+    const parsed = RequestEnvelope.safeParse(raw);
+    if (!parsed.success) {
+        throw new GatewayProtocolError(`invalid envelope: ${parsed.error.issues
+            .map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`)
+            .join("; ")}`);
+    }
+    const m = Method.safeParse(parsed.data.method);
+    if (!m.success) {
+        throw new GatewayProtocolError(`unknown method "${parsed.data.method}"`);
+    }
+    const paramSchema = PARAM_SCHEMAS[m.data];
+    const params = paramSchema.safeParse(parsed.data.params);
+    if (!params.success) {
+        throw new GatewayProtocolError(`invalid params for ${m.data}: ${params.error.issues
+            .map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`)
+            .join("; ")}`);
+    }
+    return { ...parsed.data, method: m.data, params: params.data };
+}
+export function encodeSuccess(id, result) {
+    return { protocol: PROTOCOL_VERSION, id, result };
+}
+export function encodeError(id, code, message, data) {
+    return {
+        protocol: PROTOCOL_VERSION,
+        id,
+        error: { code, message, ...(data !== undefined ? { data } : {}) },
+    };
+}
+// ---------------------------------------------------------------------------
+// Standard error codes — wire-stable so reference clients can switch on them.
+// ---------------------------------------------------------------------------
+export const ErrorCode = {
+    Unauthorized: "unauthorized",
+    Forbidden: "forbidden",
+    NotFound: "not_found",
+    BadRequest: "bad_request",
+    BudgetExceeded: "budget_exceeded",
+    InternalError: "internal_error",
+};

package/package.json

@@ -1,18 +1,21 @@
 {
   "name": "@crewhaus/gateway-protocol",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "type": "module",
   "description": "JSON-RPC wire protocol for the managed-daemon gateway — versioned envelope + Zod schemas",
-  "main": "src/index.ts",
-  "types": "src/index.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "exports": {
-    ".": "./src/index.ts"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
   },
   "scripts": {
     "test": "bun test src"
   },
   "dependencies": {
-    "@crewhaus/errors": "0.1.4",
+    "@crewhaus/errors": "0.1.6",
     "zod": "^3.23.8"
   },
   "license": "Apache-2.0",
@@ -33,5 +36,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "files": ["src", "README.md", "LICENSE", "NOTICE"]
+  "files": ["dist", "README.md", "LICENSE", "NOTICE"]
 }

package/src/index.test.ts

@@ -1,259 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-  ErrorCode,
-  GatewayProtocolError,
-  Method,
-  PROTOCOL_VERSION,
-  RequestEnvelope,
-  ResponseEnvelope,
-  decodeRequest,
-  encodeError,
-  encodeSuccess,
-} from "./index";
-
-describe("envelope", () => {
-  test("PROTOCOL_VERSION is the v1 string", () => {
-    expect(PROTOCOL_VERSION).toBe("crewhaus.v1");
-  });
-
-  test("decodeRequest accepts a well-formed runs.create", () => {
-    const raw = {
-      protocol: "crewhaus.v1",
-      id: "abc",
-      method: "runs.create",
-      params: { spec: "x", input: "hi" },
-    };
-    const r = decodeRequest(raw);
-    expect(r.method).toBe("runs.create");
-    expect((r.params as { spec: string }).spec).toBe("x");
-  });
-
-  test("rejects wrong protocol version", () => {
-    const raw = {
-      protocol: "crewhaus.v0",
-      id: "abc",
-      method: "runs.create",
-      params: { spec: "x", input: "" },
-    };
-    expect(() => decodeRequest(raw)).toThrow(GatewayProtocolError);
-  });
-
-  test("rejects unknown method", () => {
-    const raw = {
-      protocol: "crewhaus.v1",
-      id: "abc",
-      method: "runs.nuke",
-      params: {},
-    };
-    expect(() => decodeRequest(raw)).toThrow(/unknown method "runs.nuke"/);
-  });
-
-  test("rejects invalid params for known method", () => {
-    const raw = {
-      protocol: "crewhaus.v1",
-      id: "abc",
-      method: "runs.create",
-      params: { spec: 1 }, // wrong type
-    };
-    expect(() => decodeRequest(raw)).toThrow(/invalid params/);
-  });
-
-  test("rejects extra unknown fields on the envelope (.strict)", () => {
-    const raw = {
-      protocol: "crewhaus.v1",
-      id: "abc",
-      method: "runs.create",
-      params: { spec: "x", input: "" },
-      foo: "bar",
-    };
-    expect(() => decodeRequest(raw)).toThrow(GatewayProtocolError);
-  });
-});
-
-describe("response encoders", () => {
-  test("encodeSuccess shape", () => {
-    const r = encodeSuccess("id-1", { ok: true });
-    expect(r).toEqual({ protocol: "crewhaus.v1", id: "id-1", result: { ok: true } });
-  });
-
-  test("encodeError shape with no data", () => {
-    const r = encodeError("id-1", ErrorCode.NotFound, "missing");
-    expect(r).toEqual({
-      protocol: "crewhaus.v1",
-      id: "id-1",
-      error: { code: "not_found", message: "missing" },
-    });
-  });
-
-  test("encodeError shape with data", () => {
-    const r = encodeError("id-1", ErrorCode.BadRequest, "bad", { field: "x" });
-    expect(r).toEqual({
-      protocol: "crewhaus.v1",
-      id: "id-1",
-      error: { code: "bad_request", message: "bad", data: { field: "x" } },
-    });
-  });
-});
-
-describe("standard error codes are wire-stable", () => {
-  test("expected codes exist", () => {
-    expect(ErrorCode.Unauthorized).toBe("unauthorized");
-    expect(ErrorCode.Forbidden).toBe("forbidden");
-    expect(ErrorCode.NotFound).toBe("not_found");
-    expect(ErrorCode.BadRequest).toBe("bad_request");
-    expect(ErrorCode.BudgetExceeded).toBe("budget_exceeded");
-    expect(ErrorCode.InternalError).toBe("internal_error");
-  });
-});
-
-describe("error-message path formatting", () => {
-  // The issue-formatter uses `i.path.join(".") || "<root>"`. A top-level
-  // failure (raw is not an object at all) yields an empty Zod path, which
-  // must surface as "<root>" rather than an empty string.
-  test("envelope failure on a non-object surfaces <root>", () => {
-    expect(() => decodeRequest("not-an-object")).toThrow(/<root>: /);
-  });
-
-  test("param failure on a non-object surfaces <root>", () => {
-    const raw = {
-      protocol: "crewhaus.v1",
-      id: "abc",
-      method: "runs.cancel",
-      params: null,
-    };
-    expect(() => decodeRequest(raw)).toThrow(/invalid params for runs.cancel: <root>: /);
-  });
-
-  test("named-field failure surfaces the field path, not <root>", () => {
-    const raw = {
-      protocol: "crewhaus.v1",
-      id: "abc",
-      method: "runs.create",
-      params: { spec: 1, input: "hi" },
-    };
-    // `spec` is the offending path; it must appear and <root> must not.
-    expect(() => decodeRequest(raw)).toThrow(/spec: /);
-    try {
-      decodeRequest(raw);
-    } catch (e) {
-      expect((e as Error).message).not.toContain("<root>");
-    }
-  });
-});
-
-describe("decodeRequest accepts every declared method", () => {
-  const cases: Array<[string, unknown]> = [
-    ["runs.create", { spec: "s", input: "" }],
-    ["runs.continue", { sessionId: "sess", input: "more" }],
-    ["runs.cancel", { runId: "r1" }],
-    ["runs.subscribe", { runId: "r1" }],
-    ["sessions.list", {}],
-    ["sessions.fork", { sessionId: "sess", atEventTs: 0 }],
-    ["audit.tail", { tenantId: "t1" }],
-  ];
-  for (const [method, params] of cases) {
-    test(`decodes ${method}`, () => {
-      const r = decodeRequest({ protocol: "crewhaus.v1", id: "id", method, params });
-      expect(r.method).toBe(method as (typeof r)["method"]);
-      expect(r.protocol).toBe("crewhaus.v1");
-      expect(r.params).toEqual(params);
-    });
-  }
-
-  test("Method enum lists exactly the routed methods", () => {
-    expect([...Method.options].sort()).toEqual(
-      [...cases.map(([m]) => m as (typeof Method.options)[number])].sort(),
-    );
-  });
-});
-
-describe("envelope id/method minimums", () => {
-  test("rejects empty id", () => {
-    const raw = {
-      protocol: "crewhaus.v1",
-      id: "",
-      method: "runs.create",
-      params: { spec: "x", input: "" },
-    };
-    expect(() => decodeRequest(raw)).toThrow(GatewayProtocolError);
-  });
-
-  test("rejects empty method", () => {
-    const raw = { protocol: "crewhaus.v1", id: "abc", method: "", params: {} };
-    expect(() => decodeRequest(raw)).toThrow(GatewayProtocolError);
-  });
-
-  test("optional sessionId is accepted on runs.create", () => {
-    const r = decodeRequest({
-      protocol: "crewhaus.v1",
-      id: "abc",
-      method: "runs.create",
-      params: { spec: "x", input: "hi", sessionId: "sess" },
-    });
-    expect((r.params as { sessionId?: string }).sessionId).toBe("sess");
-  });
-});
-
-describe("encoder ↔ schema round-trips", () => {
-  test("encodeSuccess output validates against ResponseEnvelope", () => {
-    expect(ResponseEnvelope.safeParse(encodeSuccess("i", { ok: true })).success).toBe(true);
-  });
-
-  test("encodeError output validates against ResponseEnvelope (no data)", () => {
-    expect(ResponseEnvelope.safeParse(encodeError("i", "not_found", "missing")).success).toBe(true);
-  });
-
-  test("encodeError output validates against ResponseEnvelope (with data)", () => {
-    const parsed = ResponseEnvelope.safeParse(encodeError("i", "bad_request", "bad", { f: 1 }));
-    expect(parsed.success).toBe(true);
-  });
-
-  // Distinct from the no-arg call: passing `data: undefined` explicitly must
-  // still omit the key (the `data !== undefined` guard), keeping the wire
-  // form identical to the success/no-data shape.
-  test("encodeError with explicit undefined data omits the data key", () => {
-    const r = encodeError("id-1", ErrorCode.InternalError, "boom", undefined);
-    expect(r).toEqual({
-      protocol: "crewhaus.v1",
-      id: "id-1",
-      error: { code: "internal_error", message: "boom" },
-    });
-    expect("data" in (r as { error: Record<string, unknown> }).error).toBe(false);
-  });
-
-  test("encodeError preserves a falsy-but-defined data value", () => {
-    const r = encodeError("id-1", ErrorCode.BadRequest, "bad", null);
-    expect((r as { error: { data?: unknown } }).error.data).toBeNull();
-    expect("data" in (r as { error: Record<string, unknown> }).error).toBe(true);
-  });
-});
-
-describe("RequestEnvelope is the exported request schema", () => {
-  test("validates a well-formed envelope shape directly", () => {
-    const parsed = RequestEnvelope.safeParse({
-      protocol: "crewhaus.v1",
-      id: "abc",
-      method: "anything.goes",
-      params: 42,
-    });
-    expect(parsed.success).toBe(true);
-  });
-});
-
-describe("GatewayProtocolError", () => {
-  test("carries the config code and preserves its cause", () => {
-    const cause = new Error("underlying");
-    const err = new GatewayProtocolError("nope", cause);
-    expect(err).toBeInstanceOf(GatewayProtocolError);
-    expect(err.name).toBe("GatewayProtocolError");
-    expect(err.code).toBe("config");
-    expect(err.message).toBe("nope");
-    expect(err.cause).toBe(cause);
-  });
-
-  test("is constructible without a cause", () => {
-    const err = new GatewayProtocolError("solo");
-    expect(err.cause).toBeUndefined();
-    expect(err.code).toBe("config");
-  });
-});

package/src/index.ts

@@ -1,228 +0,0 @@
-/**
- * Catalog R16 `gateway-protocol` — wire contract for the managed-daemon
- * gateway.
- *
- * Every request and response is wrapped in a versioned envelope so
- * future protocol revisions can fan out on `protocol`. v1 carries:
- *
- *   { protocol: "crewhaus.v1", id: <opaque>, method: <string>, params: <obj> }
- *
- * All schemas are exported as Zod runtime validators; the inferred
- * types are the canonical TS API. Reference clients (TS, Python) ship
- * alongside this package — see `clients/` for snippets external app
- * servers can paste into their own build.
- *
- * Methods (v1):
- *   runs.create        — start a new run, return runId
- *   runs.continue      — append a user turn to an existing session
- *   runs.cancel        — abort an in-flight run
- *   runs.subscribe     — SSE stream of trace events for a runId
- *   sessions.list      — list per-tenant sessions
- *   sessions.fork      — branch a session at a specific event
- *   audit.tail         — stream the per-tenant audit log
- *
- * Layer R16. Pairs with `gateway-server` (R16 — Bun.serve daemon) and
- * `target-managed` (F2 — codegen).
- */
-
-import { CrewhausError } from "@crewhaus/errors";
-import { z } from "zod";
-
-export const PROTOCOL_VERSION = "crewhaus.v1" as const;
-
-export class GatewayProtocolError extends CrewhausError {
-  override readonly name = "GatewayProtocolError";
-  constructor(message: string, cause?: unknown) {
-    super("config", message, cause);
-  }
-}
-
-const protocolField = z.literal(PROTOCOL_VERSION);
-
-const requestEnvelope = z
-  .object({
-    protocol: protocolField,
-    id: z.string().min(1),
-    method: z.string().min(1),
-    params: z.unknown(),
-  })
-  .strict();
-
-const successEnvelope = z
-  .object({
-    protocol: protocolField,
-    id: z.string().min(1),
-    result: z.unknown(),
-  })
-  .strict();
-
-const errorEnvelope = z
-  .object({
-    protocol: protocolField,
-    id: z.string().min(1),
-    error: z
-      .object({
-        code: z.string().min(1),
-        message: z.string().min(1),
-        data: z.unknown().optional(),
-      })
-      .strict(),
-  })
-  .strict();
-
-export const ResponseEnvelope = z.union([successEnvelope, errorEnvelope]);
-export const RequestEnvelope = requestEnvelope;
-export type RequestEnvelopeT = z.infer<typeof RequestEnvelope>;
-export type ResponseEnvelopeT = z.infer<typeof ResponseEnvelope>;
-
-// ---------------------------------------------------------------------------
-// Method-specific schemas.
-// ---------------------------------------------------------------------------
-
-export const RunsCreateParams = z
-  .object({
-    spec: z.string().min(1),
-    input: z.string(),
-    sessionId: z.string().min(1).optional(),
-  })
-  .strict();
-export const RunsCreateResult = z
-  .object({
-    runId: z.string().min(1),
-    sessionId: z.string().min(1),
-    tenantId: z.string().min(1),
-  })
-  .strict();
-export type RunsCreateParamsT = z.infer<typeof RunsCreateParams>;
-export type RunsCreateResultT = z.infer<typeof RunsCreateResult>;
-
-export const RunsContinueParams = z
-  .object({
-    sessionId: z.string().min(1),
-    input: z.string(),
-  })
-  .strict();
-export const RunsContinueResult = z
-  .object({
-    runId: z.string().min(1),
-    sessionId: z.string().min(1),
-    tenantId: z.string().min(1),
-  })
-  .strict();
-export type RunsContinueParamsT = z.infer<typeof RunsContinueParams>;
-export type RunsContinueResultT = z.infer<typeof RunsContinueResult>;
-
-export const RunsCancelParams = z.object({ runId: z.string().min(1) }).strict();
-export const RunsCancelResult = z.object({ ok: z.boolean() }).strict();
-export type RunsCancelParamsT = z.infer<typeof RunsCancelParams>;
-export type RunsCancelResultT = z.infer<typeof RunsCancelResult>;
-
-export const RunsSubscribeParams = z.object({ runId: z.string().min(1) }).strict();
-export type RunsSubscribeParamsT = z.infer<typeof RunsSubscribeParams>;
-
-export const SessionsListParams = z.object({}).strict();
-export const SessionsListResult = z
-  .object({
-    sessions: z.array(
-      z
-        .object({
-          id: z.string().min(1),
-          tenantId: z.string().min(1),
-          updatedAt: z.string().min(1),
-        })
-        .strict(),
-    ),
-  })
-  .strict();
-export type SessionsListParamsT = z.infer<typeof SessionsListParams>;
-export type SessionsListResultT = z.infer<typeof SessionsListResult>;
-
-export const SessionsForkParams = z
-  .object({ sessionId: z.string().min(1), atEventTs: z.number().int().nonnegative() })
-  .strict();
-export const SessionsForkResult = z.object({ newSessionId: z.string().min(1) }).strict();
-export type SessionsForkParamsT = z.infer<typeof SessionsForkParams>;
-export type SessionsForkResultT = z.infer<typeof SessionsForkResult>;
-
-export const AuditTailParams = z
-  .object({ tenantId: z.string().min(1), sinceTs: z.number().int().nonnegative().optional() })
-  .strict();
-export type AuditTailParamsT = z.infer<typeof AuditTailParams>;
-
-export const Method = z.enum([
-  "runs.create",
-  "runs.continue",
-  "runs.cancel",
-  "runs.subscribe",
-  "sessions.list",
-  "sessions.fork",
-  "audit.tail",
-]);
-export type MethodT = z.infer<typeof Method>;
-
-const PARAM_SCHEMAS: Record<MethodT, z.ZodType<unknown>> = {
-  "runs.create": RunsCreateParams,
-  "runs.continue": RunsContinueParams,
-  "runs.cancel": RunsCancelParams,
-  "runs.subscribe": RunsSubscribeParams,
-  "sessions.list": SessionsListParams,
-  "sessions.fork": SessionsForkParams,
-  "audit.tail": AuditTailParams,
-};
-
-export function decodeRequest(raw: unknown): RequestEnvelopeT & { method: MethodT } {
-  const parsed = RequestEnvelope.safeParse(raw);
-  if (!parsed.success) {
-    throw new GatewayProtocolError(
-      `invalid envelope: ${parsed.error.issues
-        .map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`)
-        .join("; ")}`,
-    );
-  }
-  const m = Method.safeParse(parsed.data.method);
-  if (!m.success) {
-    throw new GatewayProtocolError(`unknown method "${parsed.data.method}"`);
-  }
-  const paramSchema = PARAM_SCHEMAS[m.data];
-  const params = paramSchema.safeParse(parsed.data.params);
-  if (!params.success) {
-    throw new GatewayProtocolError(
-      `invalid params for ${m.data}: ${params.error.issues
-        .map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`)
-        .join("; ")}`,
-    );
-  }
-  return { ...parsed.data, method: m.data, params: params.data };
-}
-
-export function encodeSuccess(id: string, result: unknown): ResponseEnvelopeT {
-  return { protocol: PROTOCOL_VERSION, id, result };
-}
-
-export function encodeError(
-  id: string,
-  code: string,
-  message: string,
-  data?: unknown,
-): ResponseEnvelopeT {
-  return {
-    protocol: PROTOCOL_VERSION,
-    id,
-    error: { code, message, ...(data !== undefined ? { data } : {}) },
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Standard error codes — wire-stable so reference clients can switch on them.
-// ---------------------------------------------------------------------------
-
-export const ErrorCode = {
-  Unauthorized: "unauthorized",
-  Forbidden: "forbidden",
-  NotFound: "not_found",
-  BadRequest: "bad_request",
-  BudgetExceeded: "budget_exceeded",
-  InternalError: "internal_error",
-} as const;
-
-export type ErrorCodeT = (typeof ErrorCode)[keyof typeof ErrorCode];