@opencode/server 2.0.2 → 2.0.4

package/dist/api.d.ts

@@ -145,7 +145,7 @@ export declare const Api: import("@opencode/protocol/api").Api<LocationMiddlewar
     };
     readonly created: import("effect/Schema").Finite;
     readonly metadata: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>, never, never>;
-    readonly type: import("effect/Schema").Literal<"catalog.updated">;
+    readonly type: import("effect/Schema").Literal<"provider.updated">;
     readonly location: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
         readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
         readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
@@ -167,7 +167,39 @@ export declare const Api: import("@opencode/protocol/api").Api<LocationMiddlewar
     }>>, never, never>;
     readonly data: import("effect/Schema").Struct<{}>;
 }> & {
-    type: "catalog.updated";
+    type: "provider.updated";
+    durability: "ephemeral";
+    durable: undefined;
+    data: import("effect/Schema").Struct<{}>;
+}, import("effect/Schema").Struct<{
+    readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: import("effect/Schema").Finite;
+    readonly metadata: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>, never, never>;
+    readonly type: import("effect/Schema").Literal<"model.updated">;
+    readonly location: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+        readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+        readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+        readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: import("effect/Schema").Struct<{}>;
+}> & {
+    type: "model.updated";
     durability: "ephemeral";
     durable: undefined;
     data: import("effect/Schema").Struct<{}>;
@@ -789,7 +821,7 @@ export declare const Api: import("@opencode/protocol/api").Api<LocationMiddlewar
     };
     readonly created: import("effect/Schema").Finite;
     readonly metadata: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>, never, never>;
-    readonly type: import("effect/Schema").Literal<"session.permissions.updated">;
+    readonly type: import("effect/Schema").Literal<"session.permissions">;
     readonly durable: import("effect/Schema").Struct<{
         readonly aggregateID: import("effect/Schema").String;
         readonly seq: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Seq">;
@@ -826,7 +858,7 @@ export declare const Api: import("@opencode/protocol/api").Api<LocationMiddlewar
         };
     }>;
 }> & {
-    type: "session.permissions.updated";
+    type: "session.permissions";
     durability: "durable";
     durable: {
         readonly version: number;
@@ -4541,7 +4573,6 @@ export declare const Api: import("@opencode/protocol/api").Api<LocationMiddlewar
         readonly time: import("effect/Schema").Struct<{
             readonly created: import("effect/Schema").Int;
             readonly updated: import("effect/Schema").Int;
-            readonly initialized: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Int>>, import("effect/Schema").optionalKey<import("effect/Schema").Int>, never, never>;
         }>;
         readonly sandboxes: import("effect/Schema").$Array<import("effect/Schema").String>;
     }>;
@@ -4573,7 +4604,6 @@ export declare const Api: import("@opencode/protocol/api").Api<LocationMiddlewar
         readonly time: import("effect/Schema").Struct<{
             readonly created: import("effect/Schema").Int;
             readonly updated: import("effect/Schema").Int;
-            readonly initialized: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Int>>, import("effect/Schema").optionalKey<import("effect/Schema").Int>, never, never>;
         }>;
         readonly sandboxes: import("effect/Schema").$Array<import("effect/Schema").String>;
     }>;
