@opencode/server 0.0.0-dev-19795 → 0.0.0-dev-19812

package/dist/chunks/process-kgbwhj3q.js

@@ -0,0 +1,149 @@
+import {
+  layer2
+} from "./process-8j6eh3dh.js";
+import {
+  formLocationLayer2
+} from "./process-27edjygf.js";
+import {
+  sessionLocationLayer2
+} from "./process-kb9735wh.js";
+import {
+  Api2
+} from "./process-ks9pc2xc.js";
+import {
+  Config2
+} from "./process-zyv89x5n.js";
+import {
+  CorsConfig2
+} from "./process-q4bn6dy8.js";
+import {
+  layer5
+} from "./process-18k6g42r.js";
+import {
+  node2
+} from "./process-t7k3q1ah.js";
+import {
+  handlers2
+} from "./process-tp6dn9dc.js";
+import {
+  authorizationLayer2
+} from "./process-m6wvgbfq.js";
+import {
+  schemaErrorLayer2
+} from "./process-t8yzmczr.js";
+
+// src/routes.ts
+import { Database } from "@opencode/core/database/database";
+import { V1Migration } from "@opencode/core/database/v1-migration";
+import { App } from "@opencode/core/app";
+import { LayerNode } from "@opencode/util/effect/layer-node";
+import { httpClient } from "@opencode/util/effect/app-node-platform";
+import { AppNodeBuilder } from "@opencode/core/effect/app-node-builder";
+import { Bus } from "@opencode/core/bus";
+import { EventLogger } from "@opencode/core/event-logger";
+import { FileSystemSearch } from "@opencode/core/filesystem/search";
+import { Credential } from "@opencode/core/credential";
+import { Config } from "@opencode/core/config";
+import { PermissionSaved } from "@opencode/core/permission/saved";
+import { PtyTicket } from "@opencode/core/pty/ticket";
+import { PersistentPty } from "@opencode/core/persistent-pty";
+import { Project } from "@opencode/core/project";
+import { Worktree } from "@opencode/core/worktree";
+import { Session } from "@opencode/core/session";
+import { Instance } from "@opencode/core/instance/service";
+import { SessionTransfer } from "@opencode/core/session/transfer";
+import { ShellSelect } from "@opencode/core/shell/select";
+import { Job } from "@opencode/core/job";
+import { Mcp } from "@opencode/core/mcp/index";
+import { Global } from "@opencode/util/global";
+import { InstructionDiscovery } from "@opencode/core/instruction-discovery";
+import { LocationServiceMap } from "@opencode/core/location-service-map";
+import { LocationActivity } from "@opencode/core/location-activity";
+import { ModelsDev } from "@opencode/core/models-dev";
+import { SessionRestart } from "@opencode/core/session/execution/restart";
+import { PluginUpdate } from "@opencode/core/plugin/update";
+import { SdkPlugins } from "@opencode/core/plugin/sdk";
+import { WellKnown } from "@opencode/core/wellknown";
+import { Workspace } from "@opencode/core/workspace";
+import { Watcher } from "@opencode/core/filesystem/watcher";
+import { HttpRouter } from "effect/unstable/http";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { Context, Effect, Layer, Option } from "effect";
+var applicationServiceNodes = [
+  Global.node,
+  Database.node,
+  Bus.node,
+  EventLogger.node,
+  httpClient,
+  Job.node,
+  Project.node,
+  Worktree.node,
+  Session.node,
+  Instance.node,
+  SessionTransfer.node,
+  SdkPlugins.node,
+  PluginUpdate.node,
+  PermissionSaved.node,
+  PtyTicket.node,
+  PersistentPty.node,
+  Credential.node,
+  WellKnown.node,
+  node2,
+  LocationServiceMap.node,
+  LocationActivity.node,
+  SessionRestart.node,
+  Workspace.node
+];
+var applicationServices = LayerNode.group(applicationServiceNodes);
+function createRoutes2(options = {}, serviceURLs = () => [], overrides = []) {
+  return makeRoutes(options.password ? Config2.configLayer({ password: Option.some(options.password) }) : Config2.layer, options, serviceURLs, overrides);
+}
+function createEmbeddedRoutes2(options = {}, overrides = [], instances) {
+  return makeRoutes(Config2.configLayer({ password: Option.none() }), options, () => [], overrides, instances);
+}
+function makeRoutes(auth, options, serviceURLs, overrides, instances) {
+  const standard = [
+    Database.node.replace(Database.configured(options.database)),
+    PersistentPty.node.replace(PersistentPty.configured(options.pty)),
+    Bus.node.replace(Bus.configured({ persist: options.events?.persist })),
+    App.node.replace(App.configured(options.app)),
+    ModelsDev.node.replace(ModelsDev.configured(options.models)),
+    Watcher.node.replace(Watcher.configured({ enabled: options.fs?.filewatcher })),
+    FileSystemSearch.node.replace(FileSystemSearch.configured({ fff: options.fs?.fff })),
+    Global.node.replace(Global.layerWith(options.config?.directory ? { config: options.config.directory } : {})),
+    Config.node.replace(Config.configured({
+      project: options.config?.project,
+      file: options.config?.file,
+      content: options.config?.content
+    })),
+    InstructionDiscovery.node.replace(InstructionDiscovery.configured({ project: options.config?.project })),
+    ShellSelect.node.replace(ShellSelect.configured({ gitbash: options.windows?.gitbash })),
+    Mcp.node.replace(Mcp.configured({
+      clientInfo: {
+        name: options.app?.name ?? "opencode",
+        version: options.app?.version ?? "unknown"
+      }
+    }))
+  ];
+  const build = (overrides) => {
+    const replacements = [
+      ...standard,
+      ...instances ? [Instance.node.replace(instances(() => replacements))] : [],
+      ...overrides
+    ];
+    return AppNodeBuilder.build(applicationServices, replacements);
+  };
+  const serviceLayer = options.simulation ? Layer.unwrap(Effect.gen(function* () {
+    const { simulationReplacements } = yield* Effect.promise(() => import("@opencode/simulation/backend"));
+    const simulation = yield* simulationReplacements({ version: App.make(options.app).version });
+    return build([...overrides, ...simulation]);
+  })) : build(overrides);
+  return serviceLayer.pipe(Layer.flatMap((context) => {
+    const services = Layer.succeedContext(context);
+    const requestServices = Layer.merge(Layer.succeedContext(Context.pick(Database.Service, Credential.Service, PermissionSaved.Service, PluginUpdate.Service, Project.Service, WellKnown.Service)(context)), layer5(serviceURLs, Context.get(context, Global.Service).tmp, options.app));
+    const api = HttpApiBuilder.layer(Api2, { openapiPath: "/openapi.json" }).pipe(Layer.provide(handlers2.pipe(Layer.provide(services), Layer.provide(Layer.succeed(CorsConfig2, options)))), Layer.provide(formLocationLayer2), Layer.provide(sessionLocationLayer2), Layer.provide(layer2), Layer.provide(authorizationLayer2), Layer.provide(schemaErrorLayer2), Layer.provide(auth), HttpRouter.provideRequest(requestServices), Layer.provideMerge(services), Layer.provideMerge(HttpRouter.layer));
+    return Layer.merge(api, V1Migration.layer.pipe(Layer.provide(services)));
+  }));
+}
+
+export { createRoutes2, createEmbeddedRoutes2 };

