@loopbacktools/protocol 0.0.0-stage → 0.4.0

package/dist/src/generated/schemas.r1.gen.js

@@ -0,0 +1,58 @@
+// GENERATED by scripts/schemas.ts from openapi/openapi.1.json. DO NOT EDIT.
+// Regenerate with: pnpm generate
+import * as Schema from "effect/Schema";
+import { unknownAsk, unknownBlock, unknownEvent, unknownReply, } from "../unknown.js";
+export const Actor = Schema.Struct({ "id": Schema.String.annotate({ "description": "Stable within the deployment, as its gate names them." }), "name": Schema.optionalKey(Schema.String.annotate({ "description": "How to show them, when the gate knows." })) }).annotate({ "description": "Someone a deployment's gate recognised: a person, or the agent they authorised.", "identifier": "Actor" });
+export const MarkdownBlock = Schema.Struct({ "type": Schema.Literal("markdown"), "text": Schema.String.check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })) }).annotate({ "description": "Prose, copy or a plan, as GitHub-flavoured markdown.", "identifier": "MarkdownBlock" });
+export const CodeBlock = Schema.Struct({ "type": Schema.Literal("code"), "code": Schema.String.check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })), "language": Schema.optionalKey(Schema.String.annotate({ "description": "A language name the highlighter knows, such as `ts` or `python`." })), "filename": Schema.optionalKey(Schema.String) }).annotate({ "description": "Source code, shown highlighted.", "identifier": "CodeBlock" });
+export const DiffBlock = Schema.Struct({ "type": Schema.Literal("diff"), "diff": Schema.String.check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })), "filename": Schema.optionalKey(Schema.String) }).annotate({ "description": "A unified diff, as `git diff` prints it.", "identifier": "DiffBlock" });
+export const ImageBlock = Schema.Struct({ "type": Schema.Literal("image"), "uploadId": Schema.String.check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })), "caption": Schema.optionalKey(Schema.String) }).annotate({ "description": "An image uploaded beforehand through an upload ticket.", "identifier": "ImageBlock" });
+export const Answered = Schema.Struct({ "outcome": Schema.Literal("answered"), "selected": Schema.Array(Schema.String), "text": Schema.optionalKey(Schema.String) }).annotate({ "description": "An answer to a question: the choices picked, words of their own, or both.", "identifier": "Answered" });
+export const Approved = Schema.Struct({ "outcome": Schema.Literal("approved"), "note": Schema.optionalKey(Schema.String) }).annotate({ "description": "A review approved, with an optional note.", "identifier": "Approved" });
+export const Choice = Schema.Struct({ "label": Schema.String.check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(80).annotate({ "expected": "a string with at most 80 code points" })), "description": Schema.optionalKey(Schema.String) }).annotate({ "description": "A choice offered with a question.", "identifier": "Choice" });
+export const AskStatus = Schema.Literals(["awaiting_human", "awaiting_agent", "closed"]).annotate({ "description": "Where an ask stands. While it is open, it is either the person's move or the agent's.", "identifier": "AskStatus" });
+export const ChangesRequested = Schema.Struct({ "outcome": Schema.Literal("changes_requested"), "feedback": Schema.String.check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })) }).annotate({ "description": "A review sent back with feedback.", "identifier": "ChangesRequested" });
+export const FollowUp = Schema.Struct({ "outcome": Schema.Literal("follow_up"), "question": Schema.String.check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })) }).annotate({ "description": "A question asked back before deciding. The ask stays open until the agent answers.", "identifier": "FollowUp" });
+export const Dismissed = Schema.Struct({ "outcome": Schema.Literal("dismissed") }).annotate({ "description": "Declined without an answer.", "identifier": "Dismissed" });
+export const PointReply = Schema.Struct({ "point": Schema.String.check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })), "text": Schema.optionalKey(Schema.String.annotate({ "description": "What they said: a question, a push-back or a comment." })), "resolved": Schema.optionalKey(Schema.Boolean.annotate({ "description": "Whether they are done with the point, and everything beneath it." })) }).annotate({ "description": "The person on one point of a briefing: words, resolved, or both.", "identifier": "PointReply" });
+export const AskKind = Schema.Literals(["question", "review", "briefing"]).annotate({ "description": "What an agent is asking for: an answer to a question, a verdict on something it produced, or the\nperson's word on each point of something it explained.", "identifier": "AskKind" });
+export const EventTicket = Schema.Struct({ "ticket": Schema.String, "expiresAt": Schema.String.annotate({ "format": "date-time" }) }).annotate({ "description": "A one-time pass onto the event socket, for a client that cannot send headers there, as a browser\ncannot. Offer it as the subprotocol `loopback.ticket.<ticket>` alongside `loopback.v1`. It works\nonce, within a minute, so a copy that turns up in a log is of no use to anyone.", "identifier": "EventTicket" });
+export const ImageType = Schema.Literals(["image/png", "image/jpeg", "image/webp", "image/gif"]).annotate({ "description": "Image formats an agent may upload for a review.", "identifier": "ImageType" });
+export const InboxLink = Schema.Struct({ "url": Schema.String }).annotate({ "description": "Where the person reads and answers everything agents ask.", "identifier": "InboxLink" });
+export const InboxRequest = Schema.Struct({ "askId": Schema.optionalKey(Schema.String.annotate({ "description": "An ask to open directly. Leave it out for the inbox itself." })) }).annotate({ "description": "A request for the address of the person's inbox.", "identifier": "InboxRequest" });
+export const Problem = Schema.Struct({ "code": Schema.String.annotate({ "description": "A stable, machine-readable reason, such as `ask.closed`." }), "message": Schema.String }).annotate({ "description": "Why a request was refused.", "identifier": "Problem" });
+export const Revisions = Schema.Literal("1").annotate({ "description": "The contract's revisions, oldest first. Change the shape of any message and declare it here as a\nnew revision, marking what changed with `@added`, `@removed`, `@renamedFrom` or `@typeChangedFrom`:\nevery part of a deployment names the revision it writes, and newer code upgrades older messages.\nNever edit a revision that has shipped; `revisions/` holds each one frozen, and a test fails when\nthe contract no longer emits it unchanged. See docs/design/versioned-messages.md.", "identifier": "Revisions" });
+export const UploadTicket = Schema.Struct({ "uploadId": Schema.String, "uploadUrl": Schema.String.annotate({ "description": "Send the image here with `PUT` and its `Content-Type`. No credentials needed." }), "expiresAt": Schema.String.annotate({ "format": "date-time" }), "maxBytes": Schema.Number.annotate({ "format": "int32" }).check(Schema.isInt().annotate({ "expected": "an integer" })), "command": Schema.String.annotate({ "description": "A ready-to-run command that performs the upload; replace `FILE` with the image's path." }) }).annotate({ "description": "Where to upload an image, once, before it expires.", "identifier": "UploadTicket" });
+export const Whoami = Schema.Struct({ "space": Schema.String, "actor": Actor }).annotate({ "description": "Who the caller is.", "identifier": "Whoami" });
+export const Block = Schema.Union([MarkdownBlock, CodeBlock, DiffBlock, ImageBlock, unknownBlock]).annotate({ "description": "One piece of what is shown to the person.", "identifier": "Block" });
+export const QuestionPrompt = Schema.Struct({ "question": Schema.String, "options": Schema.Array(Choice), "multiple": Schema.Boolean, "context": Schema.optionalKey(Schema.String) }).annotate({ "description": "A question as it is shown to the person.", "identifier": "QuestionPrompt" });
+export const QuestionInput = Schema.Struct({ "question": Schema.String.annotate({ "description": "The question, as markdown." }).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })), "options": Schema.optionalKey(Schema.Array(Choice).annotate({ "description": "Between two and six choices, offered as buttons." }).check(Schema.isMinLength(2).annotate({ "expected": "a value with a length of at least 2" })).check(Schema.isMaxLength(6).annotate({ "expected": "a value with a length of at most 6" }))), "multiple": Schema.optionalKey(Schema.Boolean.annotate({ "description": "Whether the person may pick more than one choice." })), "context": Schema.optionalKey(Schema.String.annotate({ "description": "Background the person needs to answer, as markdown." })), "project": Schema.String.annotate({ "description": "The project you are working in: the name of the folder at the root of its repository (the\nlast part of `git rev-parse --show-toplevel`), or of the working directory outside one. The\nperson works on many projects at once from one inbox; this is how they know who is asking." }).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })) }).annotate({ "description": "A question for the person, with optional choices. They may always answer in their own words. All\nof it together may be at most 256 KiB.", "identifier": "QuestionInput" });
+export const Responded = Schema.Struct({ "outcome": Schema.Literal("responded"), "points": Schema.Array(PointReply).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })) }).annotate({ "description": "Replies on the points of a briefing. The agent answers every point written on and left unresolved;\nthe briefing closes once every point is resolved.", "identifier": "Responded" });
+export const UploadReceipt = Schema.Struct({ "uploadId": Schema.String, "contentType": ImageType, "size": Schema.Number.annotate({ "format": "int32" }).check(Schema.isInt().annotate({ "expected": "an integer" })) }).annotate({ "description": "A stored upload.", "identifier": "UploadReceipt" });
+export const UploadRequest = Schema.Struct({ "contentType": ImageType }).annotate({ "description": "A request for somewhere to upload an image.", "identifier": "UploadRequest" });
+export const Point = Schema.Struct({ "id": Schema.String.annotate({ "description": "`3` for the third point of the briefing, `3.1` for the first beneath it." }), "title": Schema.String.annotate({ "description": "The point in one line, shown while it is folded." }).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(200).annotate({ "expected": "a string with at most 200 code points" })), "detail": Schema.optionalKey(Schema.String.annotate({ "description": "The point explained, as markdown, shown when the person opens it." })), "content": Schema.optionalKey(Schema.Array(Block).annotate({ "description": "Anything to look at with it: code, a diff or an image." })) }).annotate({ "description": "A point of a briefing as it is shown, with the id replies name it by.", "identifier": "Point" });
+export const ReviewPrompt = Schema.Struct({ "title": Schema.String, "content": Schema.Array(Block), "summary": Schema.optionalKey(Schema.String) }).annotate({ "description": "A review as it is shown to the person.", "identifier": "ReviewPrompt" });
+export const BriefingPoint = Schema.Struct({ "title": Schema.String.annotate({ "description": "The point in one line, shown while it is folded." }).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(200).annotate({ "expected": "a string with at most 200 code points" })), "detail": Schema.optionalKey(Schema.String.annotate({ "description": "The point explained, as markdown, shown when the person opens it." })), "content": Schema.optionalKey(Schema.Array(Block).annotate({ "description": "Anything to look at with it: code, a diff or an image." })) }).annotate({ "description": "One point of a briefing: a line the person sees folded, and what opens beneath it.", "identifier": "BriefingPoint" });
+export const FollowUpInput = Schema.Struct({ "askId": Schema.String.check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })), "answer": Schema.String.annotate({ "description": "The answer, as markdown." }).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })), "content": Schema.optionalKey(Schema.Array(Block).annotate({ "description": "Anything new to look at alongside the answer." })) }).annotate({ "description": "The agent's answer to a question the person asked back, with its content at most 256 KiB.", "identifier": "FollowUpInput" });
+export const ReviewInput = Schema.Struct({ "title": Schema.String.check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(200).annotate({ "expected": "a string with at most 200 code points" })), "content": Schema.Array(Block).annotate({ "description": "What is being reviewed, in order." }).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })), "summary": Schema.optionalKey(Schema.String.annotate({ "description": "What changed, or what to look at." })), "revises": Schema.optionalKey(Schema.String.annotate({ "description": "The id of the review this one revises, after changes were requested." })), "project": Schema.String.annotate({ "description": "The project you are working in: the name of the folder at the root of its repository (the\nlast part of `git rev-parse --show-toplevel`), or of the working directory outside one. The\nperson works on many projects at once from one inbox; this is how they know who is asking." }).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })) }).annotate({ "description": "Work put in front of the person for approval or feedback. All of it together may be at most\n256 KiB: show the part that matters, or split it into several reviews.", "identifier": "ReviewInput" });
+export const Reply = Schema.Union([Answered, Approved, ChangesRequested, FollowUp, Dismissed, Responded, unknownReply]).annotate({ "description": "What a person replies. A `follow_up` hands the move to the agent; so does a `responded` that\nleaves any point unresolved. Every other reply closes the ask.", "identifier": "Reply" });
+export const AgentEntry = Schema.Struct({ "author": Schema.Literal("agent"), "answer": Schema.String, "content": Schema.optionalKey(Schema.Array(Block)), "point": Schema.optionalKey(Schema.String.annotate({ "description": "The briefing point this answers." })), "points": Schema.optionalKey(Schema.Array(Point).annotate({ "description": "Sub-points the answer broke the point into, with their ids." })), "at": Schema.String.annotate({ "format": "date-time" }) }).annotate({ "description": "An answer the agent gave: to a question asked back, or on one point of a briefing.", "identifier": "AgentEntry" });
+export const BriefingPromptSection = Schema.Struct({ "title": Schema.optionalKey(Schema.String), "points": Schema.Array(Point) }).annotate({ "description": "A list of a briefing's points as it is shown.", "identifier": "BriefingPromptSection" });
+export const PointAnswer = Schema.Struct({ "point": Schema.String.annotate({ "description": "The point's id, such as `3` or `3.1`." }).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })), "answer": Schema.String.annotate({ "description": "The answer, as markdown." }).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })), "content": Schema.optionalKey(Schema.Array(Block).annotate({ "description": "Anything new to look at alongside the answer." })), "points": Schema.optionalKey(Schema.Array(BriefingPoint).annotate({ "description": "Sub-points this point breaks into, numbered beneath it (`3.1`, `3.2`, …), each of which the\nperson can reply on in turn. Points go at most three levels deep." })) }).annotate({ "description": "Your answer on one point of a briefing.", "identifier": "PointAnswer" });
+export const BriefingSection = Schema.Struct({ "title": Schema.optionalKey(Schema.String), "points": Schema.Array(BriefingPoint).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })) }).annotate({ "description": "A list of points under an optional heading.", "identifier": "BriefingSection" });
+export const HumanEntry = Schema.Struct({ "author": Schema.Literal("human"), "reply": Reply, "by": Schema.optionalKey(Schema.suspend(() => Actor).annotate({ "description": "Who replied, when the deployment knows." })), "at": Schema.String.annotate({ "format": "date-time" }) }).annotate({ "description": "A reply the person gave.", "identifier": "HumanEntry" });
+export const ToolReply = Schema.Struct({ "askId": Schema.String, "reply": Reply }).annotate({ "description": "What a blocking MCP tool returns: the reply that ended its wait.", "identifier": "ToolReply" });
+export const BriefingPrompt = Schema.Struct({ "title": Schema.String, "summary": Schema.optionalKey(Schema.String), "sections": Schema.Array(BriefingPromptSection) }).annotate({ "description": "A briefing as it is shown to the person, before any sub-points the agent adds while answering.", "identifier": "BriefingPrompt" });
+export const BriefingAnswerInput = Schema.Struct({ "askId": Schema.String.check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })), "answers": Schema.Array(PointAnswer).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })) }).annotate({ "description": "Your answers on a briefing, one per point: every point the person wrote on without resolving it,\nand any other open point you have more to say on. All of it together may be at most 256 KiB.", "identifier": "BriefingAnswerInput" });
+export const BriefingInput = Schema.Struct({ "title": Schema.String.check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(200).annotate({ "expected": "a string with at most 200 code points" })), "summary": Schema.optionalKey(Schema.String.annotate({ "description": "What this explains, and why, as markdown." })), "sections": Schema.Array(BriefingSection).annotate({ "description": "The points, in lists under optional headings." }).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })), "project": Schema.String.annotate({ "description": "The project you are working in: the name of the folder at the root of its repository (the\nlast part of `git rev-parse --show-toplevel`), or of the working directory outside one. The\nperson works on many projects at once from one inbox; this is how they know who is asking." }).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })) }).annotate({ "description": "Something explained as points the person can reply on one at a time: findings, options, steps, a\nlist of changes. They may write on any point, or mark it resolved, and you answer on each point\nthey wrote on until every point is resolved. Points are numbered for you, straight through every\nsection: at most fifty. All of it together may be at most 256 KiB.", "identifier": "BriefingInput" });
+export const Entry = Schema.Union([HumanEntry, AgentEntry]).annotate({ "description": "One turn in an ask's thread after it was opened.", "identifier": "Entry" });
+export const QuestionAsk = Schema.Struct({ "kind": Schema.Literal("question"), "prompt": QuestionPrompt, "id": Schema.String, "status": AskStatus, "waiting": Schema.Boolean.annotate({ "description": "Whether an agent is following this ask right now: waiting on its call, or polling it as a background task." }), "project": Schema.optionalKey(Schema.String), "client": Schema.optionalKey(Schema.String.annotate({ "description": "The MCP client that asked, such as `claude-code 2.1.0`." })), "raisedBy": Schema.optionalKey(Schema.suspend(() => Actor).annotate({ "description": "Whose agent asked: the person its credential belongs to, when the deployment knows." })), "thread": Schema.Array(Entry).annotate({ "description": "Every turn after the ask was opened, oldest first." }), "createdAt": Schema.String.annotate({ "format": "date-time" }), "updatedAt": Schema.String.annotate({ "format": "date-time" }), "closedAt": Schema.optionalKey(Schema.String.annotate({ "format": "date-time" })) }).annotate({ "description": "A question an agent asked.", "identifier": "QuestionAsk" });
+export const ReviewAsk = Schema.Struct({ "kind": Schema.Literal("review"), "prompt": ReviewPrompt, "revises": Schema.optionalKey(Schema.String.annotate({ "description": "The id of the review this one revises." })), "id": Schema.String, "status": AskStatus, "waiting": Schema.Boolean.annotate({ "description": "Whether an agent is following this ask right now: waiting on its call, or polling it as a background task." }), "project": Schema.optionalKey(Schema.String), "client": Schema.optionalKey(Schema.String.annotate({ "description": "The MCP client that asked, such as `claude-code 2.1.0`." })), "raisedBy": Schema.optionalKey(Schema.suspend(() => Actor).annotate({ "description": "Whose agent asked: the person its credential belongs to, when the deployment knows." })), "thread": Schema.Array(Entry).annotate({ "description": "Every turn after the ask was opened, oldest first." }), "createdAt": Schema.String.annotate({ "format": "date-time" }), "updatedAt": Schema.String.annotate({ "format": "date-time" }), "closedAt": Schema.optionalKey(Schema.String.annotate({ "format": "date-time" })) }).annotate({ "description": "Work an agent put up for review.", "identifier": "ReviewAsk" });
+export const BriefingAsk = Schema.Struct({ "kind": Schema.Literal("briefing"), "prompt": BriefingPrompt, "id": Schema.String, "status": AskStatus, "waiting": Schema.Boolean.annotate({ "description": "Whether an agent is following this ask right now: waiting on its call, or polling it as a background task." }), "project": Schema.optionalKey(Schema.String), "client": Schema.optionalKey(Schema.String.annotate({ "description": "The MCP client that asked, such as `claude-code 2.1.0`." })), "raisedBy": Schema.optionalKey(Schema.suspend(() => Actor).annotate({ "description": "Whose agent asked: the person its credential belongs to, when the deployment knows." })), "thread": Schema.Array(Entry).annotate({ "description": "Every turn after the ask was opened, oldest first." }), "createdAt": Schema.String.annotate({ "format": "date-time" }), "updatedAt": Schema.String.annotate({ "format": "date-time" }), "closedAt": Schema.optionalKey(Schema.String.annotate({ "format": "date-time" })) }).annotate({ "description": "Points an agent explained, for the person to reply on one at a time.", "identifier": "BriefingAsk" });
+export const AskCommon = Schema.Struct({ "id": Schema.String, "status": AskStatus, "waiting": Schema.Boolean.annotate({ "description": "Whether an agent is following this ask right now: waiting on its call, or polling it as a background task." }), "project": Schema.optionalKey(Schema.String), "client": Schema.optionalKey(Schema.String.annotate({ "description": "The MCP client that asked, such as `claude-code 2.1.0`." })), "raisedBy": Schema.optionalKey(Schema.suspend(() => Actor).annotate({ "description": "Whose agent asked: the person its credential belongs to, when the deployment knows." })), "thread": Schema.Array(Entry).annotate({ "description": "Every turn after the ask was opened, oldest first." }), "createdAt": Schema.String.annotate({ "format": "date-time" }), "updatedAt": Schema.String.annotate({ "format": "date-time" }), "closedAt": Schema.optionalKey(Schema.String.annotate({ "format": "date-time" })) }).annotate({ "description": "What every ask carries, whatever its kind.", "identifier": "AskCommon" });
+export const Ask = Schema.Union([QuestionAsk, ReviewAsk, BriefingAsk, unknownAsk(AskStatus)]).annotate({ "description": "Something an agent needs from a person: a short thread that ends with a reply.", "identifier": "Ask" });
+export const AskEvent = Schema.Struct({ "type": Schema.Literals(["ask.opened", "ask.updated"]), "ask": Ask }).annotate({ "description": "An ask was opened, or changed: a new turn, a close, or an agent starting or stopping following it.", "identifier": "AskEvent" });
+export const AskPage = Schema.Struct({ "items": Schema.Array(Ask), "nextBefore": Schema.optionalKey(Schema.String.annotate({ "description": "Pass as `before` for the next page. Absent on the last page.", "format": "date-time" })) }).annotate({ "description": "A page of closed asks, newest first.", "identifier": "AskPage" });
+export const Snapshot = Schema.Struct({ "open": Schema.Array(Ask), "recent": Schema.Array(Ask) }).annotate({ "description": "Open asks, newest first, and the most recently closed.", "identifier": "Snapshot" });
+export const SnapshotEvent = Schema.Struct({ "type": Schema.Literal("snapshot"), "snapshot": Snapshot }).annotate({ "description": "The first frame on the event socket, and the state to start from.", "identifier": "SnapshotEvent" });
+export const ServerEvent = Schema.Union([SnapshotEvent, AskEvent, unknownEvent]).annotate({ "description": "A frame on the event socket.", "identifier": "ServerEvent" });

