@opencode/core 0.0.0-reserved → 2.0.0

package/dist/chunks/aisdk-native-5t3nmthw.js

@@ -0,0 +1,32 @@
+import {
+  WebSocketConstructor2
+} from "./aisdk-native-y8cydn3q.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/effect/app-node-platform.ts
+var exports_app_node_platform = {};
+__export(exports_app_node_platform, {
+  LayerNodePlatform: () => exports_app_node_platform,
+  llmClient: () => llmClient2,
+  requestExecutor: () => requestExecutor2,
+  webSocketConstructor: () => webSocketConstructor2
+});
+import { LLMClient, RequestExecutor } from "@opencode/ai/route";
+import { Socket } from "effect/unstable/socket";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+import { httpClient } from "@opencode/util/effect/app-node-platform";
+var requestExecutor2 = makeGlobalNode({
+  service: RequestExecutor.Service,
+  layer: RequestExecutor.layer,
+  deps: [httpClient]
+});
+var llmClient2 = makeGlobalNode({ service: LLMClient.Service, layer: LLMClient.layer, deps: [requestExecutor2] });
+var webSocketConstructor2 = makeGlobalNode({
+  service: Socket.WebSocketConstructor,
+  layer: WebSocketConstructor2.layer,
+  deps: []
+});
+
+export { requestExecutor2, llmClient2, webSocketConstructor2, exports_app_node_platform };

package/dist/chunks/aisdk-native-607tc6va.js

@@ -0,0 +1,16 @@
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/v1/config/plugin.ts
+var exports_plugin3 = {};
+__export(exports_plugin3, {
+  ConfigPluginV1: () => exports_plugin3,
+  Options: () => Options5,
+  Spec: () => Spec2
+});
+import { Schema } from "effect";
+var Options5 = Schema.Record(Schema.String, Schema.Unknown);
+var Spec2 = Schema.Union([Schema.String, Schema.mutable(Schema.Tuple([Schema.String, Options5]))]);
+
+export { Options5, Spec2, exports_plugin3 };

package/dist/chunks/aisdk-native-62zc03d1.js