package/dist/chunks/process-kheky2r0.js

@@ -0,0 +1,35 @@
+import {
+  response2
+} from "./process-8j6eh3dh.js";
+import {
+  Api2
+} from "./process-ks9pc2xc.js";
+
+// src/handlers/shell.ts
+import { Shell } from "@opencode/core/shell";
+import { Location } from "@opencode/core/location";
+import { Effect } from "effect";
+import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi";
+import { ShellNotFoundError } from "@opencode/protocol/errors";
+var ShellHandler2 = HttpApiBuilder.group(Api2, "server.shell", (handlers) => Effect.gen(function* () {
+  return handlers.handle("shell.list", Effect.fn(function* () {
+    const shell = yield* Shell.Service;
+    return yield* response2(shell.list());
+  })).handle("shell.create", Effect.fn(function* (ctx) {
+    const shell = yield* Shell.Service;
+    const location = yield* Location.Service;
+    return yield* response2(shell.create({ ...ctx.payload, cwd: ctx.payload.cwd || location.directory }).pipe(Effect.orDie));
+  })).handle("shell.get", Effect.fn(function* (ctx) {
+    const shell = yield* Shell.Service;
+    return yield* response2(shell.get(ctx.params.id).pipe(Effect.catchTag("Shell.NotFoundError", () => new ShellNotFoundError({ id: ctx.params.id, message: `Shell command not found: ${ctx.params.id}` }))));
+  })).handle("shell.output", Effect.fn(function* (ctx) {
+    const shell = yield* Shell.Service;
+    return yield* response2(shell.output(ctx.params.id, { cursor: ctx.query.cursor, limit: ctx.query.limit }).pipe(Effect.catchTag("Shell.NotFoundError", () => new ShellNotFoundError({ id: ctx.params.id, message: `Shell command not found: ${ctx.params.id}` }))));
+  })).handle("shell.remove", Effect.fn(function* (ctx) {
+    const shell = yield* Shell.Service;
+    yield* shell.remove(ctx.params.id).pipe(Effect.catchTag("Shell.NotFoundError", () => Effect.void));
+    return HttpApiSchema.NoContent.make();
+  }));
+}));
+
+export { ShellHandler2 };