package/dist/src/generated/vocabularies.gen.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The spec's vocabularies - every enum the surface reaches, and what each one contains.
+ *
+ * `as const` so each is a readonly tuple of literals - the type every consumer derives with
+ * `(typeof X)[number]` keeps working unchanged.
+ */
+export declare const SPEC_VOCABULARIES: {
+    readonly AskKind: readonly ["question", "review", "briefing"];
+    readonly AskStatus: readonly ["awaiting_human", "awaiting_agent", "closed"];
+    readonly Revisions: readonly ["1"];
+};

package/dist/src/generated/vocabularies.gen.js

@@ -0,0 +1,13 @@
+// GENERATED by typespec-http-zod from the TypeSpec service definition. DO NOT EDIT.
+// Regenerate with: pnpm generate
+/**
+ * The spec's vocabularies - every enum the surface reaches, and what each one contains.
+ *
+ * `as const` so each is a readonly tuple of literals - the type every consumer derives with
+ * `(typeof X)[number]` keeps working unchanged.
+ */
+export const SPEC_VOCABULARIES = {
+    AskKind: ["question", "review", "briefing"],
+    AskStatus: ["awaiting_human", "awaiting_agent", "closed"],
+    Revisions: ["1"],
+};

package/dist/src/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./generated/requests.gen.ts";
+export * from "./generated/vocabularies.gen.ts";
+export * from "./briefing.ts";
+export * from "./versions.ts";