@@ -0,0 +1,608 @@
+import {
+  Metadata2,
+  node56
+} from "./aisdk-native-cjg4xdhd.js";
+import {
+  Service79,
+  node84
+} from "./aisdk-native-11nvngjf.js";
+import {
+  ID9,
+  Service62,
+  node66
+} from "./aisdk-native-x0v86zgp.js";
+import {
+  ID18
+} from "./aisdk-native-33n3bzdy.js";
+import {
+  Service76,
+  node81
+} from "./aisdk-native-qjwa214h.js";
+import {
+  ID13
+} from "./aisdk-native-jghsd1wz.js";
+import {
+  ID12,
+  OAuth3
+} from "./aisdk-native-111hscse.js";
+import {
+  ID11,
+  MethodID2,
+  AttemptID2,
+  Method2,
+  Service66,
+  node70
+} from "./aisdk-native-tpbhnsa4.js";
+import {
+  Service65,
+  node69
+} from "./aisdk-native-r4kwqy5f.js";
+import {
+  Service54,
+  node58
+} from "./aisdk-native-ackkwfcq.js";
+import {
+  Service58,
+  node62
+} from "./aisdk-native-1xqm2dzv.js";
+import {
+  AbsolutePath2
+} from "./aisdk-native-922hggd3.js";
+import {
+  Info30,
+  Ref4,
+  Service73,
+  node78
+} from "./aisdk-native-6fyvx278.js";
+import {
+  Service43,
+  node46
+} from "./aisdk-native-nhqh66qs.js";
+import {
+  ID15
+} from "./aisdk-native-8a24hghq.js";
+import {
+  Service31,
+  node35
+} from "./aisdk-native-es98n7aa.js";
+import {
+  Service63,
+  node67
+} from "./aisdk-native-ra3qct3x.js";
+import {
+  Service59,
+  node63
+} from "./aisdk-native-h05a6ep0.js";
+import {
+  Service34,
+  node38
+} from "./aisdk-native-g27wjat6.js";
+import {
+  Source3,
+  Service44,
+  node47
+} from "./aisdk-native-xmvvg8ty.js";
+import {
+  Info18,
+  Service50,
+  node53
+} from "./aisdk-native-rd6pz67j.js";
+import {
+  Service19,
+  node23
+} from "./aisdk-native-rqysayyh.js";
+import {
+  Service77,
+  node82
+} from "./aisdk-native-9vfhq93a.js";
+import {
+  Service45,
+  node48
+} from "./aisdk-native-2se0afp6.js";
+import {
+  Service69,
+  node73
+} from "./aisdk-native-cxvbe4d1.js";
+import {
+  ID6,
+  Service56,
+  node60
+} from "./aisdk-native-76xfeaks.js";
+import {
+  StrategyID2,
+  Info17,
+  ListEntry3,
+  UnsupportedLocationError2,
+  Service49,
+  node52
+} from "./aisdk-native-9z45pttg.js";
+import {
+  Service37,
+  node41
+} from "./aisdk-native-hf4q8sgp.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/plugin/host.ts
+var exports_host = {};
+__export(exports_host, {
+  PluginHost: () => exports_host,
+  make: () => make11,
+  requirements: () => requirements3,
+  storage: () => storage2
+});
+import { EventManifest } from "@opencode/schema/event-manifest";
+import { ServerConfig } from "@opencode/schema/mcp";
+import { Effect, Schema, Stream } from "effect";
+import { LayerNode } from "@opencode/util/effect/layer-node";
+var mutable = (value) => value;
+var isRpcEvent = (event) => event.type.startsWith("rpc.");
+var make11 = Effect.fn("PluginHost.make")(function* (plugin, pluginID = "test") {
+  const app = yield* Metadata2;
+  const agents = yield* Service62;
+  const aisdk = yield* Service76;
+  const catalog = yield* Service65;
+  const commands = yield* Service54;
+  const bus = yield* Service79;
+  const integration = yield* Service66;
+  const kv = yield* Service58;
+  const mcp = yield* Service31;
+  const location = yield* Service73;
+  const reference = yield* Service44;
+  const rpc = yield* Service45;
+  const skill = yield* Service50;
+  const tools = yield* Service34;
+  const vcs = yield* Service69;
+  const websearch = yield* Service56;
+  const generate = yield* Service37;
+  const permission = yield* Service59;
+  const hooks = yield* Service63;
+  const sessions = yield* Service19;
+  const persistentPty = yield* Service77;
+  const locations = yield* Service43;
+  const worktrees = yield* Service49;
+  const locationInfo = () => new Info30({
+    directory: location.directory,
+    workspaceID: location.workspaceID,
+    project: location.project
+  });
+  const locationRef = (input) => input?.location === undefined ? undefined : Ref4.make({
+    directory: AbsolutePath2.make(input.location.directory ?? location.directory),
+    workspaceID: input.location.workspace === undefined ? location.workspaceID : ID15.make(input.location.workspace)
+  });
+  const isCurrentLocation = (ref) => ref.directory === location.directory && ref.workspaceID === location.workspaceID;
+  const response = (effect) => effect.pipe(Effect.map((data) => ({ location: locationInfo(), data })));
+  const atWorktree = (ref, run) => {
+    if (ref?.workspaceID)
+      return Effect.fail(new UnsupportedLocationError2({ directory: ref.directory }));
+    if (!ref || isCurrentLocation(ref))
+      return run(worktrees);
+    return Effect.gen(function* () {
+      const { Plugin } = yield* Effect.promise(() => import("../plugin.js"));
+      const plugins = yield* Plugin.Service;
+      const target = yield* Service49;
+      yield* plugins.awaitActivation;
+      return yield* run(target);
+    }).pipe(Effect.provide(locations.get(ref)));
+  };
+  const decodeWorktree = Schema.decodeUnknownEffect(Info17);
+  const decodeWorktrees = Schema.decodeUnknownEffect(Schema.Array(ListEntry3));
+  const listAgents = Effect.fn("PluginHost.listAgents")((ref) => Effect.gen(function* () {
+    const location = yield* Service73;
+    const agents = yield* Service62;
+    return {
+      location: new Info30({
+        directory: location.directory,
+        workspaceID: location.workspaceID,
+        project: location.project
+      }),
+      data: yield* agents.list()
+    };
+  }).pipe(Effect.provide(locations.get(ref)), Effect.orDie));
+  const context = {
+    app,
+    location: locationInfo(),
+    options: {},
+    rpc: Object.assign(rpc.client, { register: rpc.register }),
+    agent: {
+      get: (input) => {
+        const ref = locationRef(input);
+        const output = ref && !isCurrentLocation(ref) ? listAgents(ref).pipe(Effect.map((result) => ({
+          ...result,
+          data: result.data.find((agent) => agent.id === input.agentID)
+        }))) : response(agents.get(input.agentID));
+        return output.pipe(Effect.flatMap((result) => result.data ? Effect.succeed({ ...result, data: result.data }) : Effect.fail(new Error(`Agent not found: ${input.agentID}`))));
+      },
+      list: (input) => {
+        const ref = locationRef(input);
+        if (ref && !isCurrentLocation(ref))
+          return listAgents(ref);
+        return response(agents.list());
+      },
+      reload: agents.reload,
+      transform: (callback) => agents.transform((editor) => {
+        callback({
+          list: () => mutable(editor.list()),
+          get: (id) => mutable(editor.get(ID9.make(id))),
+          default: (id) => editor.default(id === undefined ? undefined : ID9.make(id)),
+          update: (id, update) => editor.update(ID9.make(id), update),
+          remove: (id) => editor.remove(ID9.make(id))
+        });
+      })
+    },
+    aisdk: {
+      hook: (name, callback, options) => {
+        if (name === "sdk") {
+          return aisdk.hook.sdk((event) => {
+            if (options?.providerID !== undefined && options.providerID !== event.model.providerID)
+              return Effect.void;
+            const output = {
+              model: mutable(event.model),
+              package: event.package,
+              options: event.options,
+              sdk: event.sdk
+            };
+            return Reflect.apply(callback, undefined, [output]).pipe(Effect.tap(() => Effect.sync(() => event.sdk = output.sdk)));
+          });
+        }
+        return aisdk.hook.language((event) => {
+          if (options?.providerID !== undefined && options.providerID !== event.model.providerID)
+            return Effect.void;
+          const output = {
+            model: mutable(event.model),
+            options: event.options,
+            sdk: event.sdk,
+            language: event.language
+          };
+          return Reflect.apply(callback, undefined, [output]).pipe(Effect.tap(() => Effect.sync(() => event.language = output.language)));
+        });
+      }
+    },
+    catalog: {
+      provider: {
+        list: () => response(catalog.provider.available()),
+        get: (input) => catalog.provider.get(ID18.make(input.providerID)).pipe(Effect.flatMap((provider) => provider === undefined ? Effect.fail(new Error(`Provider not found: ${input.providerID}`)) : response(Effect.succeed(provider))))
+      },
+      model: {
+        list: () => response(catalog.model.available()),
+        default: () => response(catalog.model.default())
+      },
+      reload: catalog.reload,
+      transform: (callback) => catalog.transform((editor) => {
+        callback({
+          provider: {
+            list: () => mutable(editor.provider.list()),
+            get: (id) => mutable(editor.provider.get(ID18.make(id))),
+            update: (id, update) => editor.provider.update(ID18.make(id), update),
+            remove: (id) => editor.provider.remove(ID18.make(id))
+          },
+          model: {
+            get: (providerID, modelID) => mutable(editor.model.get(ID18.make(providerID), ID13.make(modelID))),
+            update: (providerID, modelID, update) => editor.model.update(ID18.make(providerID), ID13.make(modelID), update),
+            remove: (providerID, modelID) => editor.model.remove(ID18.make(providerID), ID13.make(modelID)),
+            default: {
+              get: editor.model.default.get,
+              set: (providerID, modelID) => editor.model.default.set(ID18.make(providerID), ID13.make(modelID))
+            }
+          }
+        });
+      })
+    },
+    command: {
+      list: () => response(commands.list()),
+      reload: commands.reload,
+      transform: commands.transform
+    },
+    event: {
+      subscribe: () => bus.subscribe().pipe(Stream.filter((event) => EventManifest.isServer(event) || isRpcEvent(event)))
+    },
+    experimental: {
+      terminal: {
+        read: (input) => persistentPty.read(input.sessionID, input.lines)
+      }
+    },
+    generate: {
+      text: (input) => generate.text(input).pipe(Effect.map((text) => ({ text })))
+    },
+    integration: {
+      list: () => response(integration.list()),
+      get: (input) => response(integration.get(ID11.make(input.integrationID))),
+      connect: {
+        key: (input) => integration.connection.key({
+          integrationID: ID11.make(input.integrationID),
+          key: input.key,
+          answer: input.answer,
+          label: input.label
+        })
+      },
+      oauth: {
+        connect: (input) => response(integration.oauth.connect({
+          integrationID: ID11.make(input.integrationID),
+          methodID: MethodID2.make(input.methodID),
+          answer: input.answer,
+          label: input.label
+        })),
+        status: (input) => response(integration.oauth.status({
+          integrationID: ID11.make(input.integrationID),
+          attemptID: AttemptID2.make(input.attemptID)
+        })),
+        complete: (input) => integration.oauth.complete({
+          integrationID: ID11.make(input.integrationID),
+          attemptID: AttemptID2.make(input.attemptID),
+          code: input.code
+        }),
+        cancel: (input) => integration.oauth.cancel({
+          integrationID: ID11.make(input.integrationID),
+          attemptID: AttemptID2.make(input.attemptID)
+        })
+      },
+      command: {
+        connect: (input) => response(integration.command.connect({
+          integrationID: ID11.make(input.integrationID),
+          methodID: MethodID2.make(input.methodID),
+          label: input.label
+        })),
+        status: (input) => response(integration.command.status({
+          integrationID: ID11.make(input.integrationID),
+          attemptID: AttemptID2.make(input.attemptID)
+        })),
+        cancel: (input) => integration.command.cancel({
+          integrationID: ID11.make(input.integrationID),
+          attemptID: AttemptID2.make(input.attemptID)
+        })
+      },
+      reload: integration.reload,
+      connection: {
+        active: (id) => integration.connection.active(ID11.make(id)),
+        resolve: (connection) => integration.connection.resolve(connection.type === "credential" ? { ...connection, id: ID12.make(connection.id) } : connection)
+      },
+      transform: (callback) => integration.transform((editor) => {
+        callback({
+          list: () => mutable(editor.list()),
+          get: (id) => mutable(editor.get(ID11.make(id))),
+          update: (id, update) => editor.update(ID11.make(id), update),
+          remove: (id) => editor.remove(ID11.make(id)),
+          method: {
+            list: (id) => editor.method.list(ID11.make(id)),
+            update: (input) => editor.method.update(methodImplementation(input)),
+            remove: (id, method) => editor.method.remove(ID11.make(id), Schema.decodeUnknownSync(Method2)(method))
+          }
+        });
+      })
+    },
+    mcp: {
+      list: (input) => {
+        const ref = locationRef(input);
+        if (ref && !isCurrentLocation(ref))
+          return Effect.gen(function* () {
+            const location = yield* Service73;
+            const mcp = yield* Service31;
+            return {
+              location: new Info30({
+                directory: location.directory,
+                workspaceID: location.workspaceID,
+                project: location.project
+              }),
+              data: yield* mcp.servers()
+            };
+          }).pipe(Effect.provide(locations.get(ref)));
+        return response(mcp.servers());
+      },
+      reload: mcp.reload,
+      transform: (callback) => mcp.transform((editor) => {
+        callback({
+          list: () => editor.list().map(([name, config]) => [name, mutable(config)]),
+          get: (name) => mutable(editor.get(name)),
+          set: (name, config) => editor.set(name, Schema.decodeUnknownSync(ServerConfig)(config)),
+          update: editor.update,
+          remove: editor.remove
+        });
+      })
+    },
+    permission: {
+      hook: (name, callback) => hooks.register("permission", name, callback),
+      list: (input) => permission.forSession(input.sessionID),
+      get: (input) => permission.get(input.requestID).pipe(Effect.flatMap((request) => request?.sessionID === input.sessionID ? Effect.succeed(request) : Effect.fail(new Error(`Permission request not found: ${input.requestID}`)))),
+      reply: (input) => permission.get(input.requestID).pipe(Effect.flatMap((request) => request?.sessionID === input.sessionID ? permission.reply({ requestID: input.requestID, reply: input.reply, message: input.message }) : Effect.fail(new Error(`Permission request not found: ${input.requestID}`)))),
+      rules: sessions.setPermissions
+    },
+    plugin: {
+      list: () => response(plugin.list())
+    },
+    reference: {
+      list: () => response(reference.list()),
+      reload: reference.reload,
+      transform: (callback) => reference.transform((editor) => {
+        callback({
+          add: (name, source) => editor.add(name, Schema.decodeUnknownSync(Source3)(source)),
+          remove: editor.remove,
+          list: editor.list,
+          get: editor.get
+        });
+      })
+    },
+    skill: {
+      list: () => response(skill.list()),
+      reload: skill.reload,
+      transform: (callback) => skill.transform((editor) => {
+        callback({
+          list: () => mutable(editor.list()),
+          get: editor.get,
+          add: (value) => editor.add(Schema.decodeUnknownSync(Info18)(value)),
+          update: editor.update,
+          remove: editor.remove
+        });
+      })
+    },
+    storage: storage2(kv, pluginID),
+    shell: {
+      hook: (name, callback) => hooks.register("shell", name, callback)
+    },
+    tool: {
+      transform: tools.transform,
+      reload: tools.reload,
+      hook: (name, callback) => hooks.register("tool", name, callback)
+    },
+    vcs: {
+      get: () => response(vcs.info()),
+      base: () => response(vcs.base()),
+      branches: (input) => response(vcs.branches({ search: input?.search, limit: input?.limit })),
+      status: () => response(vcs.status()),
+      diff: (input) => response(vcs.diff(input.mode, { context: input.context, base: input.base })),
+      transform: vcs.transform,
+      reload: vcs.reload
+    },
+    websearch: {
+      providers: () => response(websearch.providers()),
+      query: (input) => response(websearch.query({
+        query: input.query,
+        providerID: input.providerID === undefined ? undefined : ID6.make(input.providerID)
+      })),
+      reload: websearch.reload,
+      transform: (callback) => websearch.transform((editor) => {
+        callback({
+          add: (definition) => editor.add({
+            id: ID6.make(definition.id),
+            name: definition.name,
+            execute: definition.execute
+          }),
+          default: {
+            get: editor.default.get,
+            set: (selection) => editor.default.set(selection === false || selection === "random" ? selection : ID6.make(selection))
+          }
+        });
+      })
+    },
+    worktree: {
+      list: (input) => atWorktree(locationRef(input), (service) => service.list()),
+      create: (input) => atWorktree(locationRef(input), (service) => service.create(input)),
+      refresh: (input) => atWorktree(locationRef(input), (service) => service.refresh()).pipe(Effect.asVoid),
+      remove: (input) => atWorktree(locationRef(input), (service) => service.remove(input)),
+      reload: worktrees.reload,
+      transform: (callback) => worktrees.transform((editor) => callback({
+        add: (definition) => editor.add({
+          id: StrategyID2.make(definition.id),
+          create: (input) => definition.create(input).pipe(Effect.flatMap(decodeWorktree)),
+          remove: (input) => definition.remove(input),
+          list: (directory) => definition.list(directory).pipe(Effect.flatMap(decodeWorktrees))
+        })
+      }))
+    },
+    session: {
+      hook: (name, callback, options) => hooks.register("session", name, callback, options),
+      create: (input) => sessions.create({
+        id: input?.id,
+        title: input?.title,
+        agent: input?.agent,
+        model: input?.model,
+        metadata: input?.metadata,
+        permissions: input?.permissions,
+        location: input?.location ?? Ref4.make({ directory: location.directory, workspaceID: location.workspaceID })
+      }),
+      get: (input) => sessions.get(input.sessionID),
+      switchAgent: sessions.switchAgent,
+      switchModel: sessions.switchModel,
+      prompt: sessions.prompt,
+      generate: (input) => sessions.generate(input).pipe(Effect.map((text) => ({ text }))),
+      command: sessions.command,
+      rename: sessions.rename,
+      move: sessions.move,
+      synthetic: sessions.synthetic,
+      interrupt: (input) => sessions.interrupt(input.sessionID, { continue: input.continue }).pipe(Effect.map((interrupted) => ({ interrupted }))),
+      wait: (input) => sessions.wait(input.sessionID),
+      context: (input) => sessions.context(input.sessionID)
+    }
+  };
+  return context;
+});
+var requirements3 = LayerNode.group([
+  node56,
+  node66,
+  node81,
+  node69,
+  node58,
+  node84,
+  node70,
+  node62,
+  node35,
+  node78,
+  node47,
+  node48,
+  node53,
+  node38,
+  node73,
+  node60,
+  node52,
+  node41,
+  node63,
+  node67,
+  node23,
+  node82,
+  node46
+]);
+function storage2(kv, pluginID) {
+  const namespace = `plugin:${pluginID.split("").map((value) => value.charCodeAt(0).toString(16).padStart(4, "0")).join("")}:`;
+  return {
+    get: (key) => kv.get(namespace + key),
+    set: (key, value) => kv.set(namespace + key, value),
+    remove: (key) => kv.remove(namespace + key),
+    scan: (options) => kv.scan({
+      prefix: namespace + options.prefix,
+      after: options.after === undefined ? undefined : namespace + options.after,
+      limit: options.limit
+    }).pipe(Effect.map((result) => {
+      const entries = result.entries.map((entry) => ({
+        key: entry.key.slice(namespace.length),
+        value: entry.value
+      }));
+      if (result.next === undefined)
+        return { entries };
+      return { entries, next: result.next.slice(namespace.length) };
+    }))
+  };
+}
+function methodImplementation(input) {
+  if ("authorize" in input) {
+    const refresh = input.refresh;
+    return {
+      integrationID: ID11.make(input.integrationID),
+      method: { ...input.method, id: MethodID2.make(input.method.id) },
+      authorize: (answer) => input.authorize(answer).pipe(Effect.map((authorization) => {
+        if (authorization.mode === "auto") {
+          return {
+            ...authorization,
+            callback: authorization.callback.pipe(Effect.map(credential))
+          };
+        }
+        return {
+          ...authorization,
+          callback: (code) => authorization.callback(code).pipe(Effect.map(credential))
+        };
+      })),
+      ...refresh ? { refresh: (value) => refresh(value).pipe(Effect.map(credential)) } : {},
+      ...input.label ? { label: input.label } : {}
+    };
+  }
+  if (input.method.type === "env") {
+    return {
+      integrationID: ID11.make(input.integrationID),
+      method: input.method
+    };
+  }
+  if (input.method.type === "command") {
+    return {
+      integrationID: ID11.make(input.integrationID),
+      method: { ...input.method, id: MethodID2.make(input.method.id) }
+    };
+  }
+  return {
+    integrationID: ID11.make(input.integrationID),
+    method: input.method
+  };
+}
+function credential(value) {
+  return OAuth3.make({ ...value, methodID: MethodID2.make(value.methodID) });
+}
+
+export { make11, requirements3, storage2, exports_host };

package/dist/chunks/aisdk-native-669tq793.js

@@ -0,0 +1,15 @@
+import {
+  createProviderPlugin2
+} from "./aisdk-native-ym463w8f.js";
+
+// src/plugin/provider/gateway.ts
+var GatewayPlugin2 = createProviderPlugin2({
+  id: "opencode.provider.gateway",
+  package: "@ai-sdk/gateway",
+  load: async (options) => {
+    const { createGateway } = await import("@ai-sdk/gateway");
+    return createGateway(options);
+  }
+});
+
+export { GatewayPlugin2 };