@opencode/sdk 0.0.0-reserved → 2.0.0

package/README.md

@@ -1,5 +1,143 @@
 # @opencode/sdk
 
-Bootstrap placeholder for the official [OpenCode](https://opencode.ai) release pipeline.
+In-process OpenCode host for Promise and Effect applications. The SDK executes Server's assembled HTTP router in memory, opening no listener and adding no network hop.
 
-This version contains no implementation or executable. Do not use it as a functional release.
+```ts
+import { OpenCode } from "@opencode/sdk"
+
+await using opencode = await OpenCode.create()
+const session = await opencode.sessions.create({
+  location: { directory: "/workspace" },
+})
+```
+
+Pass imported Promise plugins in `plugins`, or register one later with `await opencode.plugin(plugin)`.
+
+The Promise API uses the same values, errors, request options, and `AsyncIterable` streams as `@opencode/client`.
+
+Embedded hosts are silent by default. Set `log` to receive structured log entries:
+
+```ts
+await using opencode = await OpenCode.create({
+  log: {
+    level: "warn",
+    emit: (entry) => console.error(entry.message, entry.attributes, entry.cause),
+  },
+})
+```
+
+`close()` and `Symbol.asyncDispose` release router resources, Location services, fibers, and scoped plugin registrations.
+
+## Session-Selected Plugins
+
+Use `instances` when Sessions in the same directory need different application plugins. The application selects a stable key from Session metadata; the SDK constructs and caches an instance for that key and the Session's current Location.
+
+```ts
+import { OpenCode } from "@opencode/sdk"
+import { threads } from "./threads"
+import { slackPlugin } from "./slack-plugin"
+
+await using opencode = await OpenCode.create({
+  database: { path: "./sessions.db" },
+  instances: {
+    key(session) {
+      const threadID = session.metadata?.threadID
+      if (typeof threadID !== "string") throw new Error("Session has no thread ID")
+      return threadID
+    },
+    configure: async (threadID) => ({
+      plugins: [slackPlugin(await threads.get(threadID))],
+    }),
+  },
+})
+
+const session = await opencode.sessions.create({
+  location: { directory: "/workspace" },
+  metadata: { threadID: "thread-42" },
+})
+await opencode.sessions.prompt({ sessionID: session.id, text: "Review the changes" })
+```
+
+`threads` and `slackPlugin` are application-owned modules. `key` is synchronous and should only select identity, not initialize plugins. `configure` returns plugin definitions; their setup receives the selected instance's `ctx.location`.
+
+- The same key and Location share one live instance. Different directories or workspace IDs always select separate instances, even with the same application key.
+- `configure` runs on a cache miss, not on each prompt. Loaded instances live until the host closes; change the application key or restart the host to reconstruct their birth configuration. Plugin transforms and reloads remain available within that lifetime.
+- Session metadata, message, inbox, and context reads do not initialize plugins; permission and form lists read instance services and therefore acquire the Session's instance. Configuration failure or a supplied plugin reported as failed after activation, including initial setup failure or an ID that collides with a host `plugins` entry (the host plugin keeps the ID), prevents capability acquisition, without falling back to another instance. A subsequent request can retry a failed construction.
+- Existing HTTP prompt middleware also acquires capabilities for an idempotent retry. After restart, that retry can reconstruct plugins before returning the original admission; prompt preparation and hooks do not rerun. Configuration failure can therefore block the retry even when its input was already saved.
+- Instance selection is not an authorization or storage-isolation boundary. Plugin Session APIs and the existing plugin-ID-based durable storage retain their normal scope.
+- Omitting `instances` preserves default Location sharing. Host-wide plugins remain separate from Session-selected configuration; retain host-wide catalog policy when locationless generation needs it.
+
+### Restart and Lifetime
+
+The selector is installed before automatic recovery starts. Its callbacks must be able to load application data without depending on the returned `opencode` handle or a later registration call. Functions are reconstructed, not serialized.
+
+Use a persistent `database.path` to recover Sessions after restart; the default database is in memory. Workerd uses its injected Durable Object storage. After restart, the next capability-dependent operation or recovery drain rebuilds the selected instance from saved Session metadata and application data.
+
+Promise plugin resources should be acquired in `setup` and released by its cleanup function. Effect configuration can acquire resources in its supplied instance Scope and require services provided to the SDK entrypoint (see the Effect section).
+
+## Workerd
+
+Use the Workerd entrypoint inside a Cloudflare Durable Object. Hold one host for the lifetime of the object instance rather than creating one per request.
+
+```ts
+import { OpenCodeWorkerd } from "@opencode/sdk/workerd"
+import myPlugin from "./my-plugin"
+
+export class OpenCodeDO {
+  private readonly opencode: Promise<OpenCodeWorkerd.Interface>
+
+  constructor(state: DurableObjectState) {
+    this.opencode = state.blockConcurrencyWhile(() =>
+      OpenCodeWorkerd.create({
+        storage: state.storage,
+        config: { default_agent: "build" },
+        plugins: [myPlugin],
+      }),
+    )
+  }
+
+  async fetch() {
+    const opencode = await this.opencode
+    return Response.json(await opencode.health.get())
+  }
+}
+```
+
+`blockConcurrencyWhile` keeps every Durable Object event out until the host is ready and resets the object if initialization fails. The retained Promise gives request handlers direct access to the same host after startup. Configuration is a typed JavaScript object, and plugins are imported values bundled with the Worker.
+
+## Effect
+
+The Effect-native API remains available from `@opencode/sdk/effect`:
+
+```ts
+import { OpenCode } from "@opencode/sdk/effect"
+
+const opencode = yield * OpenCode.create()
+const session = yield * opencode.sessions.get({ sessionID })
+```
+
+The Effect Workerd entrypoint is `@opencode/sdk/workerd/effect`.
+
+Effect configuration uses the same keys and lifetime rules, with canonical `Session.Info` values and an Effect-returning factory. `configure` may require services; `OpenCode.create` and `OpenCode.layer` carry those requirements, so the application satisfies them where it builds the SDK, as with any other Effect callback:
+
+```ts
+import { OpenCode } from "@opencode/sdk/effect"
+import { Effect, Layer, Schema } from "effect"
+import { Threads } from "./threads-effect"
+import { slackPlugin } from "./slack-plugin-effect"
+
+const threadMetadata = Schema.decodeUnknownSync(Schema.Struct({ threadID: Schema.String }))
+const opencode = OpenCode.layer({
+  database: { path: "./sessions.db" },
+  instances: {
+    key: (session) => threadMetadata(session.metadata).threadID,
+    configure: (threadID) =>
+      Effect.gen(function* () {
+        const threads = yield* Threads
+        return { plugins: [slackPlugin(yield* threads.get(threadID))] }
+      }),
+  },
+}).pipe(Layer.provide(Threads.layer))
+```
+
+Resources acquired in `configure` still belong to the instance, not to the Scope the SDK was built in. Both Workerd entrypoints also accept `instances`. The public `OpenCode.InstanceOptions` and `OpenCode.InstanceConfiguration` types describe the corresponding Promise or Effect callbacks.

package/dist/contracts.d.ts

@@ -0,0 +1,26 @@
+export { Agent } from "@opencode/schema/agent";
+export { Command } from "@opencode/schema/command";
+export { Config } from "@opencode/schema/config";
+export { Credential } from "@opencode/schema/credential";
+export { Event } from "@opencode/schema/event";
+export { FileSystem } from "@opencode/schema/filesystem";
+export { Integration } from "@opencode/schema/integration";
+export { Location } from "@opencode/schema/location";
+export { Model } from "@opencode/schema/model";
+export { Permission } from "@opencode/schema/permission";
+export { PermissionSaved } from "@opencode/schema/permission-saved";
+export { Project } from "@opencode/schema/project";
+export { Worktree } from "@opencode/schema/worktree";
+export { Prompt } from "@opencode/schema/prompt";
+export { PromptInput } from "@opencode/schema/prompt-input";
+export { Provider } from "@opencode/schema/provider";
+export { Pty } from "@opencode/schema/pty";
+export { Question } from "@opencode/schema/question";
+export { Reference } from "@opencode/schema/reference";
+export { WebSearch } from "@opencode/schema/websearch";
+export { AbsolutePath, RelativePath } from "@opencode/schema/schema";
+export { Session } from "@opencode/schema/session";
+export { SessionInbox } from "@opencode/schema/session-inbox";
+export { SessionMessage } from "@opencode/schema/session-message";
+export { Skill } from "@opencode/schema/skill";
+export { Workspace } from "@opencode/schema/workspace";

package/dist/contracts.js

@@ -0,0 +1,26 @@
+export { Agent } from "@opencode/schema/agent";
+export { Command } from "@opencode/schema/command";
+export { Config } from "@opencode/schema/config";
+export { Credential } from "@opencode/schema/credential";
+export { Event } from "@opencode/schema/event";
+export { FileSystem } from "@opencode/schema/filesystem";
+export { Integration } from "@opencode/schema/integration";
+export { Location } from "@opencode/schema/location";
+export { Model } from "@opencode/schema/model";
+export { Permission } from "@opencode/schema/permission";
+export { PermissionSaved } from "@opencode/schema/permission-saved";
+export { Project } from "@opencode/schema/project";
+export { Worktree } from "@opencode/schema/worktree";
+export { Prompt } from "@opencode/schema/prompt";
+export { PromptInput } from "@opencode/schema/prompt-input";
+export { Provider } from "@opencode/schema/provider";
+export { Pty } from "@opencode/schema/pty";
+export { Question } from "@opencode/schema/question";
+export { Reference } from "@opencode/schema/reference";
+export { WebSearch } from "@opencode/schema/websearch";
+export { AbsolutePath, RelativePath } from "@opencode/schema/schema";
+export { Session } from "@opencode/schema/session";
+export { SessionInbox } from "@opencode/schema/session-inbox";
+export { SessionMessage } from "@opencode/schema/session-message";
+export { Skill } from "@opencode/schema/skill";
+export { Workspace } from "@opencode/schema/workspace";

package/dist/effect/index.d.ts

@@ -0,0 +1,5 @@
+export * as OpenCode from "./opencode";
+export * as Tool from "./tool";
+export { ClientError } from "@opencode/client/effect";
+export type { OpenCodeEvent } from "@opencode/client/effect";
+export * from "../contracts";

package/dist/effect/index.js

@@ -0,0 +1,4 @@
+export * as OpenCode from "./opencode";
+export * as Tool from "./tool";
+export { ClientError } from "@opencode/client/effect";
+export * from "../contracts";

package/dist/effect/opencode.d.ts

@@ -0,0 +1,31 @@
+export * as OpenCode from "./opencode";
+import { type OpenCodeClient } from "@opencode/client/effect";
+import type { Workspace } from "@opencode/core/workspace";
+import { Context, Effect, Layer } from "effect";
+import type { Config, Scope } from "effect";
+import { EmbeddedHost } from "../internal/host";
+import type { SdkInstances } from "../internal/instances";
+export type { LogEntry, LogLevel, LogOptions, LogWriter } from "../logging";
+export type CreateOptions<R = never> = EmbeddedHost.CreateOptions<R>;
+export type EmbedOptions = EmbeddedHost.EmbedOptions;
+export type InstanceOptions<R = never> = SdkInstances.Options<R>;
+export type InstanceConfiguration = SdkInstances.Configuration;
+export type Interface = Omit<OpenCodeClient, "plugin" | "workspace"> & {
+    readonly sessions: OpenCodeClient["session"];
+    readonly events: OpenCodeClient["event"];
+    readonly workspace: {
+        readonly create: Workspace.Interface["create"];
+        readonly provision: (options: {
+            readonly workspaceID: Workspace.ID;
+        }) => ReturnType<Workspace.Interface["provision"]>;
+        readonly destroy: (options: {
+            readonly workspaceID: Workspace.ID;
+        }) => ReturnType<Workspace.Interface["destroy"]>;
+    };
+    readonly plugin: EmbeddedHost.Interface["plugins"]["register"] & OpenCodeClient["plugin"];
+};
+export declare const create: <R = never>(options?: CreateOptions<R>, embed?: EmbedOptions) => Effect.Effect<Interface, Config.ConfigError | Error, Scope.Scope | R>;
+declare const Service_base: Context.ServiceClass<Service, "@opencode/sdk/OpenCode", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: <R = never>(options?: CreateOptions<R>) => Layer.Layer<Service, Config.ConfigError | Error, Exclude<R, Scope.Scope>>;

package/dist/effect/opencode.js

@@ -0,0 +1,23 @@
+export * as OpenCode from "./opencode";
+import { OpenCode } from "@opencode/client/effect";
+import { Context, Effect, Layer } from "effect";
+import { FetchHttpClient, HttpClient } from "effect/unstable/http";
+import { EmbeddedHost } from "../internal/host";
+export const create = Effect.fn("OpenCode.create")(function* (options = {}, embed = {}) {
+  const host = yield* Effect.acquireRelease(EmbeddedHost.create(options, embed), (host) => Effect.promise(host.close)), httpClient = yield* HttpClient.HttpClient.pipe(Effect.provide(FetchHttpClient.layer)), client = yield* OpenCode.make({ baseUrl: "http://opencode.local" }).pipe(Effect.provideService(HttpClient.HttpClient, HttpClient.transformResponse(httpClient, Effect.provideService(FetchHttpClient.Fetch, host.fetch))));
+  return {
+    ...client,
+    sessions: client.session,
+    events: client.event,
+    workspace: {
+      create: host.workspace.create,
+      provision: ({ workspaceID }) => host.workspace.provision(workspaceID),
+      destroy: ({ workspaceID }) => host.workspace.destroy(workspaceID)
+    },
+    plugin: Object.assign(host.plugins.register, client.plugin)
+  };
+});
+
+export class Service extends Context.Service()("@opencode/sdk/OpenCode") {
+}
+export const layer = (options = {}) => Layer.effect(Service, create(options));

package/dist/effect/tool.d.ts

@@ -0,0 +1,3 @@
+export { RegistrationError } from "@opencode/core/tool";
+export { Error } from "@opencode/schema/tool";
+export type { Context, Info } from "@opencode/schema/tool";

package/dist/effect/tool.js

@@ -0,0 +1,2 @@
+export { RegistrationError } from "@opencode/core/tool";
+export { Error } from "@opencode/schema/tool";

package/dist/effect/workerd.d.ts

@@ -0,0 +1,15 @@
+export * as OpenCodeWorkerd from "./workerd";
+import { Layer } from "effect";
+import type { Config, Scope } from "effect";
+import { WorkerdProfile } from "../internal/workerd";
+import { OpenCode } from "./opencode";
+export type Configuration = WorkerdProfile.Configuration;
+export interface CreateOptions<R = never> extends WorkerdProfile.Options {
+    readonly log?: OpenCode.CreateOptions["log"];
+    readonly workspaceProviders?: OpenCode.CreateOptions["workspaceProviders"];
+    readonly instances?: OpenCode.CreateOptions<R>["instances"];
+}
+export declare const create: <R = never>({ log, workspaceProviders, instances, ...options }: CreateOptions<R>) => import("effect/Effect").Effect<OpenCode.Interface, Error | Config.ConfigError, Scope.Scope | R>;
+export declare const layer: <R = never>(options: CreateOptions<R>) => Layer.Layer<OpenCode.Service, Config.ConfigError | Error, Exclude<R, Scope.Scope>>;
+export type Interface = OpenCode.Interface;
+export type Requirements = Scope.Scope;

package/dist/effect/workerd.js

@@ -0,0 +1,8 @@
+export * as OpenCodeWorkerd from "./workerd";
+import { Layer } from "effect";
+import { WorkerdProfile } from "../internal/workerd";
+import { OpenCode } from "./opencode";
+export const create = ({ log, workspaceProviders, instances, ...options }) => {
+  const profile = WorkerdProfile.make(options);
+  return OpenCode.create({ ...profile.options, log, workspaceProviders, instances }, { overrides: profile.replacements });
+}, layer = (options) => Layer.effect(OpenCode.Service, create(options));

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * as OpenCode from "./opencode";
+export * as Tool from "./tool";
+export { ClientError } from "@opencode/client";
+export type { OpenCodeEvent } from "@opencode/client";
+export * from "./contracts";

package/dist/index.js

@@ -0,0 +1,4 @@
+export * as OpenCode from "./opencode";
+export * as Tool from "./tool";
+export { ClientError } from "@opencode/client";
+export * from "./contracts";

package/dist/internal/fetch.d.ts

@@ -0,0 +1,7 @@
+export * as OwnedFetch from "./fetch";
+export declare function make(handler: (request: Request) => Promise<Response>, dispose: () => Promise<void>): {
+    fetch: ((input: RequestInfo | URL, init?: RequestInit) => Promise<Response>) & {
+        preconnect: () => undefined;
+    };
+    close: () => Promise<void>;
+};

package/dist/internal/fetch.js

@@ -0,0 +1,106 @@
+export * as OwnedFetch from "./fetch";
+export function make(handler, dispose) {
+  const requests = new Set, shutdown = new AbortController, closed = Error("OpenCode host is closed");
+  let closePromise;
+  return { fetch: Object.assign((input, init) => {
+    if (closePromise)
+      return Promise.reject(closed);
+    const source = new Request(input, init);
+    if (source.signal.aborted)
+      return Promise.reject(source.signal.reason);
+    const request = new Request(source, { signal: AbortSignal.any([source.signal, shutdown.signal]) }), lifetime = Promise.withResolvers(), finish = () => {
+      requests.delete(lifetime.promise);
+      lifetime.resolve();
+    };
+    requests.add(lifetime.promise);
+    const handled = handler(request);
+    return rejectOnAbort(handled, request.signal).then((response) => trackResponse(response, request.signal, finish), (cause) => {
+      handled.then(finish, finish);
+      throw cause;
+    });
+  }, { preconnect: () => {
+    return;
+  } }), close: () => {
+    if (closePromise)
+      return closePromise;
+    closePromise = Promise.resolve().then(async () => {
+      shutdown.abort(closed);
+      await Promise.allSettled(requests);
+      await dispose();
+    });
+    return closePromise;
+  } };
+}
+function rejectOnAbort(promise, signal) {
+  if (signal.aborted)
+    return Promise.reject(signal.reason);
+  return new Promise((resolve, reject) => {
+    const abort = () => reject(signal.reason);
+    signal.addEventListener("abort", abort, { once: !0 });
+    promise.then((value) => {
+      signal.removeEventListener("abort", abort);
+      resolve(value);
+    }, (cause) => {
+      signal.removeEventListener("abort", abort);
+      reject(cause);
+    });
+  });
+}
+function trackResponse(response, signal, finish) {
+  if (!response.body) {
+    finish();
+    return response;
+  }
+  const reader = response.body.getReader();
+  let done = !1, abort = () => {};
+  const complete = () => {
+    if (done)
+      return !1;
+    done = !0;
+    signal.removeEventListener("abort", abort);
+    return !0;
+  }, body = new ReadableStream({
+    start(controller) {
+      abort = () => {
+        if (!complete())
+          return;
+        controller.error(signal.reason);
+        reader.cancel(signal.reason).then(finish, finish);
+      };
+      if (signal.aborted)
+        abort();
+      else
+        signal.addEventListener("abort", abort, { once: !0 });
+    },
+    async pull(controller) {
+      try {
+        const next = await reader.read();
+        if (done)
+          return;
+        if (!next.done) {
+          controller.enqueue(next.value);
+          return;
+        }
+        if (!complete())
+          return;
+        controller.close();
+        finish();
+      } catch (cause) {
+        if (!complete())
+          return;
+        controller.error(cause);
+        finish();
+      }
+    },
+    async cancel(reason) {
+      if (!complete())
+        return;
+      try {
+        await reader.cancel(reason);
+      } finally {
+        finish();
+      }
+    }
+  });
+  return new Response(body, response);
+}

package/dist/internal/host.d.ts

@@ -0,0 +1,30 @@
+export * as EmbeddedHost from "./host";
+import { SdkPlugins } from "@opencode/core/plugin/sdk";
+import { SessionRestart } from "@opencode/core/session/execution/restart";
+import { Workspace } from "@opencode/core/workspace";
+import { WorkspaceDriver } from "@opencode/core/workspace/driver";
+import type { ServerOptions } from "@opencode/server/options";
+import type { LayerNode } from "@opencode/util/effect/layer-node";
+import { Effect, ManagedRuntime } from "effect";
+import { HttpRouter } from "effect/unstable/http";
+import { type LogOptions } from "../logging";
+import { SdkInstances } from "./instances";
+export interface CreateOptions<R = never> extends Omit<ServerOptions, "hostname" | "port" | "password"> {
+    readonly log?: LogOptions;
+    readonly workspaceProviders?: Readonly<Record<string, WorkspaceDriver.Interface>>;
+    readonly instances?: SdkInstances.Options<R>;
+}
+/** Host hooks for embedding opencode on a non-default runtime profile. */
+export interface EmbedOptions {
+    readonly overrides?: LayerNode.Replacements;
+}
+export declare const create: <R = never>(options?: CreateOptions<R> | undefined, embed?: EmbedOptions | undefined) => Effect.Effect<{
+    runtime: ManagedRuntime.ManagedRuntime<import("effect/unstable/http/HttpClient").HttpClient | import("@opencode/util/global").Service | import("@opencode/core/database/database").Service | import("@opencode/core/project").Service | import("@opencode/core/bus").Service | import("@opencode/core/persistent-pty/index").Service | import("@opencode/core/credential").Service | import("@opencode/core/wellknown").Service | Workspace.Service | import("@opencode/core/permission/saved").Service | SdkPlugins.Service | import("@opencode/core/plugin/update").Service | import("@opencode/core/session").Service | import("@opencode/core/job").Service | import("@opencode/core/instance").Service | import("@opencode/core/location-service-map").Service | SessionRestart.Service | import("@opencode/core/pty/ticket").Service | import("@opencode/core/session/transfer").Service | import("@opencode/core/location-activity").Service | import("@opencode/server/pty-environment").Service | HttpRouter.HttpRouter, Error | import("@opencode/core/persistent-pty/index").UnavailableError>;
+    fetch: ((input: RequestInfo | URL, init?: RequestInit) => Promise<Response>) & {
+        preconnect: () => undefined;
+    };
+    plugins: SdkPlugins.Interface;
+    workspace: Workspace.Interface;
+    close: () => Promise<void>;
+}, Error, R>;
+export type Interface = Effect.Success<ReturnType<typeof create>>;

package/dist/internal/host.js

@@ -0,0 +1,30 @@
+export * as EmbeddedHost from "./host";
+import { SdkPlugins } from "@opencode/core/plugin/sdk";
+import { SessionRestart } from "@opencode/core/session/execution/restart";
+import { Workspace } from "@opencode/core/workspace";
+import { WorkspaceDriver } from "@opencode/core/workspace/driver";
+import { createEmbeddedRoutes } from "@opencode/server/routes";
+import { Context, Effect, Layer, ManagedRuntime, Scope } from "effect";
+import { HttpEffect, HttpRouter, HttpServer, HttpServerRequest } from "effect/unstable/http";
+import { context, layer } from "../logging";
+import { OwnedFetch } from "./fetch";
+import { SdkInstances } from "./instances";
+export const create = Effect.fn("EmbeddedHost.create")(function* (options = {}, embed = {}) {
+  const { log, workspaceProviders, instances, ...server } = options, selector = instances ? SdkInstances.provide(instances, yield* Effect.context()) : void 0, runtime = ManagedRuntime.make(createEmbeddedRoutes({
+    ...server,
+    app: { ...server.app, name: server.app?.name ?? "sdk" },
+    database: { path: ":memory:", ...server.database }
+  }, workspaceProviders ? [...embed.overrides ?? [], WorkspaceDriver.node.replace(WorkspaceDriver.registryNode(workspaceProviders))] : embed.overrides, selector ? (replacements) => SdkInstances.node(selector, replacements) : void 0).pipe(Layer.provide(HttpServer.layerServices), Layer.provideMerge(layer(log))));
+  return yield* Effect.gen(function* () {
+    const services = yield* runtime.contextEffect;
+    runtime.runFork(Context.get(services, SessionRestart.Service).resumeSuspendedSessions);
+    const handler = HttpEffect.toWebHandlerWith(context(services))(Context.get(services, HttpRouter.HttpRouter).asHttpEffect()), transport = OwnedFetch.make(handler, runtime.dispose);
+    return {
+      runtime,
+      fetch: transport.fetch,
+      plugins: Context.get(services, SdkPlugins.Service),
+      workspace: Context.get(services, Workspace.Service),
+      close: transport.close
+    };
+  }).pipe(Effect.onError(() => runtime.disposeEffect));
+});

package/dist/internal/instances.d.ts

@@ -0,0 +1,24 @@
+export * as SdkInstances from "./instances";
+import { Instance } from "@opencode/core/instance";
+import { LocationServiceMap } from "@opencode/core/location-service-map";
+import type { InstancePlugins } from "@opencode/core/plugin/instance";
+import type { Session } from "@opencode/schema/session";
+import type { LayerNode } from "@opencode/util/effect/layer-node";
+import { Context, Effect, Layer, Scope } from "effect";
+export interface Configuration {
+    readonly plugins: InstancePlugins.List;
+}
+export interface Options<R = never> {
+    /** Select a sharing key within the Session's current Location. Must not initialize plugins. */
+    readonly key: (session: Session.Info) => string;
+    /**
+     * Reconstruct configuration on a cache miss. Resources belong to the instance Scope; other requirements
+     * are the services the SDK entrypoint was built with.
+     */
+    readonly configure: (key: string) => Effect.Effect<Configuration, unknown, R | Scope.Scope>;
+}
+/** Closes `configure` over services captured where the SDK entrypoint was built; the host graph has none of its own. */
+export declare function provide<R>(options: Options<R>, context: Context.Context<R>): Options;
+/** Replaces the host's `Instance.node`; `replacements` resolves lazily so instances inherit the final host graph. */
+export declare function node(options: Options, replacements: () => LayerNode.Replacements): LayerNode.Provider<Instance.Service, never, LayerNode.Tag<"global">>;
+export declare function layer(options: Options, replacements: () => LayerNode.Replacements): Layer.Layer<Instance.Service, never, LocationServiceMap.Service>;

package/dist/internal/instances.js

@@ -0,0 +1,45 @@
+export * as SdkInstances from "./instances";
+import { Instance } from "@opencode/core/instance";
+import { LocationServiceMap } from "@opencode/core/location-service-map";
+import { Plugin } from "@opencode/core/plugin";
+import { Location } from "@opencode/schema/location";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+import { Context, Duration, Effect, Layer, LayerMap, Scope } from "effect";
+export function provide(options, context) {
+  return {
+    key: options.key,
+    configure: (key) => options.configure(key).pipe(Effect.updateContext((ambient) => Context.merge(context, ambient)))
+  };
+}
+export function node(options, replacements) {
+  return makeGlobalNode({
+    service: Instance.Service,
+    layer: layer(options, replacements),
+    deps: [LocationServiceMap.node]
+  });
+}
+export function layer(options, replacements) {
+  return Layer.effect(Instance.Service, Effect.gen(function* () {
+    const scope = yield* Effect.scope, locations = yield* LocationServiceMap.Service, key = (session) => ({
+      key: options.key(session),
+      ...LocationServiceMap.canonical(session.location)
+    }), provide = (session) => Effect.provide(instances.get(key(session))), instances = yield* LayerMap.make((input) => Layer.unwrap(Effect.gen(function* () {
+      const configuration = yield* options.configure(input.key).pipe(Effect.orDie);
+      return Instance.layer(Location.Ref.make({ directory: input.directory, workspaceID: input.workspaceID }), {
+        plugins: configuration.plugins,
+        replacements: [
+          ...replacements(),
+          Instance.node.replace(Layer.succeed(Instance.Service, { provide })),
+          LocationServiceMap.node.replace(Layer.succeed(LocationServiceMap.Service, locations))
+        ]
+      }).pipe(Layer.tap((context) => Effect.gen(function* () {
+        const plugins = yield* Plugin.Service;
+        yield* plugins.awaitActivation;
+        const failed = (yield* plugins.list()).filter((plugin) => plugin.state.status === "failed" && configuration.plugins.some((configured) => configured.id === plugin.id));
+        if (failed.length > 0)
+          yield* Effect.die(Error(`Instance plugin setup failed: ${failed.map((plugin) => plugin.id).join(", ")}`));
+      }).pipe(Effect.provide(context))));
+    })).pipe(Layer.tapCause(() => instances.invalidate(input).pipe(Effect.forkIn(scope, { startImmediately: !0 }), Effect.asVoid))), { idleTimeToLive: Duration.infinity });
+    return Instance.Service.of({ provide });
+  }));
+}

package/dist/internal/workerd.d.ts

@@ -0,0 +1,55 @@
+export * as WorkerdProfile from "./workerd";
+import type { Config } from "@opencode/schema/config";
+import { ServerWorkerd } from "@opencode/server/workerd";
+export type Configuration = Omit<typeof Config.Info.Encoded, "plugins">;
+export interface Options extends Omit<ServerWorkerd.Options, "password" | "config"> {
+    readonly config?: Configuration;
+}
+export declare function make({ config, ...options }: Options): {
+    options: {
+        readonly models?: {
+            readonly url?: string | undefined;
+            readonly file?: string | undefined;
+            readonly snapshot?: boolean | undefined;
+            readonly fetch?: boolean | undefined;
+        } | undefined;
+        readonly pty?: {
+            readonly handoff?: {
+                readonly directory: string;
+                readonly instanceID: string;
+                readonly ticket: string;
+                readonly expiresAt: number;
+            } | undefined;
+        } | undefined;
+        readonly config?: {
+            readonly directory?: string | undefined;
+            readonly project?: boolean | undefined;
+            readonly content?: string | undefined;
+            readonly file?: string | undefined;
+        } | undefined;
+        readonly events?: {
+            readonly persist?: boolean | undefined;
+        } | undefined;
+        readonly port?: number | undefined;
+        readonly hostname?: string | undefined;
+        readonly cors?: readonly string[] | undefined;
+        readonly windows?: {
+            readonly gitbash?: string | undefined;
+        } | undefined;
+        readonly password?: string | undefined;
+        readonly app?: {
+            readonly version?: string | undefined;
+            readonly name?: string | undefined;
+            readonly channel?: string | undefined;
+        } | undefined;
+        readonly fs?: {
+            readonly fff?: boolean | undefined;
+            readonly filewatcher?: boolean | undefined;
+        } | undefined;
+        readonly simulation?: boolean | undefined;
+        readonly database?: {
+            readonly path?: string | undefined;
+        } | undefined;
+    };
+    replacements: import("@opencode/util/effect/layer-node").Replacements;
+};

package/dist/internal/workerd.js

@@ -0,0 +1,12 @@
+export * as WorkerdProfile from "./workerd";
+import { ServerWorkerd } from "@opencode/server/workerd";
+export function make({ config, ...options }) {
+  const server = {
+    ...options,
+    config: config === void 0 ? void 0 : { content: JSON.stringify(config) }
+  };
+  return {
+    options: ServerWorkerd.serverOptions(server),
+    replacements: ServerWorkerd.replacements(server)
+  };
+}

package/dist/logging.d.ts

@@ -0,0 +1,15 @@
+import { Context, Layer } from "effect";
+export type LogLevel = "trace" | "debug" | "info" | "warn" | "error" | "fatal";
+export type LogEntry = {
+    readonly level: LogLevel;
+    readonly message: string;
+    readonly attributes?: Readonly<Record<string, unknown>>;
+    readonly cause?: unknown;
+};
+export type LogWriter = (entry: LogEntry) => void;
+export type LogOptions = {
+    readonly level?: LogLevel;
+    readonly emit: LogWriter;
+};
+export declare function layer(log?: LogOptions): Layer.Layer<never, never, never>;
+export declare function context(source: Context.Context<never>): Context.Context<never>;

package/dist/logging.js

@@ -0,0 +1,46 @@
+import { Context, Formatter, Layer, Logger, References } from "effect";
+const levels = {
+  trace: "Trace",
+  debug: "Debug",
+  info: "Info",
+  warn: "Warn",
+  error: "Error",
+  fatal: "Fatal"
+}, levelNames = new Map([
+  [levels.trace, "trace"],
+  [levels.debug, "debug"],
+  [levels.info, "info"],
+  [levels.warn, "warn"],
+  [levels.error, "error"],
+  [levels.fatal, "fatal"]
+]);
+function normalizeLevel(level) {
+  return levelNames.get(level);
+}
+export function layer(log) {
+  const logger = Logger.make((options) => {
+    if (!log)
+      return;
+    const level = normalizeLevel(options.logLevel);
+    if (!level)
+      return;
+    const entry = Logger.formatStructured.log(options), values = Array.isArray(entry.message) ? entry.message : [entry.message], [message, ...data] = values, details = data.length === 1 && !Array.isArray(data[0]) ? data[0] : void 0, { cause: detailCause, ...detailAttributes } = details ?? {}, attributes = {
+      ...entry.annotations,
+      ...detailAttributes,
+      ...Object.keys(entry.spans).length > 0 ? { spans: entry.spans } : {},
+      ...!details && data.length > 0 ? { data: data.length === 1 ? data[0] : data } : {}
+    };
+    try {
+      log.emit({
+        level,
+        message: typeof message === "string" ? message : Formatter.format(message),
+        ...Object.keys(attributes).length > 0 ? { attributes } : {},
+        ...entry.cause === void 0 && detailCause === void 0 ? {} : { cause: entry.cause ?? detailCause }
+      });
+    } catch {}
+  });
+  return Layer.merge(Logger.layer([logger], { mergeWithExisting: !1 }), Layer.succeed(References.MinimumLogLevel, levels[log?.level ?? "info"]));
+}
+export function context(source) {
+  return Context.make(Logger.CurrentLoggers, Context.get(source, Logger.CurrentLoggers)).pipe(Context.add(References.MinimumLogLevel, Context.get(source, References.MinimumLogLevel)));
+}

package/dist/opencode.d.ts

@@ -0,0 +1,7 @@
+import { PromiseSdk } from "./promise";
+export type { LogEntry, LogLevel, LogOptions, LogWriter } from "./logging";
+export type CreateOptions = PromiseSdk.CreateOptions;
+export type InstanceOptions = PromiseSdk.InstanceOptions;
+export type InstanceConfiguration = PromiseSdk.InstanceConfiguration;
+export type Interface = PromiseSdk.Interface;
+export declare const create: (options?: CreateOptions) => Promise<PromiseSdk.Interface>;

package/dist/opencode.js

@@ -0,0 +1,2 @@
+import { PromiseSdk } from "./promise";
+export const create = (options = {}) => PromiseSdk.create(options);

package/dist/promise.d.ts

@@ -0,0 +1,26 @@
+export * as PromiseSdk from "./promise";
+import { type OpenCodeClient } from "@opencode/client";
+import type { Plugin } from "@opencode/plugin";
+import { Session } from "@opencode/schema/session";
+import { EmbeddedHost } from "./internal/host";
+export interface InstanceConfiguration {
+    readonly plugins: ReadonlyArray<Plugin.Plugin>;
+}
+export interface InstanceOptions {
+    /** Select a sharing key within the Session's current Location. Must not initialize plugins. */
+    readonly key: (session: typeof Session.Info.Encoded) => string;
+    /** Reconstruct configuration on a cache miss, including after a host restart. */
+    readonly configure: (key: string) => InstanceConfiguration | Promise<InstanceConfiguration>;
+}
+export interface CreateOptions extends Omit<EmbeddedHost.CreateOptions, "workspaceProviders" | "instances"> {
+    readonly plugins?: ReadonlyArray<Plugin.Plugin>;
+    readonly instances?: InstanceOptions;
+}
+export type Interface = Omit<OpenCodeClient, "plugin"> & {
+    readonly sessions: OpenCodeClient["session"];
+    readonly events: OpenCodeClient["event"];
+    readonly plugin: ((plugin: Plugin.Plugin) => Promise<void>) & OpenCodeClient["plugin"];
+    readonly close: () => Promise<void>;
+    readonly [Symbol.asyncDispose]: () => Promise<void>;
+};
+export declare function create(options?: CreateOptions, embed?: EmbeddedHost.EmbedOptions): Promise<Interface>;

package/dist/promise.js

@@ -0,0 +1,30 @@
+export * as PromiseSdk from "./promise";
+import { OpenCode } from "@opencode/client";
+import { Session } from "@opencode/schema/session";
+import { Effect, Schema } from "effect";
+import { EmbeddedHost } from "./internal/host";
+export async function create(options = {}, embed = {}) {
+  const { plugins, instances, ...hostOptions } = options, host = await Effect.runPromise(EmbeddedHost.create({
+    ...hostOptions,
+    instances: instances ? {
+      key: (session) => instances.key(Schema.encodeSync(Session.Info)(session)),
+      configure: (key) => Effect.gen(function* () {
+        const { PluginPromise } = yield* Effect.promise(() => import("@opencode/core/plugin/promise"));
+        return { plugins: (yield* Effect.tryPromise(async () => instances.configure(key))).plugins.map(PluginPromise.fromPromise) };
+      })
+    } : void 0
+  }, embed)), client = OpenCode.make({ baseUrl: "http://opencode.local", fetch: host.fetch }), register = async (plugin) => {
+    const { PluginPromise } = await import("@opencode/core/plugin/promise");
+    return host.runtime.runPromise(host.plugins.register(PluginPromise.fromPromise(plugin)));
+  };
+  for (const plugin of plugins ?? [])
+    await register(plugin);
+  return {
+    ...client,
+    sessions: client.session,
+    events: client.event,
+    plugin: Object.assign(register, client.plugin),
+    close: host.close,
+    [Symbol.asyncDispose]: host.close
+  };
+}

package/dist/tool.d.ts

@@ -0,0 +1,3 @@
+export { RegistrationError } from "@opencode/core/tool";
+export { Error } from "@opencode/schema/tool";
+export type { ToolContext as Context, Info } from "@opencode/plugin/promise/tool";

package/dist/tool.js

@@ -0,0 +1,2 @@
+export { RegistrationError } from "@opencode/core/tool";
+export { Error } from "@opencode/schema/tool";

package/dist/workerd.d.ts

@@ -0,0 +1,26 @@
+export * as OpenCodeWorkerd from "./workerd";
+import { WorkerdProfile } from "./internal/workerd";
+import type { LogOptions } from "./logging";
+import { PromiseSdk } from "./promise";
+export type Configuration = WorkerdProfile.Configuration;
+export interface CreateOptions extends WorkerdProfile.Options {
+    readonly log?: LogOptions;
+    readonly plugins?: PromiseSdk.CreateOptions["plugins"];
+    readonly instances?: PromiseSdk.CreateOptions["instances"];
+}
+/**
+ * Boots the embedded opencode SDK on the workerd runtime profile: the full
+ * application graph inside a Cloudflare Durable Object, with the database on
+ * the injected `DurableObjectStorage` SQLite and every intentionally-local
+ * service replaced or disabled (see `ServerWorkerd.replacements`).
+ *
+ * Suspended Sessions resume on boot (as on every runtime) because a Durable
+ * Object can be evicted mid-turn with no teardown; the write-ahead execution
+ * claim marks the turn and the boot-time sweep replays it.
+ *
+ * Returns the same typed `OpenCode.Interface` as `OpenCode.create` — typed
+ * session operations plus the live `events.subscribe()` stream — served over
+ * an in-process fetch transport, so no request leaves the isolate.
+ */
+export declare const create: ({ log, plugins, instances, ...options }: CreateOptions) => Promise<PromiseSdk.Interface>;
+export type Interface = PromiseSdk.Interface;

package/dist/workerd.js

@@ -0,0 +1,7 @@
+export * as OpenCodeWorkerd from "./workerd";
+import { WorkerdProfile } from "./internal/workerd";
+import { PromiseSdk } from "./promise";
+export const create = ({ log, plugins, instances, ...options }) => {
+  const profile = WorkerdProfile.make(options);
+  return PromiseSdk.create({ ...profile.options, log, plugins, instances }, { overrides: profile.replacements });
+};

package/package.json

@@ -1,15 +1,59 @@
 {
+  "$schema": "https://json.schemastore.org/package.json",
+  "version": "2.0.0",
   "name": "@opencode/sdk",
-  "version": "0.0.0-reserved",
-  "description": "OpenCode package bootstrap — not a functional release",
+  "type": "module",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/anomalyco/opencode.git"
+    "url": "git+https://github.com/anomalyco/opencode.git",
+    "directory": "packages/sdk"
   },
   "publishConfig": {
-    "registry": "https://registry.npmjs.org",
-    "access": "public",
-    "tag": "reserved"
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./effect": {
+      "import": "./dist/effect/index.js",
+      "types": "./dist/effect/index.d.ts"
+    },
+    "./workerd": {
+      "import": "./dist/workerd.js",
+      "types": "./dist/workerd.d.ts"
+    },
+    "./workerd/effect": {
+      "import": "./dist/effect/workerd.js",
+      "types": "./dist/effect/workerd.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "bun run script/build.ts",
+    "test": "bun test --timeout 5000",
+    "typecheck": "tsgo -b",
+    "verify:package": "bun run script/verify-package.ts"
+  },
+  "dependencies": {
+    "@opencode/client": "2.0.0",
+    "@opencode/core": "2.0.0",
+    "@opencode/plugin": "2.0.0",
+    "@opencode/schema": "2.0.0",
+    "@opencode/server": "2.0.0",
+    "@opencode/util": "2.0.0",
+    "effect": "4.0.0-rc.112"
+  },
+  "devDependencies": {
+    "@opencode/ai": "2.0.0",
+    "@opencode/httpapi-codegen": "2.0.0",
+    "@opencode/protocol": "2.0.0",
+    "@tsconfig/bun": "1.0.9",
+    "@types/bun": "1.4.0",
+    "@typescript/native-preview": "7.0.0-dev.20251207.1"
   }
 }