package/dist/src/index.js

@@ -0,0 +1,4 @@
+export * from "./generated/requests.gen.js";
+export * from "./generated/vocabularies.gen.js";
+export * from "./briefing.js";
+export * from "./versions.js";

package/dist/src/schema.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The contract as a reader decodes it: Effect schemas for every message at the latest revision,
+ * generated from the spec. Each union a release can grow (kinds of ask, blocks of content, reply
+ * outcomes, socket frames) has an `unknown` member, so a reader that meets a message from a newer
+ * revision keeps what it can show instead of failing. Decode what you receive with these; never cast
+ * it. See docs/design/versioned-messages.md.
+ */
+export * from "./generated/schemas.gen.ts";
+export type { UnknownAsk, UnknownBlock, UnknownEvent, UnknownReply } from "./unknown.ts";

package/dist/src/schema.js

@@ -0,0 +1,8 @@
+/**
+ * The contract as a reader decodes it: Effect schemas for every message at the latest revision,
+ * generated from the spec. Each union a release can grow (kinds of ask, blocks of content, reply
+ * outcomes, socket frames) has an `unknown` member, so a reader that meets a message from a newer
+ * revision keeps what it can show instead of failing. Decode what you receive with these; never cast
+ * it. See docs/design/versioned-messages.md.
+ */
+export * from "./generated/schemas.gen.js";