package/dist/chunks/process-knez9aqv.js

@@ -0,0 +1,13 @@
+import {
+  Api2
+} from "./process-ks9pc2xc.js";
+
+// src/handlers/migration.ts
+import { V1Migration } from "@opencode/core/database/v1-migration";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { Effect } from "effect";
+var MigrationHandler2 = HttpApiBuilder.group(Api2, "server.migration", (handlers) => handlers.handle("migration.v1.status", Effect.fn(function* () {
+  return yield* V1Migration.status();
+})));
+
+export { MigrationHandler2 };

package/dist/chunks/process-ks9pc2xc.js

@@ -0,0 +1,19 @@
+import {
+  LocationMiddleware2
+} from "./process-8j6eh3dh.js";
+import {
+  FormLocationMiddleware2
+} from "./process-27edjygf.js";
+import {
+  SessionLocationMiddleware2
+} from "./process-kb9735wh.js";
+
+// src/api.ts
+import { makeDefaultApi } from "@opencode/protocol/api";
+var Api2 = makeDefaultApi({
+  locationMiddleware: LocationMiddleware2,
+  formLocationMiddleware: FormLocationMiddleware2,
+  sessionLocationMiddleware: SessionLocationMiddleware2
+});
+
+export { Api2 };

package/dist/chunks/process-m5dqr0xs.js

@@ -0,0 +1,21 @@
+import {
+  Api2
+} from "./process-ks9pc2xc.js";
+import {
+  Service4
+} from "./process-18k6g42r.js";
+
+// src/handlers/server.ts
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+var ServerHandler2 = HttpApiBuilder.group(Api2, "server.server", (handlers) => handlers.handle("server.info", () => Effect.gen(function* () {
+  const info = yield* Service4;
+  return {
+    version: info.app.version ?? "unknown",
+    pid: process.pid ?? 0,
+    urls: info.urls(),
+    paths: info.paths
+  };
+})));
+
+export { ServerHandler2 };

package/dist/chunks/process-m6wvgbfq.js

