@opencode/sdk 2.0.8 → 2.0.9

package/dist/chunks/tool-39225h8g.js

@@ -0,0 +1,23 @@
+import {
+  __export
+} from "./tool-9rqn6x4v.js";
+
+// src/internal/workerd.ts
+var exports_workerd = {};
+__export(exports_workerd, {
+  WorkerdProfile: () => exports_workerd,
+  make: () => make2
+});
+import { ServerWorkerd } from "@opencode/server/workerd";
+function make2({ config, ...options }) {
+  const server = {
+    ...options,
+    config: config === undefined ? undefined : { content: JSON.stringify(config) }
+  };
+  return {
+    options: ServerWorkerd.serverOptions(server),
+    replacements: ServerWorkerd.replacements(server)
+  };
+}
+
+export { make2, exports_workerd };

package/dist/chunks/tool-9rqn6x4v.js

@@ -0,0 +1,16 @@
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+export { __export };

package/dist/chunks/tool-b54z5jwe.js

@@ -0,0 +1,54 @@
+import {
+  layer4,
+  context2
+} from "./tool-ya9awdj2.js";
+import {
+  make3
+} from "./tool-wyq33nd6.js";
+import {
+  provide2,
+  node2
+} from "./tool-pqb0kjhx.js";
+import {
+  __export
+} from "./tool-9rqn6x4v.js";
+
+// src/internal/host.ts
+var exports_host = {};
+__export(exports_host, {
+  EmbeddedHost: () => exports_host,
+  create: () => create5
+});
+import { SdkPlugins } from "@opencode/core/plugin/sdk";
+import { SessionRestart } from "@opencode/core/session/execution/restart";
+import { Session } from "@opencode/core/session";
+import { Workspace } from "@opencode/core/workspace";
+import { WorkspaceDriver } from "@opencode/core/workspace/driver";
+import { createEmbeddedRoutes } from "@opencode/server/routes";
+import { Context, Effect, Layer, ManagedRuntime } from "effect";
+import { HttpEffect, HttpRouter, HttpServer } from "effect/unstable/http";
+var create5 = Effect.fn("EmbeddedHost.create")(function* (options = {}, embed = {}) {
+  const { log, workspaceProviders, instances, ...server } = options;
+  const selector = instances ? provide2(instances, yield* Effect.context()) : undefined;
+  const 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) => node2(selector, replacements) : undefined).pipe(Layer.provide(HttpServer.layerServices), Layer.provideMerge(layer4(log))));
+  return yield* Effect.gen(function* () {
+    const services = yield* runtime.contextEffect;
+    runtime.runFork(Context.get(services, SessionRestart.Service).resumeSuspendedSessions);
+    const handler = HttpEffect.toWebHandlerWith(context2(services))(Context.get(services, HttpRouter.HttpRouter).asHttpEffect());
+    const transport = make3(handler, runtime.dispose);
+    return {
+      runtime,
+      fetch: transport.fetch,
+      plugins: Context.get(services, SdkPlugins.Service),
+      sessions: Context.get(services, Session.Service),
+      workspace: Context.get(services, Workspace.Service),
+      close: transport.close
+    };
+  }).pipe(Effect.onError(() => runtime.disposeEffect));
+});
+
+export { create5, exports_host };

package/dist/chunks/tool-hdqq71na.js

@@ -0,0 +1,14 @@
+import {
+  __export
+} from "./tool-9rqn6x4v.js";
+
+// src/tool.ts
+var exports_tool2 = {};
+__export(exports_tool2, {
+  Error: () => Error3,
+  RegistrationError: () => RegistrationError3
+});
+import { RegistrationError as RegistrationError3 } from "@opencode/core/tool";
+import { Error as Error3 } from "@opencode/schema/tool";
+
+export { exports_tool2, RegistrationError3, Error3 };

package/dist/chunks/tool-j1jhtwv7.js