package/dist/src/unknown.d.ts

@@ -0,0 +1,94 @@
+import { Schema } from "effect";
+/**
+ * What a reader makes of a message it can't read: one of a kind, outcome or type it doesn't know, as
+ * it meets one from a newer revision of the contract. It keeps what it can still show and what the
+ * message said it was, so that one message is drawn as "can't be shown" instead of failing
+ * everything around it. The generated schemas end each union a release can grow with one of these
+ * (`scripts/schemas.ts`). See docs/design/versioned-messages.md.
+ */
+/** Who an unknown ask was raised by, read as leniently as the rest of it. */
+interface UnknownActor {
+    readonly id: string;
+    readonly name?: string;
+}
+/** An ask of a kind this reader doesn't know, or that it can't otherwise read. */
+export interface UnknownAsk<Status extends string = string> {
+    readonly kind: "unknown";
+    /** The kind it said it was. */
+    readonly was: string;
+    readonly id: string;
+    /** Its status, or `closed` when that is unknown too, so it never asks for attention it can't get. */
+    readonly status: Status;
+    readonly waiting: boolean;
+    readonly project?: string;
+    readonly client?: string;
+    readonly raisedBy?: UnknownActor;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly closedAt?: string;
+}
+/** The union member for an ask this reader can't read, given the statuses it knows. */
+export declare const unknownAsk: <Status extends string>(statuses: Schema.Codec<Status>) => Schema.decodeTo<Schema.Struct<{
+    readonly kind: Schema.Literal<"unknown">;
+    readonly was: Schema.String;
+    readonly id: Schema.String;
+    readonly status: Schema.Codec<Status, Status, never, never>;
+    readonly waiting: Schema.Boolean;
+    readonly project: Schema.optionalKey<Schema.String>;
+    readonly client: Schema.optionalKey<Schema.String>;
+    readonly raisedBy: Schema.optionalKey<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly name: Schema.optionalKey<Schema.String>;
+    }>>;
+    readonly createdAt: Schema.String;
+    readonly updatedAt: Schema.String;
+    readonly closedAt: Schema.optionalKey<Schema.String>;
+}>, Schema.Struct<{
+    readonly kind: Schema.String;
+    readonly id: Schema.String;
+    readonly status: Schema.String;
+    readonly waiting: Schema.optionalKey<Schema.Boolean>;
+    readonly project: Schema.optionalKey<Schema.String>;
+    readonly client: Schema.optionalKey<Schema.String>;
+    readonly raisedBy: Schema.optionalKey<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly name: Schema.optionalKey<Schema.String>;
+    }>>;
+    readonly createdAt: Schema.String;
+    readonly updatedAt: Schema.String;
+    readonly closedAt: Schema.optionalKey<Schema.String>;
+}>, never, never>;
+/** A block of content of a type this reader doesn't know. */
+export interface UnknownBlock {
+    readonly type: "unknown";
+    readonly was: string;
+}
+export declare const unknownBlock: Schema.decodeTo<Schema.Struct<{
+    readonly type: Schema.Literal<"unknown">;
+    readonly was: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.String;
+}>, never, never>;
+/** A frame on the event socket of a type this reader doesn't know. Readers skip it. */
+export interface UnknownEvent {
+    readonly type: "unknown";
+    readonly was: string;
+}
+export declare const unknownEvent: Schema.decodeTo<Schema.Struct<{
+    readonly type: Schema.Literal<"unknown">;
+    readonly was: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.String;
+}>, never, never>;
+/** A reply with an outcome this reader doesn't know. */
+export interface UnknownReply {
+    readonly outcome: "unknown";
+    readonly was: string;
+}
+export declare const unknownReply: Schema.decodeTo<Schema.Struct<{
+    readonly outcome: Schema.Literal<"unknown">;
+    readonly was: Schema.String;
+}>, Schema.Struct<{
+    readonly outcome: Schema.String;
+}>, never, never>;
+export {};