@@ -6156,13 +6186,6 @@ export declare const Api: import("@opencode/protocol/api").Api<LocationMiddlewar
     readonly type: import("effect/Schema").TemplateLiteral<readonly ["rpc.", import("effect/Schema").String]>;
     readonly location: import("effect/Schema").Struct<{
         readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
-        readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
-            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
-            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
-        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
-            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
-            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
-        }>, never, never>;
     }>;
     readonly data: import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>;
 }>, ...import("effect/Schema").Struct<{
@@ -6174,13 +6197,6 @@ export declare const Api: import("@opencode/protocol/api").Api<LocationMiddlewar
     readonly metadata: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>;
     readonly location: import("effect/Schema").optional<import("effect/Schema").Struct<{
         readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
-        readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
-            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
-            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
-        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
-            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
-            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
-        }>, never, never>;
     }>>;
 }>[]]>>, import("effect/Schema").Never, {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
@@ -6199,8 +6215,6 @@ export declare const Api: import("@opencode/protocol/api").Api<LocationMiddlewar
     readonly data: {
         readonly form: {
             readonly id: string & import("effect/Brand").Brand<"Form.ID">;
-            readonly sessionID: string;
-            readonly title: string;
             readonly fields: readonly [{
                 readonly type: "string";
                 readonly key: string;
@@ -6380,6 +6394,8 @@ export declare const Api: import("@opencode/protocol/api").Api<LocationMiddlewar
                 readonly description?: string | undefined;
                 readonly title?: string | undefined;
             })[]];
+            readonly sessionID: string;
+            readonly title: string;
             readonly metadata?: {
                 readonly [x: string]: unknown;
             } | undefined;
@@ -6466,6 +6482,30 @@ export declare const Api: import("@opencode/protocol/api").Api<LocationMiddlewar
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
+} | {
+    readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+    readonly data: {};
+    readonly type: "provider.updated";
+    readonly created: number;
+    readonly location?: {
+        readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+        readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
+    } | undefined;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+} | {
+    readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+    readonly data: {};
+    readonly type: "model.updated";
+    readonly created: number;
+    readonly location?: {
+        readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+        readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
+    } | undefined;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
 } | {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly data: {
@@ -6529,7 +6569,6 @@ export declare const Api: import("@opencode/protocol/api").Api<LocationMiddlewar
         readonly time: {
             readonly created: number;
             readonly updated: number;
-            readonly initialized?: number | undefined;
         };
         readonly sandboxes: readonly string[];
         readonly name?: string | undefined;
@@ -6765,7 +6804,7 @@ export declare const Api: import("@opencode/protocol/api").Api<LocationMiddlewar
         readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
         readonly version: number & import("effect/Brand").Brand<"Event.Version">;
     };
-    readonly type: "session.permissions.updated";
+    readonly type: "session.permissions";
     readonly created: number;
     readonly location?: {
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
@@ -7959,18 +7998,6 @@ export declare const Api: import("@opencode/protocol/api").Api<LocationMiddlewar
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-} | {
-    readonly id: string & import("effect/Brand").Brand<"Event.ID">;
-    readonly data: {};
-    readonly type: "catalog.updated";
-    readonly created: number;
-    readonly location?: {
-        readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
-        readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
-    } | undefined;
-    readonly metadata?: {
-        readonly [x: string]: unknown;
-    } | undefined;
 } | {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly data: {};
@@ -8370,7 +8397,6 @@ export declare const Api: import("@opencode/protocol/api").Api<LocationMiddlewar
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly location: {
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
-        readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
     };
     readonly data: {
         readonly [x: string]: unknown;
@@ -8386,7 +8412,6 @@ export declare const Api: import("@opencode/protocol/api").Api<LocationMiddlewar
     readonly type: "server.connected";
     readonly location?: {
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
-        readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
     } | undefined;
     readonly metadata?: {
         readonly [x: string]: unknown;

package/dist/handlers/config.js

@@ -3,16 +3,11 @@ import { ShellSelect } from "@opencode/core/shell/select";
 import { Effect } from "effect";
 import { HttpApiBuilder } from "effect/unstable/httpapi";
 import { Api } from "../api";
-export const ConfigHandler = HttpApiBuilder.group(Api, "server.config", (handlers) => handlers.handle("config.get", () => Config.Service.use((config) => config.entries())).handle("config.preferences", Effect.fn(function* () {
+export const ConfigHandler = HttpApiBuilder.group(Api, "server.config", (handlers) => handlers.handle("config.get", () => Config.Service.use((config) => config.entries())).handle("config.update", Effect.fn(function* (ctx) {
   const config = yield* Config.Service;
-  if (!config.preferences)
-    return yield* Effect.die(Error("Config preferences are unavailable"));
-  return yield* config.preferences().pipe(Effect.orDie);
-})).handle("config.updatePreferences", Effect.fn(function* (ctx) {
-  const config = yield* Config.Service;
-  if (!config.updatePreferences)
-    return yield* Effect.die(Error("Config preference updates are unavailable"));
-  return yield* config.updatePreferences(ctx.payload).pipe(Effect.orDie);
+  if (!config.update)
+    return yield* Effect.die(Error("Config updates are unavailable"));
+  return yield* config.update(ctx.payload).pipe(Effect.orDie);
 })).handle("config.shells", Effect.fn(function* () {
   const shell = yield* ShellSelect.Service;
   if (!shell.list)

package/dist/handlers/credential.d.ts

@@ -1 +1,2 @@
-export declare const CredentialHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.credential">, never, import("@opencode/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization | import("../location").LocationMiddleware>;
+import { Credential } from "@opencode/core/credential";
+export declare const CredentialHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.credential">, never, import("@opencode/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization | import("effect/unstable/http/HttpRouter").Request<"Requires", Credential.Service>>;

package/dist/handlers/credential.js

@@ -1,14 +1,14 @@
-import { Integration } from "@opencode/core/integration";
+import { Credential } from "@opencode/core/credential";
 import { Effect } from "effect";
 import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi";
 import { Api } from "../api";
 export const CredentialHandler = HttpApiBuilder.group(Api, "server.credential", (handlers) => handlers.handle("credential.update", Effect.fn(function* (ctx) {
-  yield* (yield* Integration.Service).connection.update(ctx.params.credentialID, { label: ctx.payload.label });
+  yield* (yield* Credential.Service).update(ctx.params.credentialID, { label: ctx.payload.label });
   return HttpApiSchema.NoContent.make();
 })).handle("credential.activate", Effect.fn(function* (ctx) {
-  yield* (yield* Integration.Service).connection.activate(ctx.params.credentialID);
+  yield* (yield* Credential.Service).activate(ctx.params.credentialID);
   return HttpApiSchema.NoContent.make();
 })).handle("credential.remove", Effect.fn(function* (ctx) {
-  yield* (yield* Integration.Service).connection.remove(ctx.params.credentialID);
+  yield* (yield* Credential.Service).remove(ctx.params.credentialID);
   return HttpApiSchema.NoContent.make();
 })));

package/dist/handlers/form.d.ts

@@ -1,4 +1 @@
-import { Instance } from "@opencode/core/instance/service";
-import { LocationServiceMap } from "@opencode/core/location-services";
-import { Session } from "@opencode/core/session";
-export declare const FormHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.form">, never, LocationServiceMap.Service | Session.Service | Instance.Service | import("../location").LocationMiddleware | (import("@opencode/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization | import("../middleware/form-location").FormLocationMiddleware)>;
+export declare const FormHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.form">, never, import("@opencode/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization | import("../location").LocationMiddleware>;

package/dist/handlers/form.js

@@ -1,61 +1,9 @@
 import { Form } from "@opencode/core/form";
-import { Instance } from "@opencode/core/instance/service";
-import { LocationServiceMap } from "@opencode/core/location-services";
-import { Session } from "@opencode/core/session";
-import {
-  ConflictError,
-  FormAlreadySettledError,
-  FormInvalidAnswerError,
-  FormNotFoundError,
-  InvalidRequestError
-} from "@opencode/protocol/errors";
 import { Effect } from "effect";
-import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
 import { Api } from "../api";
-import { requestRef, response, sessionInfo } from "../location";
-function missingForm(id) {
-  return new FormNotFoundError({ id, message: `Form not found: ${id}` });
-}
-export const FormHandler = HttpApiBuilder.group(Api, "server.form", (handlers) => Effect.gen(function* () {
-  const locations = yield* LocationServiceMap.Service, instances = yield* Instance.Service, sessions = yield* Session.Service, requireOwnedForm = Effect.fnUntraced(function* (sessionID, formID) {
-    const form = yield* Form.Service, info = yield* form.get(formID).pipe(Effect.catchTag("Form.NotFoundError", () => missingForm(formID)));
-    if (info.sessionID !== sessionID)
-      return yield* missingForm(formID);
-    return { form, info };
-  });
-  return handlers.handle("form.request.list", Effect.fn(function* () {
-    const form = yield* Form.Service;
-    return yield* response(form.list());
-  })).handle("session.form.list", Effect.fn(function* (ctx) {
-    const session = ctx.params.sessionID === "global" ? void 0 : yield* sessionInfo(sessions, ctx.params.sessionID), read = Form.Service.use((form) => form.list({ sessionID: ctx.params.sessionID }));
-    return { data: yield* session ? read.pipe(instances.provide(session)) : read.pipe(Effect.provide(locations.get(requestRef(ctx.request)))) };
-  })).handle("session.form.create", Effect.fn(function* (ctx) {
-    return { data: yield* (yield* Form.Service).create({
-      id: ctx.payload.id,
-      sessionID: ctx.params.sessionID,
-      title: ctx.payload.title,
-      metadata: ctx.payload.metadata,
-      fields: ctx.payload.fields
-    }).pipe(Effect.catchTags({
-      "Form.AlreadyExistsError": (error) => new ConflictError({ resource: error.id, message: error.message }),
-      "Form.InvalidFormError": (error) => new InvalidRequestError({ message: error.message, field: "fields" })
-    })) };
-  })).handle("session.form.get", Effect.fn(function* (ctx) {
-    return { data: (yield* requireOwnedForm(ctx.params.sessionID, ctx.params.formID)).info };
-  })).handle("session.form.state", Effect.fn(function* (ctx) {
-    return { data: yield* (yield* requireOwnedForm(ctx.params.sessionID, ctx.params.formID)).form.state(ctx.params.formID).pipe(Effect.catchTag("Form.NotFoundError", () => missingForm(ctx.params.formID))) };
-  })).handle("session.form.reply", Effect.fn(function* (ctx) {
-    yield* (yield* requireOwnedForm(ctx.params.sessionID, ctx.params.formID)).form.reply({ id: ctx.params.formID, answer: ctx.payload.answer }).pipe(Effect.catchTags({
-      "Form.AlreadySettledError": (error) => new FormAlreadySettledError({ id: error.id, message: error.message }),
-      "Form.InvalidAnswerError": (error) => new FormInvalidAnswerError({ id: error.id, message: error.message }),
-      "Form.NotFoundError": () => missingForm(ctx.params.formID)
-    }));
-    return HttpApiSchema.NoContent.make();
-  })).handle("session.form.cancel", Effect.fn(function* (ctx) {
-    yield* (yield* requireOwnedForm(ctx.params.sessionID, ctx.params.formID)).form.cancel(ctx.params.formID).pipe(Effect.catchTags({
-      "Form.AlreadySettledError": (error) => new FormAlreadySettledError({ id: error.id, message: error.message }),
-      "Form.NotFoundError": () => missingForm(ctx.params.formID)
-    }));
-    return HttpApiSchema.NoContent.make();
-  }));
-}));
+import { response } from "../location";
+export const FormHandler = HttpApiBuilder.group(Api, "server.form", (handlers) => handlers.handle("form.list", Effect.fn(function* () {
+  const form = yield* Form.Service;
+  return yield* response(form.list());
+})));

package/dist/handlers/integration.js

@@ -2,7 +2,12 @@ import { Integration } from "@opencode/core/integration";
 import { Effect } from "effect";
 import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi";
 import { Api } from "../api";
-import { InvalidRequestError } from "@opencode/protocol/errors";
+import {
+  IntegrationAttemptNotFoundError,
+  IntegrationMethodNotFoundError,
+  IntegrationNotFoundError,
+  InvalidRequestError
+} from "@opencode/protocol/errors";
 import { response } from "../location";
 import { WellKnown } from "@opencode/core/wellknown";
 const authorize = (effect) => effect.pipe(Effect.mapError((error) => new InvalidRequestError({
@@ -14,8 +19,13 @@ export const IntegrationHandler = HttpApiBuilder.group(Api, "server.integration"
     const service = yield* Integration.Service;
     return yield* response(service.list());
   })).handle("integration.get", Effect.fn(function* (ctx) {
-    const service = yield* Integration.Service;
-    return yield* response(service.get(ctx.params.integrationID));
+    const integration = yield* (yield* Integration.Service).get(ctx.params.integrationID);
+    if (!integration)
+      return yield* new IntegrationNotFoundError({
+        integrationID: ctx.params.integrationID,
+        message: `Integration not found: ${ctx.params.integrationID}`
+      });
+    return yield* response(Effect.succeed(integration));
   })).handle("integration.wellknown.add", Effect.fn(function* (ctx) {
     const wellknown = yield* WellKnown.Service, integration = yield* Integration.Service;
     yield* wellknown.add(ctx.payload.url).pipe(Effect.mapError((error) => new InvalidRequestError({ message: error.message, kind: "well_known_discovery" })));
@@ -23,6 +33,11 @@ export const IntegrationHandler = HttpApiBuilder.group(Api, "server.integration"
     return HttpApiSchema.NoContent.make();
   })).handle("integration.connect.key", Effect.fn(function* (ctx) {
     const service = yield* Integration.Service;
+    if (!(yield* service.get(ctx.params.integrationID)))
+      return yield* new IntegrationNotFoundError({
+        integrationID: ctx.params.integrationID,
+        message: `Integration not found: ${ctx.params.integrationID}`
+      });
     yield* authorize(service.connection.key({
       integrationID: ctx.params.integrationID,
       key: ctx.payload.key,
@@ -40,19 +55,42 @@ export const IntegrationHandler = HttpApiBuilder.group(Api, "server.integration"
     })));
   })).handle("integration.oauth.status", Effect.fn(function* (ctx) {
     const service = yield* Integration.Service;
+    if (!(yield* service.get(ctx.params.integrationID)))
+      return yield* new IntegrationNotFoundError({
+        integrationID: ctx.params.integrationID,
+        message: `Integration not found: ${ctx.params.integrationID}`
+      });
     return yield* response(service.oauth.status({
       integrationID: ctx.params.integrationID,
       attemptID: ctx.params.attemptID
-    }));
+    }).pipe(Effect.mapError((error) => new IntegrationAttemptNotFoundError({
+      integrationID: error.integrationID,
+      attemptID: error.attemptID,
+      message: `OAuth attempt not found: ${error.attemptID}`
+    }))));
   })).handle("integration.oauth.complete", Effect.fn(function* (ctx) {
-    yield* (yield* Integration.Service).oauth.complete({
+    const service = yield* Integration.Service;
+    if (!(yield* service.get(ctx.params.integrationID)))
+      return yield* new IntegrationNotFoundError({
+        integrationID: ctx.params.integrationID,
+        message: `Integration not found: ${ctx.params.integrationID}`
+      });
+    yield* service.oauth.complete({
       integrationID: ctx.params.integrationID,
       attemptID: ctx.params.attemptID,
       code: ctx.payload.code
-    }).pipe(Effect.mapError((error) => new InvalidRequestError({
-      message: error._tag === "Integration.CodeRequired" ? "Authorization code is required" : "Authentication failed",
-      kind: error._tag === "Integration.CodeRequired" ? "integration_code_required" : "integration_authorization"
-    })));
+    }).pipe(Effect.mapError((error) => {
+      if (error._tag === "Integration.AttemptNotFound")
+        return new IntegrationAttemptNotFoundError({
+          integrationID: error.integrationID,
+          attemptID: error.attemptID,
+          message: `OAuth attempt not found: ${error.attemptID}`
+        });
+      return new InvalidRequestError({
+        message: error._tag === "Integration.CodeRequired" ? "Authorization code is required" : "Authentication failed",
+        kind: error._tag === "Integration.CodeRequired" ? "integration_code_required" : "integration_authorization"
+      });
+    }));
     return HttpApiSchema.NoContent.make();
   })).handle("integration.oauth.cancel", Effect.fn(function* (ctx) {
     yield* (yield* Integration.Service).oauth.cancel({
@@ -61,7 +99,18 @@ export const IntegrationHandler = HttpApiBuilder.group(Api, "server.integration"
     });
     return HttpApiSchema.NoContent.make();
   })).handle("integration.command.connect", Effect.fn(function* (ctx) {
-    const service = yield* Integration.Service;
+    const service = yield* Integration.Service, integration = yield* service.get(ctx.params.integrationID);
+    if (!integration)
+      return yield* new IntegrationNotFoundError({
+        integrationID: ctx.params.integrationID,
+        message: `Integration not found: ${ctx.params.integrationID}`
+      });
+    if (!integration.methods.some((method) => method.type === "command" && method.id === ctx.payload.methodID))
+      return yield* new IntegrationMethodNotFoundError({
+        integrationID: ctx.params.integrationID,
+        methodID: ctx.payload.methodID,
+        message: `Integration method not found: ${ctx.payload.methodID}`
+      });
     return yield* response(authorize(service.command.connect({
       integrationID: ctx.params.integrationID,
       methodID: ctx.payload.methodID,
@@ -69,10 +118,19 @@ export const IntegrationHandler = HttpApiBuilder.group(Api, "server.integration"
     })));
   })).handle("integration.command.status", Effect.fn(function* (ctx) {
     const service = yield* Integration.Service;
+    if (!(yield* service.get(ctx.params.integrationID)))
+      return yield* new IntegrationNotFoundError({
+        integrationID: ctx.params.integrationID,
+        message: `Integration not found: ${ctx.params.integrationID}`
+      });
     return yield* response(service.command.status({
       integrationID: ctx.params.integrationID,
       attemptID: ctx.params.attemptID
-    }));
+    }).pipe(Effect.mapError((error) => new IntegrationAttemptNotFoundError({
+      integrationID: error.integrationID,
+      attemptID: error.attemptID,
+      message: `Command attempt not found: ${error.attemptID}`
+    }))));
   })).handle("integration.command.cancel", Effect.fn(function* (ctx) {
     yield* (yield* Integration.Service).command.cancel({
       integrationID: ctx.params.integrationID,

package/dist/handlers/location.js

@@ -6,7 +6,6 @@ export const LocationHandler = HttpApiBuilder.group(Api, "server.location", (han
   const location = yield* Location.Service;
   return new Location.Info({
     directory: location.directory,
-    workspaceID: location.workspaceID,
     project: location.project
   });
 })));

package/dist/handlers/model.js

@@ -1,14 +1,14 @@
-import { Catalog } from "@opencode/core/catalog";
+import { Model } from "@opencode/core/model";
 import { Effect } from "effect";
 import { HttpApiBuilder } from "effect/unstable/httpapi";
 import { Api } from "../api";
 import { response } from "../location";
 export const ModelHandler = HttpApiBuilder.group(Api, "server.model", (handlers) => Effect.gen(function* () {
   return handlers.handle("model.list", Effect.fn(function* () {
-    const catalog = yield* Catalog.Service;
-    return yield* response(catalog.model.available());
+    const models = yield* Model.Service;
+    return yield* response(models.available());
   })).handle("model.default", Effect.fn(function* () {
-    const catalog = yield* Catalog.Service;
-    return yield* response(catalog.model.default());
+    const models = yield* Model.Service;
+    return yield* response(models.default());
   }));
 }));

package/dist/handlers/permission.d.ts

@@ -1,4 +1,4 @@
 import { Instance } from "@opencode/core/instance/service";
 import { PermissionSaved } from "@opencode/core/permission/saved";
 import { Session } from "@opencode/core/session";
-export declare const PermissionHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.permission">, never, import("@opencode/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization | Session.Service | Instance.Service | import("../location").LocationMiddleware | import("../middleware/session-location").SessionLocationMiddleware | import("effect/unstable/http/HttpRouter").Request<"Requires", PermissionSaved.Service>>;
+export declare const PermissionHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.permission">, never, Session.Service | Instance.Service | import("../middleware/session-location").SessionLocationMiddleware | (import("@opencode/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization | import("../location").LocationMiddleware | import("effect/unstable/http/HttpRouter").Request<"Requires", PermissionSaved.Service>)>;

package/dist/handlers/permission.js

@@ -41,10 +41,7 @@ export const PermissionHandler = HttpApiBuilder.group(Api, "server.permission",
   })).handle("session.permission.get", Effect.fn(function* (ctx) {
     return { data: (yield* requireOwnedRequest(ctx.params.sessionID, ctx.params.requestID)).request };
   })).handle("session.permission.reply", Effect.fn(function* (ctx) {
-    yield* (yield* requireOwnedRequest(ctx.params.sessionID, ctx.params.requestID)).permission.reply({ requestID: ctx.params.requestID, reply: ctx.payload.reply, message: ctx.payload.message }).pipe(Effect.catchTag("Permission.NotFoundError", () => missingRequest(ctx.params.requestID)));
-    return HttpApiSchema.NoContent.make();
-  })).handle("session.permission.rules", Effect.fn(function* (ctx) {
-    yield* sessions.setPermissions({ sessionID: ctx.params.sessionID, permissions: ctx.payload.permissions }).pipe(Effect.catchTag("Session.NotFoundError", missingSession));
+    yield* (yield* requireOwnedRequest(ctx.params.sessionID, ctx.params.requestID)).permission.reply({ requestID: ctx.params.requestID, reply: ctx.payload.decision, message: ctx.payload.message }).pipe(Effect.catchTag("Permission.NotFoundError", () => missingRequest(ctx.params.requestID)));
     return HttpApiSchema.NoContent.make();
   })).handle("permission.saved.list", Effect.fn(function* (ctx) {
     const location = yield* Location.Service;

package/dist/handlers/plugin.js

@@ -7,10 +7,8 @@ import { Api } from "../api";
 import { response } from "../location";
 export const PluginHandler = HttpApiBuilder.group(Api, "server.plugin", (handlers) => handlers.handle("plugin.list", () => Effect.gen(function* () {
   return yield* response(Plugin.Service.use((plugin) => plugin.list()));
-})).handle("plugin.awaitActivation", () => Plugin.awaitActivation).handle("plugin.check", (ctx) => Effect.gen(function* () {
-  const plugins = yield* Plugin.Service;
-  yield* plugins.awaitActivation;
-  const inventory = yield* plugins.list(), targets = [
+})).handle("plugin.check", (ctx) => Effect.gen(function* () {
+  const inventory = yield* (yield* Plugin.Service).list(), targets = [
     ...new Set(inventory.flatMap((plugin) => plugin.source.type === "package" ? [plugin.source.target] : []))
   ].filter((target) => ctx.payload.target === void 0 || target === ctx.payload.target);
   if (ctx.payload.target !== void 0 && !targets.length)
@@ -34,9 +32,7 @@ export const PluginHandler = HttpApiBuilder.group(Api, "server.plugin", (handler
     };
   })));
 })).handle("plugin.update", (ctx) => Effect.gen(function* () {
-  const plugins = yield* Plugin.Service;
-  yield* plugins.awaitActivation;
-  const inventory = new Set((yield* plugins.list()).flatMap((plugin) => plugin.source.type === "package" ? [plugin.source.target] : [])), unknown = ctx.payload.targets.filter((target) => !inventory.has(target));
+  const plugins = yield* Plugin.Service, inventory = new Set((yield* plugins.list()).flatMap((plugin) => plugin.source.type === "package" ? [plugin.source.target] : [])), unknown = ctx.payload.targets.filter((target) => !inventory.has(target));
   if (unknown.length)
     return yield* new InvalidRequestError({
       message: `Plugin packages are not in the current server inventory: ${unknown.join(", ")}`,

package/dist/handlers/project.d.ts

@@ -1,2 +1,2 @@
 import { Project } from "@opencode/core/project";
-export declare const ProjectHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.project">, never, import("effect/unstable/http/HttpRouter").Request<"Requires", Project.Service> | (import("@opencode/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization | import("../location").LocationMiddleware)>;
+export declare const ProjectHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.project">, never, import("@opencode/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization | import("../location").LocationMiddleware | import("effect/unstable/http/HttpRouter").Request<"Requires", Project.Service>>;

package/dist/handlers/project.js

@@ -1,4 +1,3 @@
-import { Location } from "@opencode/core/location";
 import { Project } from "@opencode/core/project";
 import { Effect } from "effect";
 import { HttpApiBuilder } from "effect/unstable/httpapi";
@@ -7,8 +6,4 @@ import { ProjectNotFoundError } from "@opencode/protocol/errors";
 export const ProjectHandler = HttpApiBuilder.group(Api, "server.project", (handlers) => handlers.handle("project.list", () => Project.Service.use((project) => project.list())).handle("project.update", (ctx) => Project.Service.use((project) => project.update({ ...ctx.payload, projectID: ctx.params.projectID }).pipe(Effect.mapError(() => new ProjectNotFoundError({
   projectID: ctx.params.projectID,
   message: `Project not found: ${ctx.params.projectID}`
-}))))).handle("project.current", () => Location.Service.use((location) => Effect.succeed({
-  id: location.project.id,
-  directory: location.project.directory,
-  canonical: location.project.canonical
-}))));
+}))))));

package/dist/handlers/provider.js

@@ -1,4 +1,4 @@
-import { Catalog } from "@opencode/core/catalog";
+import { Provider } from "@opencode/core/provider";
 import { ProviderNotFoundError } from "@opencode/protocol/errors";
 import { Effect } from "effect";
 import { HttpApiBuilder } from "effect/unstable/httpapi";
@@ -6,10 +6,10 @@ import { Api } from "../api";
 import { response } from "../location";
 export const ProviderHandler = HttpApiBuilder.group(Api, "server.provider", (handlers) => Effect.gen(function* () {
   return handlers.handle("provider.list", Effect.fn(function* () {
-    const catalog = yield* Catalog.Service;
-    return yield* response(catalog.provider.available());
+    const providers = yield* Provider.Service;
+    return yield* response(providers.available());
   })).handle("provider.get", Effect.fn(function* (ctx) {
-    const provider = yield* (yield* Catalog.Service).provider.get(ctx.params.providerID);
+    const provider = yield* (yield* Provider.Service).get(ctx.params.providerID);
     if (!provider)
       return yield* new ProviderNotFoundError({
         providerID: ctx.params.providerID,

package/dist/handlers/server.js

@@ -2,6 +2,11 @@ import { Effect } from "effect";
 import { HttpApiBuilder } from "effect/unstable/httpapi";
 import { Api } from "../api";
 import { ServerInfo } from "../server-info";
-export const ServerHandler = HttpApiBuilder.group(Api, "server.server", (handlers) => handlers.handle("server.get", () => Effect.gen(function* () {
-  return { urls: (yield* ServerInfo.Service).urls() };
+export const ServerHandler = HttpApiBuilder.group(Api, "server.server", (handlers) => handlers.handle("server.status", () => Effect.gen(function* () {
+  const info = yield* ServerInfo.Service;
+  return {
+    version: info.app.version ?? "unknown",
+    pid: process.pid ?? 0,
+    urls: info.urls()
+  };
 })));

package/dist/handlers/session-error.d.ts

@@ -1,5 +1,9 @@
 import { Session } from "@opencode/core/session";
-import { SessionNotFoundError, UnknownError } from "@opencode/protocol/errors";
+import type { Snapshot } from "@opencode/core/snapshot";
+import { MessageNotFoundError, SessionNotFoundError, UnknownError } from "@opencode/protocol/errors";
 import { Effect } from "effect";
 export declare function missingSession(error: Session.NotFoundError): SessionNotFoundError;
+export declare function missingMessage(error: Session.MessageNotFoundError): MessageNotFoundError;
 export declare function failedMessageDecode(error: Session.MessageDecodeError): Effect.Effect<never, UnknownError, never>;
+/** Snapshot repositories are host state clients cannot repair, so surface only a log reference. */
+export declare function failedSnapshot(operation: string, sessionID: Session.ID): (error: Snapshot.Error) => Effect.Effect<never, UnknownError, never>;