@@ -0,0 +1,60 @@
+import {
+  Config2,
+  required2,
+  authorized2
+} from "./process-zyv89x5n.js";
+
+// src/middleware/authorization.ts
+import { UnauthorizedError } from "@opencode/protocol/errors";
+import { Authorization } from "@opencode/protocol/middleware/authorization";
+import { Authorization as Authorization2 } from "@opencode/protocol/middleware/authorization";
+import { hasPtyConnectTicketURL } from "@opencode/protocol/groups/pty";
+import { hasPersistentPtyConnectTicketURL } from "@opencode/protocol/groups/persistent-pty";
+import { Effect, Encoding, Layer, Redacted } from "effect";
+import { HttpEffect, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
+var AUTH_TOKEN_QUERY = "auth_token";
+var WWW_AUTHENTICATE = 'Basic realm="Secure Area"';
+function emptyCredential() {
+  return { username: "", password: Redacted.make("") };
+}
+function decodeCredential(input) {
+  return Effect.fromResult(Encoding.decodeBase64String(input)).pipe(Effect.match({
+    onFailure: emptyCredential,
+    onSuccess: (header) => {
+      const separator = header.indexOf(":");
+      if (separator === -1)
+        return emptyCredential();
+      return { username: header.slice(0, separator), password: Redacted.make(header.slice(separator + 1)) };
+    }
+  }));
+}
+function credentialFromRequest(request) {
+  const url = new URL(request.url, "http://localhost");
+  const token = url.searchParams.get(AUTH_TOKEN_QUERY);
+  if (token)
+    return decodeCredential(token);
+  const match = /^Basic\s+(.+)$/i.exec(request.headers.authorization ?? "");
+  if (match)
+    return decodeCredential(match[1]);
+  return Effect.succeed(emptyCredential());
+}
+function authorizedRequest2(request, config) {
+  return credentialFromRequest(request).pipe(Effect.map((credential) => authorized2(credential, config)));
+}
+var authorizationLayer2 = Layer.effect(Authorization, Effect.gen(function* () {
+  const config = yield* Config2;
+  if (!required2(config))
+    return Authorization.of((effect) => effect);
+  return Authorization.of((effect) => Effect.gen(function* () {
+    const request = yield* HttpServerRequest.HttpServerRequest;
+    const url = new URL(request.url, "http://localhost");
+    if (hasPtyConnectTicketURL(url) || hasPersistentPtyConnectTicketURL(url))
+      return yield* effect;
+    if (yield* authorizedRequest2(request, config))
+      return yield* effect;
+    yield* HttpEffect.appendPreResponseHandler((_request, response) => Effect.succeed(HttpServerResponse.setHeader(response, "www-authenticate", WWW_AUTHENTICATE)));
+    return yield* new UnauthorizedError({ message: "Authentication required" });
+  }));
+}));
+
+export { authorizedRequest2, authorizationLayer2, Authorization2 };

package/dist/chunks/process-m8y6333k.js

@@ -0,0 +1,346 @@
+import {
+  missingSession2,
+  missingMessage2,
+  failedMessageDecode2,
+  failedSnapshot2
+} from "./process-smaf4a18.js";
+import {
+  Api2
+} from "./process-ks9pc2xc.js";
+
+// src/handlers/session.ts
+import { Session } from "@opencode/core/session";
+import { SessionStats } from "@opencode/core/session/stats";
+import { SessionTitle } from "@opencode/core/session/title";
+import { SessionTransfer } from "@opencode/core/session/transfer";
+import { InstructionEntry } from "@opencode/core/session/instruction-entry";
+import { Form } from "@opencode/core/form";
+import { DateTime, Effect, Stream } from "effect";
+import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi";
+import { SessionsCursor } from "@opencode/protocol/groups/session";
+import {
+  ConflictError,
+  CommandExecutionError,
+  CommandNotFoundError,
+  FormAlreadySettledError,
+  FormInvalidAnswerError,
+  FormNotFoundError,
+  InvalidRequestError,
+  InvalidCursorError,
+  MessageNotFoundError,
+  ServiceUnavailableError,
+  SessionBusyError,
+  SkillNotFoundError
+} from "@opencode/protocol/errors";
+import { AbsolutePath } from "@opencode/core/schema";
+var DefaultSessionsLimit = 50;
+function missingForm(id) {
+  return new FormNotFoundError({ id, message: `Form not found: ${id}` });
+}
+var SessionHandler2 = HttpApiBuilder.group(Api2, "server.session", (handlers) => Effect.gen(function* () {
+  const session = yield* Session.Service;
+  const transfer = yield* SessionTransfer.Service;
+  const requireOwnedForm = Effect.fnUntraced(function* (sessionID, formID) {
+    const form = yield* Form.Service;
+    const info = yield* form.get(formID).pipe(Effect.catchTag("Form.NotFoundError", () => missingForm(formID)));
+    if (info.sessionID !== sessionID)
+      return yield* missingForm(formID);
+    return { form, info };
+  });
+  const busySession = (error) => new SessionBusyError({
+    sessionID: error.sessionID,
+    message: `Session is busy: ${error.sessionID}`
+  });
+  const pendingMutation = (effect, conflict) => effect.pipe(Effect.catchTag("Session.NotFoundError", missingSession2), Effect.catchTag("Session.InboxConflictError", (error) => new ConflictError({ resource: error.inboxID, message: `${conflict}: ${error.inboxID}` })), Effect.as(HttpApiSchema.NoContent.make()));
+  return handlers.handle("session.list", Effect.fn(function* (ctx) {
+    const query = ctx.query.cursor !== undefined ? yield* SessionsCursor.parse(ctx.query.cursor).pipe(Effect.mapError(() => new InvalidCursorError({ message: "Invalid cursor" }))) : ctx.query;
+    const page = yield* session.list({
+      ...query,
+      limit: ctx.query.limit ?? DefaultSessionsLimit
+    });
+    const sessions = page.data;
+    const first = sessions[0];
+    const last = sessions.at(-1);
+    return {
+      data: sessions,
+      cursor: {
+        previous: first ? SessionsCursor.make({
+          ...query,
+          anchor: {
+            id: first.id,
+            time: DateTime.toEpochMillis(first.time.updated),
+            direction: "previous"
+          }
+        }) : undefined,
+        next: last ? SessionsCursor.make({
+          ...query,
+          anchor: {
+            id: last.id,
+            time: DateTime.toEpochMillis(last.time.updated),
+            direction: "next"
+          }
+        }) : undefined
+      }
+    };
+  })).handle("session.stats", Effect.fn(function* (ctx) {
+    const timezone = ctx.query.timezone ?? "UTC";
+    yield* Effect.try({
+      try: () => new Intl.DateTimeFormat("en-US", { timeZone: timezone }),
+      catch: () => new InvalidRequestError({ message: `Invalid time zone: ${timezone}` })
+    });
+    return {
+      data: yield* SessionStats.get({
+        from: ctx.query.from,
+        to: ctx.query.to,
+        projectID: ctx.query.project,
+        timezone,
+        tools: ctx.query.tools
+      }).pipe(Effect.mapError(() => new InvalidRequestError({ message: "Stats range must end after it starts" })))
+    };
+  })).handle("session.create", Effect.fn(function* (ctx) {
+    return {
+      data: yield* session.create({
+        id: ctx.payload.id,
+        title: ctx.payload.title,
+        agent: ctx.payload.agent,
+        model: ctx.payload.model,
+        metadata: ctx.payload.metadata,
+        permissions: ctx.payload.permissions,
+        location: ctx.payload.location ?? { directory: AbsolutePath.make(process.cwd()) }
+      }).pipe(Effect.orDie)
+    };
+  })).handle("session.import", Effect.fn(function* (ctx) {
+    return {
+      data: yield* transfer.import({
+        data: { info: ctx.payload.info, messages: ctx.payload.messages },
+        location: ctx.payload.location ?? { directory: AbsolutePath.make(process.cwd()) }
+      }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2), Effect.catchTag("SessionTransfer.ImportConflictError", (error) => new ConflictError({
+        message: `Session already exists: ${error.sessionID}`,
+        resource: error.sessionID
+      })))
+    };
+  })).handle("session.export", Effect.fn(function* (ctx) {
+    return {
+      data: yield* transfer.export({ sessionID: ctx.params.sessionID, sanitize: ctx.query.sanitize }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2), Effect.catchTag("Session.MessageDecodeError", failedMessageDecode2))
+    };
+  })).handle("session.active", Effect.fn(function* () {
+    const active = yield* session.active;
+    return {
+      data: Object.fromEntries(Array.from(active, (sessionID) => [sessionID, { type: "running" }]))
+    };
+  })).handle("session.get", Effect.fn(function* (ctx) {
+    return {
+      data: yield* session.get(ctx.params.sessionID).pipe(Effect.catchTag("Session.NotFoundError", missingSession2))
+    };
+  })).handle("session.view", Effect.fn(function* (ctx) {
+    yield* session.view({ sessionID: ctx.params.sessionID, idle: DateTime.toEpochMillis(ctx.payload.idle) }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2));
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.remove", Effect.fn(function* (ctx) {
+    yield* session.remove(ctx.params.sessionID).pipe(Effect.catchTag("Session.NotFoundError", missingSession2));
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.environment", Effect.fn(function* (ctx) {
+    yield* session.environment({ sessionID: ctx.params.sessionID, variables: ctx.payload.variables }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2));
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.fork", Effect.fn(function* (ctx) {
+    return {
+      data: yield* session.fork({ sessionID: ctx.params.sessionID, before: ctx.payload.before }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2), Effect.catchTag("Session.MessageNotFoundError", missingMessage2), Effect.catchTag("Session.ForkEmptyError", (error) => new InvalidRequestError({ message: error.message, kind: "empty_session" })))
+    };
+  })).handle("session.switchAgent", Effect.fn(function* (ctx) {
+    yield* session.switchAgent({ sessionID: ctx.params.sessionID, agent: ctx.payload.agent }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2));
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.switchModel", Effect.fn(function* (ctx) {
+    yield* session.switchModel({ sessionID: ctx.params.sessionID, model: ctx.payload.model }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2));
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.update", Effect.fn(function* (ctx) {
+    yield* session.get(ctx.params.sessionID).pipe(Effect.catchTag("Session.NotFoundError", missingSession2));
+    if (ctx.payload.title !== undefined) {
+      if (ctx.payload.title) {
+        yield* session.rename({ sessionID: ctx.params.sessionID, title: ctx.payload.title }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2));
+      } else {
+        const title = yield* SessionTitle.Service;
+        yield* title.generate(ctx.params.sessionID);
+      }
+    }
+    if (ctx.payload.permissions !== undefined)
+      yield* session.setPermissions({ sessionID: ctx.params.sessionID, permissions: ctx.payload.permissions }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2));
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.move", Effect.fn(function* (ctx) {
+    yield* session.move({
+      sessionID: ctx.params.sessionID,
+      directory: ctx.payload.directory,
+      delivery: ctx.payload.delivery
+    }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2), Effect.catchTag("Session.DestinationNotFoundError", (error) => Effect.fail(new InvalidRequestError({ message: `Directory does not exist: ${error.directory}` }))), Effect.catchTag("Session.DestinationNotDirectoryError", (error) => Effect.fail(new InvalidRequestError({ message: `Not a directory: ${error.directory}` }))), Effect.catchTag("Session.DestinationUnavailableError", (error) => Effect.fail(new InvalidRequestError({ message: `Directory is unavailable: ${error.directory}` }))));
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.prompt", Effect.fn(function* (ctx) {
+    return {
+      data: yield* session.prompt({
+        sessionID: ctx.params.sessionID,
+        id: ctx.payload.id,
+        text: ctx.payload.text,
+        files: ctx.payload.files,
+        agents: ctx.payload.agents,
+        skills: ctx.payload.skills,
+        metadata: ctx.payload.metadata,
+        delivery: ctx.payload.delivery,
+        resume: ctx.payload.resume
+      }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2), Effect.catchTag("Session.PromptConflictError", (error) => Effect.fail(new ConflictError({
+        message: `Prompt message ID conflicts with an existing durable record: ${error.messageID}`,
+        resource: error.messageID
+      }))), Effect.catchTag("Session.AttachmentError", (error) => Effect.fail(new InvalidRequestError({ message: error.message, field: "files" }))), Effect.catchTag("Session.SkillNotFoundError", (error) => Effect.fail(new InvalidRequestError({ message: `Skill not found: ${error.skill}`, field: "skills" }))))
+    };
+  })).handle("session.command", Effect.fn(function* (ctx) {
+    yield* session.command({
+      sessionID: ctx.params.sessionID,
+      command: ctx.payload.name,
+      text: ctx.payload.text,
+      files: ctx.payload.files,
+      agents: ctx.payload.agents,
+      skills: ctx.payload.skills,
+      delivery: ctx.payload.delivery
+    }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2), Effect.catchTag("Command.NotFoundError", (error) => Effect.fail(new CommandNotFoundError({
+      command: error.command,
+      message: error.message
+    }))), Effect.catchTag("Command.ExecutionError", (error) => Effect.fail(new CommandExecutionError({
+      command: error.command,
+      message: error.message
+    }))));
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.skill", Effect.fn(function* (ctx) {
+    yield* session.skill({
+      sessionID: ctx.params.sessionID,
+      skill: ctx.payload.id,
+      resume: ctx.payload.resume
+    }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2), Effect.catchTag("Session.SkillNotFoundError", (error) => Effect.fail(new SkillNotFoundError({ skill: error.skill, message: `Skill not found: ${error.skill}` }))));
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.synthetic", Effect.fn(function* (ctx) {
+    const data = yield* session.synthetic({
+      id: ctx.payload.id,
+      sessionID: ctx.params.sessionID,
+      text: ctx.payload.text,
+      description: ctx.payload.description,
+      metadata: ctx.payload.metadata,
+      delivery: ctx.payload.delivery,
+      resume: ctx.payload.resume
+    }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2), Effect.catchTag("Session.SyntheticConflictError", (error) => Effect.fail(new ConflictError({
+      message: `Synthetic input ID conflicts with an existing durable record: ${error.inputID}`,
+      resource: error.inputID
+    }))));
+    return { data };
+  })).handle("session.shell", Effect.fn(function* (ctx) {
+    yield* session.shell({ sessionID: ctx.params.sessionID, id: ctx.payload.id, command: ctx.payload.command }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2));
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.compact", Effect.fn(function* (ctx) {
+    return {
+      data: yield* session.compact({ sessionID: ctx.params.sessionID, id: ctx.payload.id, delivery: ctx.payload.delivery }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2), Effect.catchTag("Session.CompactionConflictError", (error) => Effect.fail(new ConflictError({
+        message: `Compaction input ID conflicts with an existing durable record: ${error.inputID}`,
+        resource: error.inputID
+      }))))
+    };
+  })).handle("session.wait", Effect.fn(function* (ctx) {
+    yield* session.wait(ctx.params.sessionID).pipe(Effect.catchTag("Session.NotFoundError", missingSession2));
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.revert.stage", Effect.fn(function* (ctx) {
+    yield* Effect.log("session.revert.stage", {
+      sessionID: ctx.params.sessionID,
+      messageID: ctx.payload.messageID,
+      files: ctx.payload.files
+    });
+    return {
+      data: yield* session.revert.stage({ ...ctx.params, ...ctx.payload }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2), Effect.catchTag("Session.MessageNotFoundError", missingMessage2), Effect.catchTag("Session.BusyError", busySession), Effect.catchTag("Snapshot.Error", failedSnapshot2("stage session revert", ctx.params.sessionID)))
+    };
+  })).handle("session.revert.clear", Effect.fn(function* (ctx) {
+    yield* Effect.log("session.revert.clear", { sessionID: ctx.params.sessionID });
+    yield* session.revert.clear(ctx.params.sessionID).pipe(Effect.catchTag("Session.NotFoundError", missingSession2), Effect.catchTag("Session.BusyError", busySession), Effect.catchTag("Snapshot.Error", failedSnapshot2("clear session revert", ctx.params.sessionID)));
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.revert.commit", Effect.fn(function* (ctx) {
+    yield* Effect.log("session.revert.commit", { sessionID: ctx.params.sessionID });
+    yield* session.revert.commit(ctx.params.sessionID).pipe(Effect.catchTag("Session.NotFoundError", missingSession2), Effect.catchTag("Session.BusyError", busySession));
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.context", Effect.fn(function* (ctx) {
+    return {
+      data: yield* session.context(ctx.params.sessionID).pipe(Effect.catchTag("Session.NotFoundError", missingSession2), Effect.catchTag("Session.MessageDecodeError", failedMessageDecode2))
+    };
+  })).handle("session.diff", Effect.fn(function* (ctx) {
+    return {
+      data: yield* session.diff({ sessionID: ctx.params.sessionID, ...ctx.query }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2), Effect.catchTag("Session.MessageNotFoundError", missingMessage2), Effect.catchTag("Session.TurnRangeError", (error) => new InvalidRequestError({ message: error.message, field: error.field })), Effect.catchTag("Snapshot.Error", failedSnapshot2("diff session turn", ctx.params.sessionID)))
+    };
+  })).handle("session.inbox.list", Effect.fn(function* (ctx) {
+    return {
+      data: yield* session.inbox(ctx.params.sessionID).pipe(Effect.catchTag("Session.NotFoundError", missingSession2))
+    };
+  })).handle("session.inbox.cancel", Effect.fn(function* (ctx) {
+    yield* session.cancelInbox({ sessionID: ctx.params.sessionID, inboxID: ctx.params.inboxID }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2), Effect.catchTag("Session.InboxConflictError", () => Effect.void));
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.inbox.update", Effect.fn(function* (ctx) {
+    return yield* pendingMutation(ctx.payload.delivery === "steer" ? session.steerInbox({ sessionID: ctx.params.sessionID, inboxID: ctx.params.inboxID }) : session.queueInbox({ sessionID: ctx.params.sessionID, inboxID: ctx.params.inboxID }), `Pending input cannot change to ${ctx.payload.delivery}`);
+  })).handle("session.instructions.entry.list", Effect.fn(function* (ctx) {
+    const instructions = yield* InstructionEntry.Service;
+    return { data: yield* instructions.list(ctx.params.sessionID) };
+  })).handle("session.instructions.entry.put", Effect.fn(function* (ctx) {
+    const instructions = yield* InstructionEntry.Service;
+    yield* instructions.put({ sessionID: ctx.params.sessionID, key: ctx.params.key, value: ctx.payload.value });
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.instructions.entry.remove", Effect.fn(function* (ctx) {
+    const instructions = yield* InstructionEntry.Service;
+    yield* instructions.remove({ sessionID: ctx.params.sessionID, key: ctx.params.key });
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.generate", Effect.fn(function* (ctx) {
+    const text = yield* session.generate({ sessionID: ctx.params.sessionID, prompt: ctx.payload.prompt }).pipe(Effect.mapError((error) => error._tag === "Session.NotFoundError" ? missingSession2(error) : new ServiceUnavailableError({ message: error.message, service: "session generation" })));
+    return { data: { text } };
+  })).handle("session.log", Effect.fn(function* (ctx) {
+    yield* session.get(ctx.params.sessionID).pipe(Effect.catchTag("Session.NotFoundError", missingSession2));
+    return session.log({ sessionID: ctx.params.sessionID, after: ctx.query.after, follow: ctx.query.follow }).pipe(Stream.orDie);
+  })).handle("session.interrupt", Effect.fn(function* (ctx) {
+    return { interrupted: yield* session.interrupt(ctx.params.sessionID, { resume: ctx.query.resume }) };
+  })).handle("session.background", Effect.fn(function* (ctx) {
+    yield* session.background(ctx.params.sessionID).pipe(Effect.catchTag("Session.NotFoundError", missingSession2));
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.message", Effect.fn(function* (ctx) {
+    yield* session.get(ctx.params.sessionID).pipe(Effect.catchTag("Session.NotFoundError", missingSession2));
+    const message = yield* session.message(ctx.params);
+    if (message)
+      return { data: message };
+    return yield* new MessageNotFoundError({
+      sessionID: ctx.params.sessionID,
+      messageID: ctx.params.messageID,
+      message: `Message not found: ${ctx.params.messageID}`
+    });
+  })).handle("session.form.list", Effect.fn(function* (ctx) {
+    const form = yield* Form.Service;
+    return { data: yield* form.list({ sessionID: ctx.params.sessionID }) };
+  })).handle("session.form.create", Effect.fn(function* (ctx) {
+    const form = yield* Form.Service;
+    const created = yield* form.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" })
+    }));
+    return { data: created };
+  })).handle("session.form.get", Effect.fn(function* (ctx) {
+    const owned = yield* requireOwnedForm(ctx.params.sessionID, ctx.params.formID);
+    const state = yield* owned.form.state(ctx.params.formID).pipe(Effect.catchTag("Form.NotFoundError", () => missingForm(ctx.params.formID)));
+    return { data: { ...owned.info, state } };
+  })).handle("session.form.reply", Effect.fn(function* (ctx) {
+    const owned = yield* requireOwnedForm(ctx.params.sessionID, ctx.params.formID);
+    yield* owned.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) {
+    const owned = yield* requireOwnedForm(ctx.params.sessionID, ctx.params.formID);
+    yield* owned.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();
+  }));
+}));
+
+export { SessionHandler2 };