package/dist/src/unknown.js

@@ -0,0 +1,59 @@
+import { Schema, SchemaGetter } from "effect";
+const Actor = Schema.Struct({ id: Schema.String, name: Schema.optionalKey(Schema.String) });
+/**
+ * What an unknown ask is read for: what every ask has had in every revision, which a list of asks
+ * shows and sorts by. Only the identity, status and times are required, so an ask from a newer
+ * revision that has dropped anything else still reads as one.
+ */
+const AskFields = Schema.Struct({
+    kind: Schema.String,
+    id: Schema.String,
+    status: Schema.String,
+    waiting: Schema.optionalKey(Schema.Boolean),
+    project: Schema.optionalKey(Schema.String),
+    client: Schema.optionalKey(Schema.String),
+    raisedBy: Schema.optionalKey(Actor),
+    createdAt: Schema.String,
+    updatedAt: Schema.String,
+    closedAt: Schema.optionalKey(Schema.String),
+});
+/** The union member for an ask this reader can't read, given the statuses it knows. */
+export const unknownAsk = (statuses) => {
+    const known = Schema.is(statuses);
+    return AskFields.pipe(Schema.decodeTo(Schema.Struct({
+        kind: Schema.Literal("unknown"),
+        was: Schema.String,
+        id: Schema.String,
+        status: statuses,
+        waiting: Schema.Boolean,
+        project: Schema.optionalKey(Schema.String),
+        client: Schema.optionalKey(Schema.String),
+        raisedBy: Schema.optionalKey(Actor),
+        createdAt: Schema.String,
+        updatedAt: Schema.String,
+        closedAt: Schema.optionalKey(Schema.String),
+    }), {
+        decode: SchemaGetter.transform(({ kind, status, waiting, ...rest }) => ({
+            ...rest,
+            kind: "unknown",
+            was: kind,
+            status: known(status) ? status : "closed",
+            waiting: waiting ?? false,
+        })),
+        encode: SchemaGetter.transform(({ was, ...rest }) => ({ ...rest, kind: was })),
+    }));
+};
+/** A message whose `type` this reader doesn't know: the type `unknown`, and what it was. */
+const unknownType = Schema.Struct({ type: Schema.String }).pipe(Schema.decodeTo(Schema.Struct({ type: Schema.Literal("unknown"), was: Schema.String }), {
+    decode: SchemaGetter.transform(({ type }) => ({ type: "unknown", was: type })),
+    encode: SchemaGetter.transform(({ was }) => ({ type: was })),
+}));
+export const unknownBlock = unknownType;
+export const unknownEvent = unknownType;
+export const unknownReply = Schema.Struct({ outcome: Schema.String }).pipe(Schema.decodeTo(Schema.Struct({ outcome: Schema.Literal("unknown"), was: Schema.String }), {
+    decode: SchemaGetter.transform(({ outcome }) => ({
+        outcome: "unknown",
+        was: outcome,
+    })),
+    encode: SchemaGetter.transform(({ was }) => ({ outcome: was })),
+}));

