@opencode/protocol 2.0.32 → 2.1.1

package/dist/groups/message.js

@@ -4,6 +4,20 @@ import { Location } from "@opencode/schema/location";
 import { Schema, Struct } from "effect";
 import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/http-api";
 import { InvalidCursorError, SessionNotFoundError, UnknownError } from "../errors.js";
+// Keyed by message type so a new message type cannot be left out of the filter.
+const MessageTypes = {
+    "agent-switched": true,
+    "model-switched": true,
+    "location-switched": true,
+    user: true,
+    synthetic: true,
+    system: true,
+    skill: true,
+    shell: true,
+    assistant: true,
+    compaction: true,
+    idle: true,
+};
 export const SessionMessagesQuery = Schema.Struct({
     limit: Schema.optional(Schema.NumberFromString.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(1), Schema.isLessThanOrEqualTo(200))).annotate({
         description: "Maximum number of messages to return. When omitted, the endpoint returns its default page size.",
@@ -14,18 +28,7 @@ export const SessionMessagesQuery = Schema.Struct({
     cursor: Schema.optional(Schema.String.annotate({
         description: "Opaque pagination cursor returned as cursor.previous or cursor.next in the previous response. Do not combine with order.",
     })),
-    type: Schema.optional(Schema.Literals([
-        "agent-switched",
-        "model-switched",
-        "location-switched",
-        "user",
-        "synthetic",
-        "system",
-        "skill",
-        "shell",
-        "assistant",
-        "compaction",
-    ])).annotate({
+    type: Schema.optional(Schema.Literals(Object.keys(MessageTypes))).annotate({
         description: "Filter by message type before pagination. When omitted, all message types are returned. Pass the same type when following cursors.",
     }),
 }).annotate({ identifier: "SessionMessagesQuery" });

package/dist/groups/model.d.ts

@@ -2,7 +2,7 @@ import { Model } from "@opencode/schema/model";
 import { Schema } from "effect";
 import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
 import { ServiceUnavailableError } from "../errors.js";
-export declare const ModelGroup: HttpApiGroup.HttpApiGroup<"server.model", HttpApiEndpoint.HttpApiEndpoint<"model.list", "GET", "/api/model", never, Schema.toCodecStringTree<Schema.Struct<{
+export declare const ModelGroup: HttpApiGroup.HttpApiGroup<"server.model", HttpApiEndpoint.HttpApiEndpoint<"model.default", "GET", "/api/model/default", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{
         readonly directory: Schema.optional<Schema.String>;
     }>>;
@@ -10,80 +10,7 @@ export declare const ModelGroup: HttpApiGroup.HttpApiGroup<"server.model", HttpA
     readonly location: Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
     }>;
-    readonly data: Schema.$Array<Schema.Struct<{
-        readonly capabilities: Schema.Struct<{
-            readonly tools: Schema.Boolean;
-            readonly input: Schema.$Array<Schema.String>;
-            readonly output: Schema.$Array<Schema.String>;
-            readonly temperature: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
-        }> & {
-            default: () => {
-                tools: true;
-                input: string[];
-                output: string[];
-            };
-        };
-        readonly variants: Schema.$Array<Schema.Struct<{
-            readonly settings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.StructWithRest<Schema.Struct<{
-                readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
-                    readonly type: Schema.Literal<"summary">;
-                }>, Schema.Struct<{
-                    readonly type: Schema.Literal<"native">;
-                }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
-                    readonly type: Schema.Literal<"summary">;
-                }>, Schema.Struct<{
-                    readonly type: Schema.Literal<"native">;
-                }>]>>, never, never>;
-                readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
-            }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>>>, Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
-                readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
-                    readonly type: Schema.Literal<"summary">;
-                }>, Schema.Struct<{
-                    readonly type: Schema.Literal<"native">;
-                }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
-                    readonly type: Schema.Literal<"summary">;
-                }>, Schema.Struct<{
-                    readonly type: Schema.Literal<"native">;
-                }>]>>, never, never>;
-                readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
-            }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>>, never, never>;
-            readonly headers: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
-            readonly body: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
-            readonly id: Schema.brand<Schema.String, "Model.VariantID">;
-        }>>;
-        readonly time: Schema.Struct<{
-            readonly released: Schema.Finite;
-        }>;
-        readonly cost: Schema.$Array<Schema.Struct<{
-            readonly tier: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-                readonly type: Schema.tag<"context">;
-                readonly size: Schema.Int;
-            }>>>, Schema.optionalKey<Schema.Struct<{
-                readonly type: Schema.tag<"context">;
-                readonly size: Schema.Int;
-            }>>, never, never>;
-            readonly input: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
-                zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
-            };
-            readonly output: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
-                zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
-            };
-            readonly cache: Schema.Struct<{
-                readonly read: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
-                    zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
-                };
-                readonly write: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
-                    zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
-                };
-            }>;
-        }>>;
-        readonly status: Schema.Literals<readonly ["alpha", "beta", "deprecated", "active"]>;
-        readonly enabled: Schema.Boolean;
-        readonly limit: Schema.Struct<{
-            readonly context: Schema.Int;
-            readonly input: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
-            readonly output: Schema.Int;
-        }>;
+    readonly data: Schema.UndefinedOr<Schema.Struct<{
         readonly settings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.StructWithRest<Schema.Struct<{
             readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
                 readonly type: Schema.Literal<"summary">;
@@ -158,6 +85,7 @@ export declare const ModelGroup: HttpApiGroup.HttpApiGroup<"server.model", HttpA
             readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
             readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
             readonly supportsPromptCacheKey: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly streamUsage: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
             readonly cacheFormat: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["anthropic", "alibaba"]>>>, Schema.optionalKey<Schema.Literals<readonly ["anthropic", "alibaba"]>>, never, never>;
             readonly supportsThinkingBlockBinding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
             readonly supportsEffortUpdates: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
@@ -168,44 +96,12 @@ export declare const ModelGroup: HttpApiGroup.HttpApiGroup<"server.model", HttpA
             readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
             readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
             readonly supportsPromptCacheKey: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly streamUsage: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
             readonly cacheFormat: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["anthropic", "alibaba"]>>>, Schema.optionalKey<Schema.Literals<readonly ["anthropic", "alibaba"]>>, never, never>;
             readonly supportsThinkingBlockBinding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
             readonly supportsEffortUpdates: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
         }>>, never, never>;
         readonly package: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-    }> & {
-        default: (providerID: import("@opencode/schema/provider").ID, id: Model.ID) => {
-            id: string & import("effect/Brand").Brand<"Model.ID">;
-            modelID: string & import("effect/Brand").Brand<"Model.ID">;
-            providerID: string & import("effect/Brand").Brand<"Provider.ID">;
-            name: string & import("effect/Brand").Brand<"Model.ID">;
-            capabilities: {
-                tools: true;
-                input: string[];
-                output: string[];
-            };
-            variants: never[];
-            time: {
-                released: number;
-            };
-            cost: never[];
-            status: "active";
-            enabled: true;
-            limit: {
-                context: number;
-                output: number;
-            };
-        };
-    }>;
-}>>, Schema.toCodecJson<typeof ServiceUnavailableError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"model.default", "GET", "/api/model/default", never, Schema.toCodecStringTree<Schema.Struct<{
-    readonly location: Schema.optional<Schema.Struct<{
-        readonly directory: Schema.optional<Schema.String>;
-    }>>;
-}>>, never, never, Schema.toCodecJson<Schema.Struct<{
-    readonly location: Schema.Struct<{
-        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-    }>;
-    readonly data: Schema.UndefinedOr<Schema.Struct<{
         readonly capabilities: Schema.Struct<{
             readonly tools: Schema.Boolean;
             readonly input: Schema.$Array<Schema.String>;
@@ -279,6 +175,39 @@ export declare const ModelGroup: HttpApiGroup.HttpApiGroup<"server.model", HttpA
             readonly input: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
             readonly output: Schema.Int;
         }>;
+    }> & {
+        default: (providerID: import("@opencode/schema/provider").ID, id: Model.ID) => {
+            id: string & import("effect/Brand").Brand<"Model.ID">;
+            modelID: string & import("effect/Brand").Brand<"Model.ID">;
+            providerID: string & import("effect/Brand").Brand<"Provider.ID">;
+            name: string & import("effect/Brand").Brand<"Model.ID">;
+            capabilities: {
+                tools: true;
+                input: string[];
+                output: string[];
+            };
+            variants: never[];
+            time: {
+                released: number;
+            };
+            cost: never[];
+            status: "active";
+            enabled: true;
+            limit: {
+                context: number;
+                output: number;
+            };
+        };
+    }>;
+}>>, Schema.toCodecJson<typeof ServiceUnavailableError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"model.list", "GET", "/api/model", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
+    readonly data: Schema.$Array<Schema.Struct<{
         readonly settings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.StructWithRest<Schema.Struct<{
             readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
                 readonly type: Schema.Literal<"summary">;
@@ -353,6 +282,7 @@ export declare const ModelGroup: HttpApiGroup.HttpApiGroup<"server.model", HttpA
             readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
             readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
             readonly supportsPromptCacheKey: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly streamUsage: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
             readonly cacheFormat: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["anthropic", "alibaba"]>>>, Schema.optionalKey<Schema.Literals<readonly ["anthropic", "alibaba"]>>, never, never>;
             readonly supportsThinkingBlockBinding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
             readonly supportsEffortUpdates: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
@@ -363,11 +293,85 @@ export declare const ModelGroup: HttpApiGroup.HttpApiGroup<"server.model", HttpA
             readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
             readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
             readonly supportsPromptCacheKey: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly streamUsage: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
             readonly cacheFormat: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["anthropic", "alibaba"]>>>, Schema.optionalKey<Schema.Literals<readonly ["anthropic", "alibaba"]>>, never, never>;
             readonly supportsThinkingBlockBinding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
             readonly supportsEffortUpdates: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
         }>>, never, never>;
         readonly package: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly capabilities: Schema.Struct<{
+            readonly tools: Schema.Boolean;
+            readonly input: Schema.$Array<Schema.String>;
+            readonly output: Schema.$Array<Schema.String>;
+            readonly temperature: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        }> & {
+            default: () => {
+                tools: true;
+                input: string[];
+                output: string[];
+            };
+        };
+        readonly variants: Schema.$Array<Schema.Struct<{
+            readonly settings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.StructWithRest<Schema.Struct<{
+                readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+                    readonly type: Schema.Literal<"summary">;
+                }>, Schema.Struct<{
+                    readonly type: Schema.Literal<"native">;
+                }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+                    readonly type: Schema.Literal<"summary">;
+                }>, Schema.Struct<{
+                    readonly type: Schema.Literal<"native">;
+                }>]>>, never, never>;
+                readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
+            }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>>>, Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+                readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+                    readonly type: Schema.Literal<"summary">;
+                }>, Schema.Struct<{
+                    readonly type: Schema.Literal<"native">;
+                }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+                    readonly type: Schema.Literal<"summary">;
+                }>, Schema.Struct<{
+                    readonly type: Schema.Literal<"native">;
+                }>]>>, never, never>;
+                readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
+            }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>>, never, never>;
+            readonly headers: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
+            readonly body: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
+            readonly id: Schema.brand<Schema.String, "Model.VariantID">;
+        }>>;
+        readonly time: Schema.Struct<{
+            readonly released: Schema.Finite;
+        }>;
+        readonly cost: Schema.$Array<Schema.Struct<{
+            readonly tier: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly type: Schema.tag<"context">;
+                readonly size: Schema.Int;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly type: Schema.tag<"context">;
+                readonly size: Schema.Int;
+            }>>, never, never>;
+            readonly input: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+                zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+            };
+            readonly output: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+                zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+            };
+            readonly cache: Schema.Struct<{
+                readonly read: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+                    zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+                };
+                readonly write: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+                    zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+                };
+            }>;
+        }>>;
+        readonly status: Schema.Literals<readonly ["alpha", "beta", "deprecated", "active"]>;
+        readonly enabled: Schema.Boolean;
+        readonly limit: Schema.Struct<{
+            readonly context: Schema.Int;
+            readonly input: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+            readonly output: Schema.Int;
+        }>;
     }> & {
         default: (providerID: import("@opencode/schema/provider").ID, id: Model.ID) => {
             id: string & import("effect/Brand").Brand<"Model.ID">;

package/dist/groups/permission.d.ts

@@ -1,6 +1,6 @@
 import { Context, Schema } from "effect";
 import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema } from "effect/http-api";
-import { LocationNotFoundError, PermissionNotFoundError, SessionNotFoundError } from "../errors.js";
+import { ConflictError, LocationNotFoundError, PermissionNotFoundError, PermissionSavedNotFoundError, SessionNotFoundError } from "../errors.js";
 export declare const makePermissionGroup: <LocationId extends HttpApiMiddleware.AnyId, LocationService, SessionLocationId extends HttpApiMiddleware.AnyId, SessionLocationService>(locationMiddleware: Context.Key<LocationId, LocationService>, sessionLocationMiddleware: Context.Key<SessionLocationId, SessionLocationService>) => HttpApiGroup.HttpApiGroup<"server.permission", HttpApiEndpoint.HttpApiEndpoint<"permission.request.list", "GET", "/api/permission/request", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{
         readonly directory: Schema.optional<Schema.String>;
@@ -51,7 +51,29 @@ export declare const makePermissionGroup: <LocationId extends HttpApiMiddleware.
             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<{
+}>>, never, LocationId, HttpApiMiddleware.Requires<LocationId>> | HttpApiEndpoint.HttpApiEndpoint<"permission.saved.update", "PATCH", "/api/permission/saved/:id", Schema.toCodecStringTree<Schema.Struct<{
+    id: Schema.brand<Schema.String, "PermissionSaved.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"PermissionSaved.ID">;
+    };
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly action: Schema.optional<Schema.String>;
+    readonly resource: Schema.optional<Schema.String>;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly data: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "PermissionSaved.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"PermissionSaved.ID">;
+        };
+        readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+            global: string & import("effect/Brand").Brand<"Project.ID">;
+        };
+        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>;
+        }>;
+    }>;
+}>>, Schema.toCodecJson<typeof ConflictError | typeof PermissionSavedNotFoundError>, 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"> & {
         create: () => string & import("effect/Brand").Brand<"PermissionSaved.ID">;
     };