@@ -0,0 +1,29 @@
+// src/contracts.ts
+import { Agent as Agent2 } from "@opencode/schema/agent";
+import { Command as Command2 } from "@opencode/schema/command";
+import { Config as Config2 } from "@opencode/schema/config";
+import { Credential as Credential2 } from "@opencode/schema/credential";
+import { Event as Event2 } from "@opencode/schema/event";
+import { FileSystem as FileSystem2 } from "@opencode/schema/filesystem";
+import { Integration as Integration2 } from "@opencode/schema/integration";
+import { Location as Location2 } from "@opencode/schema/location";
+import { Model as Model2 } from "@opencode/schema/model";
+import { Permission as Permission2 } from "@opencode/schema/permission";
+import { PermissionSaved as PermissionSaved2 } from "@opencode/schema/permission-saved";
+import { Project as Project2 } from "@opencode/schema/project";
+import { Worktree as Worktree2 } from "@opencode/schema/worktree";
+import { Prompt as Prompt2 } from "@opencode/schema/prompt";
+import { PromptInput as PromptInput2 } from "@opencode/schema/prompt-input";
+import { Provider as Provider2 } from "@opencode/schema/provider";
+import { Pty as Pty2 } from "@opencode/schema/pty";
+import { Question as Question2 } from "@opencode/schema/question";
+import { Reference as Reference2 } from "@opencode/schema/reference";
+import { WebSearch as WebSearch2 } from "@opencode/schema/websearch";
+import { AbsolutePath as AbsolutePath2, RelativePath as RelativePath2 } from "@opencode/schema/schema";
+import { Session as Session2 } from "@opencode/schema/session";
+import { SessionInbox as SessionInbox2 } from "@opencode/schema/session-inbox";
+import { SessionMessage as SessionMessage2 } from "@opencode/schema/session-message";
+import { Skill as Skill2 } from "@opencode/schema/skill";
+import { Workspace as Workspace2 } from "@opencode/schema/workspace";
+
+export { Agent2, Command2, Config2, Credential2, Event2, FileSystem2, Integration2, Location2, Model2, Permission2, PermissionSaved2, Project2, Worktree2, Prompt2, PromptInput2, Provider2, Pty2, Question2, Reference2, WebSearch2, AbsolutePath2, RelativePath2, Session2, SessionInbox2, SessionMessage2, Skill2, Workspace2 };

package/dist/chunks/tool-j34yx374.js

@@ -0,0 +1,15 @@
+import {
+  create4
+} from "./tool-kp70gr0x.js";
+import {
+  __export
+} from "./tool-9rqn6x4v.js";
+
+// src/opencode.ts
+var exports_opencode2 = {};
+__export(exports_opencode2, {
+  create: () => create3
+});
+var create3 = (options = {}) => create4(options);
+
+export { create3, exports_opencode2 };

package/dist/chunks/tool-kp70gr0x.js

@@ -0,0 +1,47 @@
+import {
+  create5
+} from "./tool-b54z5jwe.js";
+import {
+  __export
+} from "./tool-9rqn6x4v.js";
+
+// src/promise.ts
+var exports_promise = {};
+__export(exports_promise, {
+  PromiseSdk: () => exports_promise,
+  create: () => create4
+});
+import { OpenCode } from "@opencode/client";
+import { Session } from "@opencode/schema/session";
+import { Effect, Schema } from "effect";
+async function create4(options = {}, embed = {}) {
+  const { plugins, instances, ...hostOptions } = options;
+  const host = await Effect.runPromise(create5({
+    ...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"));
+        const configuration = yield* Effect.tryPromise(async () => instances.configure(key));
+        return { plugins: configuration.plugins.map(PluginPromise.fromPromise) };
+      })
+    } : undefined
+  }, embed));
+  const client = OpenCode.make({ baseUrl: "http://opencode.local", fetch: host.fetch });
+  const 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
+  };
+}
+
+export { create4, exports_promise };

package/dist/chunks/tool-n1hprnh9.js

@@ -0,0 +1,14 @@
+import {
+  __export
+} from "./tool-9rqn6x4v.js";
+
+// src/effect/tool.ts
+var exports_tool = {};
+__export(exports_tool, {
+  Error: () => Error2,
+  RegistrationError: () => RegistrationError2
+});
+import { RegistrationError as RegistrationError2 } from "@opencode/core/tool";
+import { Error as Error2 } from "@opencode/schema/tool";
+
+export { exports_tool, RegistrationError2, Error2 };

package/dist/chunks/tool-pqb0kjhx.js