package/dist/src/versions.d.ts

@@ -0,0 +1,11 @@
+/**
+ * How the parts of a deployment name the code they run, over HTTP. Every API response names the
+ * revision of the contract its server writes, and the build of the deploy it is from. A client names
+ * the revision it writes on every request; one naming a later revision than the server's, as a page
+ * from newer code does after a rollback, is refused with `409` and the problem code `reload`. See
+ * docs/design/versioned-messages.md.
+ */
+export declare const REVISION_HEADER = "Loopback-Revision";
+export declare const BUILD_HEADER = "Loopback-Build";
+/** The problem code a request from newer code than the server's is refused with: reload onto it. */
+export declare const RELOAD_CODE = "reload";

package/dist/src/versions.js

@@ -0,0 +1,11 @@
+/**
+ * How the parts of a deployment name the code they run, over HTTP. Every API response names the
+ * revision of the contract its server writes, and the build of the deploy it is from. A client names
+ * the revision it writes on every request; one naming a later revision than the server's, as a page
+ * from newer code does after a rollback, is refused with `409` and the problem code `reload`. See
+ * docs/design/versioned-messages.md.
+ */
+export const REVISION_HEADER = "Loopback-Revision";
+export const BUILD_HEADER = "Loopback-Build";
+/** The problem code a request from newer code than the server's is refused with: reload onto it. */
+export const RELOAD_CODE = "reload";