@@ -85,13 +107,16 @@ export declare const makePermissionGroup: <LocationId extends HttpApiMiddleware.
         };
         readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
     }>;
-}>>, Schema.toCodecJson<typeof SessionNotFoundError>, SessionLocationId, HttpApiMiddleware.Requires<SessionLocationId>> | HttpApiEndpoint.HttpApiEndpoint<"session.permission.list", "GET", "/api/session/:sessionID/permission", Schema.toCodecStringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof SessionNotFoundError>, SessionLocationId, HttpApiMiddleware.Requires<SessionLocationId>> | HttpApiEndpoint.HttpApiEndpoint<"session.permission.get", "GET", "/api/session/:sessionID/permission/:requestID", Schema.toCodecStringTree<Schema.Struct<{
     sessionID: Schema.brand<Schema.String, "SessionID"> & {
         create: () => string & import("effect/Brand").Brand<"SessionID">;
         descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
     };
+    requestID: Schema.brand<Schema.String, "Permission.ID"> & {
+        create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
+    };
 }>>, never, never, never, Schema.toCodecJson<Schema.Struct<{
-    readonly data: Schema.$Array<Schema.Struct<{
+    readonly data: Schema.Struct<{
         readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
@@ -113,17 +138,14 @@ export declare const makePermissionGroup: <LocationId extends HttpApiMiddleware.
         readonly id: Schema.brand<Schema.String, "Permission.ID"> & {
             create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
         };
-    }>>;
-}>>, Schema.toCodecJson<typeof LocationNotFoundError | typeof SessionNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"session.permission.get", "GET", "/api/session/:sessionID/permission/:requestID", Schema.toCodecStringTree<Schema.Struct<{
+    }>;
+}>>, Schema.toCodecJson<typeof SessionNotFoundError | typeof PermissionNotFoundError>, SessionLocationId, HttpApiMiddleware.Requires<SessionLocationId>> | HttpApiEndpoint.HttpApiEndpoint<"session.permission.list", "GET", "/api/session/:sessionID/permission", Schema.toCodecStringTree<Schema.Struct<{
     sessionID: Schema.brand<Schema.String, "SessionID"> & {
         create: () => string & import("effect/Brand").Brand<"SessionID">;
         descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
     };
-    requestID: Schema.brand<Schema.String, "Permission.ID"> & {
-        create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
-    };
 }>>, never, never, never, Schema.toCodecJson<Schema.Struct<{
-    readonly data: Schema.Struct<{
+    readonly data: Schema.$Array<Schema.Struct<{
         readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
@@ -145,8 +167,8 @@ export declare const makePermissionGroup: <LocationId extends HttpApiMiddleware.
         readonly id: Schema.brand<Schema.String, "Permission.ID"> & {
             create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
         };
-    }>;
-}>>, Schema.toCodecJson<typeof SessionNotFoundError | typeof PermissionNotFoundError>, SessionLocationId, HttpApiMiddleware.Requires<SessionLocationId>> | HttpApiEndpoint.HttpApiEndpoint<"session.permission.reply", "POST", "/api/session/:sessionID/permission/:requestID/reply", Schema.toCodecStringTree<Schema.Struct<{
+    }>>;
+}>>, Schema.toCodecJson<typeof LocationNotFoundError | typeof SessionNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"session.permission.reply", "POST", "/api/session/:sessionID/permission/:requestID/reply", Schema.toCodecStringTree<Schema.Struct<{
     sessionID: Schema.brand<Schema.String, "SessionID"> & {
         create: () => string & import("effect/Brand").Brand<"SessionID">;
         descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;

package/dist/groups/permission.js

@@ -6,7 +6,7 @@ import { Project } from "@opencode/schema/project";
 import { Session } from "@opencode/schema/session";
 import { Context, Schema } from "effect";
 import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, OpenApi } from "effect/http-api";
-import { LocationNotFoundError, PermissionNotFoundError, SessionNotFoundError } from "../errors.js";
+import { ConflictError, LocationNotFoundError, PermissionNotFoundError, PermissionSavedNotFoundError, SessionNotFoundError, } from "../errors.js";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const makePermissionGroup = (locationMiddleware, sessionLocationMiddleware) => HttpApiGroup.make("server.permission")
     .add(HttpApiEndpoint.get("permission.request.list", "/api/permission/request", {
@@ -26,6 +26,19 @@ export const makePermissionGroup = (locationMiddleware, sessionLocationMiddlewar
     identifier: "permission.saved.list",
     summary: "List saved permissions",
     description: "Retrieve saved permissions, optionally filtered by project.",
+})))
+    .add(HttpApiEndpoint.patch("permission.saved.update", "/api/permission/saved/:id", {
+    params: { id: PermissionSaved.ID },
+    payload: Schema.Struct({
+        action: Schema.String.pipe(Schema.optional),
+        resource: Schema.String.pipe(Schema.optional),
+    }),
+    success: Schema.Struct({ data: PermissionSaved.Info }),
+    error: [PermissionSavedNotFoundError, ConflictError],
+}).annotateMerge(OpenApi.annotations({
+    identifier: "permission.saved.update",
+    summary: "Update saved permission",
+    description: "Change the action or resource of a saved permission. Fails with a conflict when the project already has a saved permission with the same action and resource.",
 })))
     .add(HttpApiEndpoint.delete("permission.saved.remove", "/api/permission/saved/:id", {
     params: { id: PermissionSaved.ID },