@opencode/protocol 0.0.0-dev-19653 → 0.0.0-dev-19656

package/dist/groups/form.js

@@ -1,95 +1,18 @@
 import { Form } from "@opencode/schema/form";
 import { Location } from "@opencode/schema/location";
 import { Context, Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
-import { ConflictError, FormAlreadySettledError, FormInvalidAnswerError, FormNotFoundError, InvalidRequestError, SessionNotFoundError, } from "../errors.js";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, OpenApi } from "effect/unstable/httpapi";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
-const CreatePayload = Schema.Struct({
-    id: Form.ID.pipe(Schema.optional),
-    title: Form.Info.fields.title,
-    metadata: Form.Info.fields.metadata,
-    fields: Form.Info.fields.fields,
-}).annotate({ identifier: "Form.CreatePayload" });
-// Form routes intentionally look session-scoped, but use a form-specific middleware instead of
-// SessionLocationMiddleware. The middleware treats real session IDs normally and has an
-// undocumented `global` sentinel branch for MCP elicitation forms that are still Location-scoped
-// but not session-owned. This is temporary and should disappear once elicitations are attributable.
-export const makeFormGroup = (locationMiddleware, formLocationMiddleware) => HttpApiGroup.make("server.form")
-    .add(HttpApiEndpoint.get("form.request.list", "/api/form/request", {
+export const makeFormGroup = (locationMiddleware) => HttpApiGroup.make("server.form")
+    .add(HttpApiEndpoint.get("form.list", "/api/form", {
     query: LocationQuery,
     success: Location.response(Schema.Array(Form.Info)),
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "form.request.list",
-    summary: "List pending form requests",
+    identifier: "form.list",
+    summary: "List pending forms",
     description: "Retrieve pending forms for a location.",
 })))
     .middleware(locationMiddleware)
-    .add(HttpApiEndpoint.get("session.form.list", "/api/session/:sessionID/form", {
-    params: { sessionID: Schema.String },
-    success: Schema.Struct({ data: Schema.Array(Form.Info) }),
-    error: SessionNotFoundError,
-}).annotateMerge(OpenApi.annotations({
-    identifier: "session.form.list",
-    summary: "List session forms",
-    description: "Retrieve pending forms for a session.",
-})))
-    .add(HttpApiEndpoint.post("session.form.create", "/api/session/:sessionID/form", {
-    params: { sessionID: Schema.String },
-    payload: CreatePayload,
-    success: Schema.Struct({ data: Form.Info }),
-    error: [SessionNotFoundError, ConflictError, InvalidRequestError],
-})
-    .middleware(formLocationMiddleware)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "session.form.create",
-    summary: "Create session form",
-    description: "Create a form for a session.",
-})))
-    .add(HttpApiEndpoint.get("session.form.get", "/api/session/:sessionID/form/:formID", {
-    params: { sessionID: Schema.String, formID: Form.ID },
-    success: Schema.Struct({ data: Form.Info }),
-    error: [SessionNotFoundError, FormNotFoundError],
-})
-    .middleware(formLocationMiddleware)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "session.form.get",
-    summary: "Get session form",
-    description: "Retrieve a form for a session.",
-})))
-    .add(HttpApiEndpoint.get("session.form.state", "/api/session/:sessionID/form/:formID/state", {
-    params: { sessionID: Schema.String, formID: Form.ID },
-    success: Schema.Struct({ data: Form.State }),
-    error: [SessionNotFoundError, FormNotFoundError],
-})
-    .middleware(formLocationMiddleware)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "session.form.state",
-    summary: "Get form state",
-    description: "Retrieve the current state for a form.",
-})))
-    .add(HttpApiEndpoint.post("session.form.reply", "/api/session/:sessionID/form/:formID/reply", {
-    params: { sessionID: Schema.String, formID: Form.ID },
-    payload: Form.Reply,
-    success: HttpApiSchema.NoContent,
-    error: [SessionNotFoundError, FormAlreadySettledError, FormInvalidAnswerError, FormNotFoundError],
-})
-    .middleware(formLocationMiddleware)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "session.form.reply",
-    summary: "Reply to form",
-    description: "Submit an answer to a pending form.",
-})))
-    .add(HttpApiEndpoint.post("session.form.cancel", "/api/session/:sessionID/form/:formID/cancel", {
-    params: { sessionID: Schema.String, formID: Form.ID },
-    success: HttpApiSchema.NoContent,
-    error: [SessionNotFoundError, FormAlreadySettledError, FormNotFoundError],
-})
-    .middleware(formLocationMiddleware)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "session.form.cancel",
-    summary: "Cancel form",
-    description: "Cancel a pending form.",
-})))
-    .annotateMerge(OpenApi.annotations({ title: "form", description: "Session form routes." }));
+    .annotateMerge(OpenApi.annotations({ title: "form", description: "Location form routes." }));

package/dist/groups/permission.d.ts

@@ -46,6 +46,10 @@ export declare const makePermissionGroup: <LocationId extends HttpApiMiddleware.
         };
         readonly action: Schema.String;
         readonly resource: Schema.String;
+        readonly time: Schema.Struct<{
+            readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+            readonly updated: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+        }>;
     }>>;
 }>>, never, LocationId, HttpApiMiddleware.Requires<LocationId>> | HttpApiEndpoint.HttpApiEndpoint<"permission.saved.remove", "DELETE", "/api/permission/saved/:id", Schema.toCodecStringTree<Schema.Struct<{
     id: Schema.brand<Schema.String, "PermissionSaved.ID"> & {
@@ -151,7 +155,7 @@ export declare const makePermissionGroup: <LocationId extends HttpApiMiddleware.
         create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
     };
 }>>, never, Schema.toCodecJson<Schema.Struct<{
-    readonly reply: Schema.Literals<readonly ["once", "always", "reject"]>;
+    readonly decision: Schema.Literals<readonly ["once", "always", "reject"]>;
     readonly message: Schema.optional<Schema.String>;
 }>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof SessionNotFoundError | typeof PermissionNotFoundError>, SessionLocationId, HttpApiMiddleware.Requires<SessionLocationId>> | HttpApiEndpoint.HttpApiEndpoint<"session.permission.rules", "PUT", "/api/session/:sessionID/permission/rules", Schema.toCodecStringTree<Schema.Struct<{
     sessionID: Schema.brand<Schema.String, "SessionID"> & {

package/dist/groups/permission.js

@@ -82,7 +82,7 @@ export const makePermissionGroup = (locationMiddleware, sessionLocationMiddlewar
     .add(HttpApiEndpoint.post("session.permission.reply", "/api/session/:sessionID/permission/:requestID/reply", {
     params: { sessionID: Session.ID, requestID: Permission.ID },
     payload: Schema.Struct({
-        reply: Permission.Reply,
+        decision: Permission.Reply,
         message: Schema.String.pipe(Schema.optional),
     }),
     success: HttpApiSchema.NoContent,