@@ -0,0 +1,62 @@
+import {
+  __export
+} from "./tool-9rqn6x4v.js";
+
+// src/internal/instances.ts
+var exports_instances = {};
+__export(exports_instances, {
+  SdkInstances: () => exports_instances,
+  layer: () => layer3,
+  node: () => node2,
+  provide: () => provide2
+});
+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 } from "effect";
+function provide2(options, context) {
+  return {
+    key: options.key,
+    configure: (key) => options.configure(key).pipe(Effect.updateContext((ambient) => Context.merge(context, ambient)))
+  };
+}
+function node2(options, replacements) {
+  return makeGlobalNode({
+    service: Instance.Service,
+    layer: layer3(options, replacements),
+    deps: [LocationServiceMap.node]
+  });
+}
+function layer3(options, replacements) {
+  return Layer.effect(Instance.Service, Effect.gen(function* () {
+    const scope = yield* Effect.scope;
+    const locations = yield* LocationServiceMap.Service;
+    const key = (session) => ({
+      key: options.key(session),
+      ...LocationServiceMap.canonical(session.location)
+    });
+    const provide = (session) => Effect.provide(instances.get(key(session)));
+    const 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(new 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: true }), Effect.asVoid))), { idleTimeToLive: Duration.infinity });
+    return Instance.Service.of({ provide });
+  }));
+}
+
+export { provide2, node2, layer3, exports_instances };

package/dist/chunks/tool-wyq33nd6.js

@@ -0,0 +1,125 @@
+import {
+  __export
+} from "./tool-9rqn6x4v.js";
+
+// src/internal/fetch.ts
+var exports_fetch = {};
+__export(exports_fetch, {
+  OwnedFetch: () => exports_fetch,
+  make: () => make3
+});
+function make3(handler, dispose) {
+  const requests = new Set;
+  const shutdown = new AbortController;
+  const closed = new Error("OpenCode host is closed");
+  let closePromise;
+  const 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]) });
+    const lifetime = Promise.withResolvers();
+    const 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;
+  } });
+  const close = () => {
+    if (closePromise)
+      return closePromise;
+    closePromise = Promise.resolve().then(async () => {
+      shutdown.abort(closed);
+      await Promise.allSettled(requests);
+      await dispose();
+    });
+    return closePromise;
+  };
+  return { fetch, close };
+}
+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: true });
+    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 = false;
+  let abort = () => {};
+  const complete = () => {
+    if (done)
+      return false;
+    done = true;
+    signal.removeEventListener("abort", abort);
+    return true;
+  };
+  const 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: true });
+    },
+    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);
+}
+
+export { make3, exports_fetch };

package/dist/chunks/tool-xcejgzf0.js

@@ -0,0 +1,45 @@
+import {
+  create5
+} from "./tool-b54z5jwe.js";
+import {
+  __export
+} from "./tool-9rqn6x4v.js";
+
+// src/effect/opencode.ts
+var exports_opencode = {};
+__export(exports_opencode, {
+  OpenCode: () => exports_opencode,
+  Service: () => Service2,
+  create: () => create2,
+  layer: () => layer2
+});
+import { OpenCode } from "@opencode/client/effect";
+import { Context, Effect, Layer } from "effect";
+import { FetchHttpClient, HttpClient } from "effect/unstable/http";
+var create2 = Effect.fn("OpenCode.create")(function* (options = {}, embed = {}) {
+  const host = yield* Effect.acquireRelease(create5(options, embed), (host) => Effect.promise(host.close));
+  const httpClient = yield* HttpClient.HttpClient.pipe(Effect.provide(FetchHttpClient.layer));
+  const 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,
+      create: host.sessions.create,
+      get: (input) => host.sessions.get(input.sessionID),
+      move: host.sessions.move
+    },
+    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)
+  };
+});
+
+class Service2 extends Context.Service()("@opencode/sdk/OpenCode") {
+}
+var layer2 = (options = {}) => Layer.effect(Service2, create2(options));
+
+export { create2, Service2, layer2, exports_opencode };

package/dist/chunks/tool-ya9awdj2.js

@@ -0,0 +1,55 @@
+// src/logging.ts
+import { Context, Formatter, Layer, Logger, References } from "effect";
+var levels = {
+  trace: "Trace",
+  debug: "Debug",
+  info: "Info",
+  warn: "Warn",
+  error: "Error",
+  fatal: "Fatal"
+};
+var 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);
+}
+function layer4(log) {
+  const logger = Logger.make((options) => {
+    if (!log)
+      return;
+    const level = normalizeLevel(options.logLevel);
+    if (!level)
+      return;
+    const entry = Logger.formatStructured.log(options);
+    const values = Array.isArray(entry.message) ? entry.message : [entry.message];
+    const [message, ...data] = values;
+    const details = data.length === 1 && !Array.isArray(data[0]) ? data[0] : undefined;
+    const { cause: detailCause, ...detailAttributes } = details ?? {};
+    const 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 === undefined && detailCause === undefined ? {} : { cause: entry.cause ?? detailCause }
+      });
+    } catch {}
+  });
+  return Layer.merge(Logger.layer([logger], { mergeWithExisting: false }), Layer.succeed(References.MinimumLogLevel, levels[log?.level ?? "info"]));
+}
+function context2(source) {
+  return Context.make(Logger.CurrentLoggers, Context.get(source, Logger.CurrentLoggers)).pipe(Context.add(References.MinimumLogLevel, Context.get(source, References.MinimumLogLevel)));
+}
+
+export { layer4, context2 };

package/dist/contracts.js

@@ -1,26 +1,58 @@
-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";
+import {
+  Agent2,
+  Command2,
+  Config2,
+  Credential2,
+  Event2,
+  FileSystem2,
+  Integration2,
+  Location2,
+  Model2,
+  Permission2,
+  PermissionSaved2,
+  Project2,
+  Worktree2,
+  Prompt2,
+  PromptInput2,
+  Provider2,
+  Pty2,
+  Question2,
+  Reference2,
+  WebSearch2,
+  AbsolutePath2,
+  RelativePath2,
+  Session2,
+  SessionInbox2,
+  SessionMessage2,
+  Skill2,
+  Workspace2
+} from "./chunks/tool-j1jhtwv7.js";
+export {
+  AbsolutePath2 as AbsolutePath,
+  Agent2 as Agent,
+  Command2 as Command,
+  Config2 as Config,
+  Credential2 as Credential,
+  Event2 as Event,
+  FileSystem2 as FileSystem,
+  Integration2 as Integration,
+  Location2 as Location,
+  Model2 as Model,
+  Permission2 as Permission,
+  PermissionSaved2 as PermissionSaved,
+  Project2 as Project,
+  Prompt2 as Prompt,
+  PromptInput2 as PromptInput,
+  Provider2 as Provider,
+  Pty2 as Pty,
+  Question2 as Question,
+  Reference2 as Reference,
+  RelativePath2 as RelativePath,
+  Session2 as Session,
+  SessionInbox2 as SessionInbox,
+  SessionMessage2 as SessionMessage,
+  Skill2 as Skill,
+  WebSearch2 as WebSearch,
+  Workspace2 as Workspace,
+  Worktree2 as Worktree
+};

package/dist/effect/index.js

@@ -1,4 +1,74 @@
-export * as OpenCode from "./opencode";
-export * as Tool from "./tool";
-export { ClientError } from "@opencode/client/effect";
-export * from "../contracts";
+import"../chunks/tool-ya9awdj2.js";
+import"../chunks/tool-wyq33nd6.js";
+import"../chunks/tool-pqb0kjhx.js";
+import"../chunks/tool-b54z5jwe.js";
+import {
+  exports_opencode
+} from "../chunks/tool-xcejgzf0.js";
+import {
+  exports_tool
+} from "../chunks/tool-n1hprnh9.js";
+import {
+  Agent2,
+  Command2,
+  Config2,
+  Credential2,
+  Event2,
+  FileSystem2,
+  Integration2,
+  Location2,
+  Model2,
+  Permission2,
+  PermissionSaved2,
+  Project2,
+  Worktree2,
+  Prompt2,
+  PromptInput2,
+  Provider2,
+  Pty2,
+  Question2,
+  Reference2,
+  WebSearch2,
+  AbsolutePath2,
+  RelativePath2,
+  Session2,
+  SessionInbox2,
+  SessionMessage2,
+  Skill2,
+  Workspace2
+} from "../chunks/tool-j1jhtwv7.js";
+
+// src/effect/index.ts
+import { ClientError } from "@opencode/client/effect";
+export {
+  AbsolutePath2 as AbsolutePath,
+  Agent2 as Agent,
+  ClientError,
+  Command2 as Command,
+  Config2 as Config,
+  Credential2 as Credential,
+  Event2 as Event,
+  FileSystem2 as FileSystem,
+  Integration2 as Integration,
+  Location2 as Location,
+  Model2 as Model,
+  exports_opencode as OpenCode,
+  Permission2 as Permission,
+  PermissionSaved2 as PermissionSaved,
+  Project2 as Project,
+  Prompt2 as Prompt,
+  PromptInput2 as PromptInput,
+  Provider2 as Provider,
+  Pty2 as Pty,
+  Question2 as Question,
+  Reference2 as Reference,
+  RelativePath2 as RelativePath,
+  Session2 as Session,
+  SessionInbox2 as SessionInbox,
+  SessionMessage2 as SessionMessage,
+  Skill2 as Skill,
+  exports_tool as Tool,
+  WebSearch2 as WebSearch,
+  Workspace2 as Workspace,
+  Worktree2 as Worktree
+};