@opencode-ai/core 0.0.0-beta-18743 → 0.0.0-beta-18955

package/dist/chunks/{websearch-rft40sg1.js → event-logger-pm6tc1g5.js}

@@ -1,92 +1,100 @@
 import {
-  exports_runtime
-} from "./websearch-y1bq0y26.js";
-import {
-  exports_mcp
-} from "./websearch-17cn0e7w.js";
+  exports_generate
+} from "./event-logger-bmdmb8f9.js";
 import {
-  exports_vcs
-} from "./websearch-wsf0pp6q.js";
+  exports_persistent_pty
+} from "./event-logger-89jm8ntc.js";
 import {
   exports_rpc
-} from "./websearch-xva3gx0c.js";
+} from "./event-logger-j189w519.js";
 import {
-  exports_app
-} from "./websearch-50jxp3hw.js";
+  exports_session
+} from "./event-logger-mp08m2a2.js";
 import {
-  exports_command
-} from "./websearch-8epg6g0q.js";
-import {
-  exports_skill
-} from "./websearch-h8nbdcx9.js";
+  exports_mcp
+} from "./event-logger-jmk5afdx.js";
 import {
-  exports_generate
-} from "./websearch-0xa3ynrb.js";
+  exports_reference
+} from "./event-logger-zzr78n57.js";
 import {
   exports_catalog
-} from "./websearch-rhf7srtt.js";
-import {
-  exports_integration
-} from "./websearch-0atc81xx.js";
+} from "./event-logger-nrbccn7t.js";
 import {
   exports_model
-} from "./websearch-t683wdge.js";
+} from "./event-logger-8manx9kj.js";
+import {
+  exports_integration
+} from "./event-logger-8458mtgv.js";
 import {
   exports_credential
-} from "./websearch-xz7tgbq3.js";
+} from "./event-logger-cz4g9a0v.js";
 import {
-  exports_aisdk
-} from "./websearch-qwn30307.js";
+  exports_tool
+} from "./event-logger-m32vxkan.js";
 import {
-  exports_reference
-} from "./websearch-q8xy3s52.js";
+  exports_app
+} from "./event-logger-hs51b0fc.js";
 import {
-  exports_tool
-} from "./websearch-r3rfmnhs.js";
+  exports_skill
+} from "./event-logger-kzzx546a.js";
 import {
   exports_permission
-} from "./websearch-682366gn.js";
+} from "./event-logger-mvhmw1qg.js";
 import {
   exports_hooks
-} from "./websearch-v2wshkax.js";
+} from "./event-logger-xws7arpm.js";
 import {
   exports_agent
-} from "./websearch-vd03bq4r.js";
+} from "./event-logger-8eb86sst.js";
+import {
+  exports_aisdk
+} from "./event-logger-nj6yqve1.js";
+import {
+  exports_command
+} from "./event-logger-thpgkbc3.js";
 import {
   exports_websearch
-} from "./websearch-mxccen0e.js";
+} from "./event-logger-gse5vfpv.js";
 import {
-  exports_workspace
-} from "./websearch-z9qwgjnx.js";
+  exports_kv
+} from "./event-logger-3r56fk07.js";
 import {
-  exports_location
-} from "./websearch-mp6zts7p.js";
+  exports_location_service_map
+} from "./event-logger-xtqs7d5w.js";
 import {
-  exports_bus
-} from "./websearch-cat9v99r.js";
+  exports_vcs
+} from "./event-logger-ta3m9k5q.js";
 import {
   exports_provider
-} from "./websearch-fex42j86.js";
+} from "./event-logger-68yag814.js";
+import {
+  exports_location
+} from "./event-logger-90zcexzw.js";
 import {
   AbsolutePath
-} from "./websearch-j07kk359.js";
+} from "./event-logger-j07kk359.js";
 import {
-  exports_kv
-} from "./websearch-8rq9vje0.js";
+  exports_bus
+} from "./event-logger-vw7aptj1.js";
+import {
+  exports_workspace
+} from "./event-logger-hbm0jdrs.js";
 import {
   __export
-} from "./websearch-rvfvac9x.js";
+} from "./event-logger-vpjkya7h.js";
 
 // src/plugin/host.ts
 var exports_host = {};
 __export(exports_host, {
-  storage: () => storage,
+  PluginHost: () => exports_host,
   make: () => make,
-  PluginHost: () => exports_host
+  requirements: () => requirements,
+  storage: () => storage
 });
 import { EventManifest } from "@opencode-ai/schema/event-manifest";
 import { ServerConfig } from "@opencode-ai/schema/mcp";
 import { Effect, Schema, Stream } from "effect";
+import { LayerNode } from "@opencode-ai/util/effect/layer-node";
 var mutable = (value) => value;
 var isRpcEvent = (event) => event.type.startsWith("rpc.");
 var make = Effect.fn("PluginHost.make")(function* (plugin, pluginID = "test") {
@@ -109,7 +117,9 @@ var make = Effect.fn("PluginHost.make")(function* (plugin, pluginID = "test") {
   const generate = yield* exports_generate.Service;
   const permission = yield* exports_permission.Service;
   const hooks = yield* exports_hooks.Service;
-  const runtime = yield* exports_runtime.Service;
+  const sessions = yield* exports_session.Service;
+  const persistentPty = yield* exports_persistent_pty.Service;
+  const locations = yield* exports_location_service_map.Service;
   const locationInfo = () => new exports_location.Info({
     directory: location.directory,
     workspaceID: location.workspaceID,
@@ -121,7 +131,19 @@ var make = Effect.fn("PluginHost.make")(function* (plugin, pluginID = "test") {
   });
   const isCurrentLocation = (ref) => ref.directory === location.directory && ref.workspaceID === location.workspaceID;
   const response = (effect) => effect.pipe(Effect.map((data) => ({ location: locationInfo(), data })));
-  return {
+  const listAgents = Effect.fn("PluginHost.listAgents")((ref) => Effect.gen(function* () {
+    const location2 = yield* exports_location.Service;
+    const agents2 = yield* exports_agent.Service;
+    return {
+      location: new exports_location.Info({
+        directory: location2.directory,
+        workspaceID: location2.workspaceID,
+        project: location2.project
+      }),
+      data: yield* agents2.list()
+    };
+  }).pipe(Effect.provide(locations.get(ref)), Effect.orDie));
+  const context = {
     app,
     location: locationInfo(),
     options: {},
@@ -129,7 +151,7 @@ var make = Effect.fn("PluginHost.make")(function* (plugin, pluginID = "test") {
     agent: {
       get: (input) => {
         const ref = locationRef(input);
-        const output = ref && !isCurrentLocation(ref) ? runtime.location.agent.list(ref).pipe(Effect.map((result) => ({
+        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));
@@ -138,17 +160,17 @@ var make = Effect.fn("PluginHost.make")(function* (plugin, pluginID = "test") {
       list: (input) => {
         const ref = locationRef(input);
         if (ref && !isCurrentLocation(ref))
-          return runtime.location.agent.list(ref);
+          return listAgents(ref);
         return response(agents.list());
       },
       reload: agents.reload,
-      transform: (callback) => agents.transform((draft) => {
+      transform: (callback) => agents.transform((editor) => {
         callback({
-          list: () => mutable(draft.list()),
-          get: (id) => mutable(draft.get(exports_agent.ID.make(id))),
-          default: (id) => draft.default(id === undefined ? undefined : exports_agent.ID.make(id)),
-          update: (id, update) => draft.update(exports_agent.ID.make(id), update),
-          remove: (id) => draft.remove(exports_agent.ID.make(id))
+          list: () => mutable(editor.list()),
+          get: (id) => mutable(editor.get(exports_agent.ID.make(id))),
+          default: (id) => editor.default(id === undefined ? undefined : exports_agent.ID.make(id)),
+          update: (id, update) => editor.update(exports_agent.ID.make(id), update),
+          remove: (id) => editor.remove(exports_agent.ID.make(id))
         });
       })
     },
@@ -190,21 +212,21 @@ var make = Effect.fn("PluginHost.make")(function* (plugin, pluginID = "test") {
         default: () => response(catalog.model.default())
       },
       reload: catalog.reload,
-      transform: (callback) => catalog.transform((draft) => {
+      transform: (callback) => catalog.transform((editor) => {
         callback({
           provider: {
-            list: () => mutable(draft.provider.list()),
-            get: (id) => mutable(draft.provider.get(exports_provider.ID.make(id))),
-            update: (id, update) => draft.provider.update(exports_provider.ID.make(id), update),
-            remove: (id) => draft.provider.remove(exports_provider.ID.make(id))
+            list: () => mutable(editor.provider.list()),
+            get: (id) => mutable(editor.provider.get(exports_provider.ID.make(id))),
+            update: (id, update) => editor.provider.update(exports_provider.ID.make(id), update),
+            remove: (id) => editor.provider.remove(exports_provider.ID.make(id))
           },
           model: {
-            get: (providerID, modelID) => mutable(draft.model.get(exports_provider.ID.make(providerID), exports_model.ID.make(modelID))),
-            update: (providerID, modelID, update) => draft.model.update(exports_provider.ID.make(providerID), exports_model.ID.make(modelID), update),
-            remove: (providerID, modelID) => draft.model.remove(exports_provider.ID.make(providerID), exports_model.ID.make(modelID)),
+            get: (providerID, modelID) => mutable(editor.model.get(exports_provider.ID.make(providerID), exports_model.ID.make(modelID))),
+            update: (providerID, modelID, update) => editor.model.update(exports_provider.ID.make(providerID), exports_model.ID.make(modelID), update),
+            remove: (providerID, modelID) => editor.model.remove(exports_provider.ID.make(providerID), exports_model.ID.make(modelID)),
             default: {
-              get: draft.model.default.get,
-              set: (providerID, modelID) => draft.model.default.set(exports_provider.ID.make(providerID), exports_model.ID.make(modelID))
+              get: editor.model.default.get,
+              set: (providerID, modelID) => editor.model.default.set(exports_provider.ID.make(providerID), exports_model.ID.make(modelID))
             }
           }
         });
@@ -220,7 +242,7 @@ var make = Effect.fn("PluginHost.make")(function* (plugin, pluginID = "test") {
     },
     experimental: {
       terminal: {
-        read: (input) => runtime.persistentPty.read(input.sessionID, input.lines)
+        read: (input) => persistentPty.read(input.sessionID, input.lines)
       }
     },
     generate: {
@@ -278,16 +300,16 @@ var make = Effect.fn("PluginHost.make")(function* (plugin, pluginID = "test") {
         active: (id) => integration.connection.active(exports_integration.ID.make(id)),
         resolve: (connection) => integration.connection.resolve(connection.type === "credential" ? { ...connection, id: exports_credential.ID.make(connection.id) } : connection)
       },
-      transform: (callback) => integration.transform((draft) => {
+      transform: (callback) => integration.transform((editor) => {
         callback({
-          list: () => mutable(draft.list()),
-          get: (id) => mutable(draft.get(exports_integration.ID.make(id))),
-          update: (id, update) => draft.update(exports_integration.ID.make(id), update),
-          remove: (id) => draft.remove(exports_integration.ID.make(id)),
+          list: () => mutable(editor.list()),
+          get: (id) => mutable(editor.get(exports_integration.ID.make(id))),
+          update: (id, update) => editor.update(exports_integration.ID.make(id), update),
+          remove: (id) => editor.remove(exports_integration.ID.make(id)),
           method: {
-            list: (id) => draft.method.list(exports_integration.ID.make(id)),
-            update: (input) => draft.method.update(methodImplementation(input)),
-            remove: (id, method) => draft.method.remove(exports_integration.ID.make(id), Schema.decodeUnknownSync(exports_integration.Method)(method))
+            list: (id) => editor.method.list(exports_integration.ID.make(id)),
+            update: (input) => editor.method.update(methodImplementation(input)),
+            remove: (id, method) => editor.method.remove(exports_integration.ID.make(id), Schema.decodeUnknownSync(exports_integration.Method)(method))
           }
         });
       })
@@ -296,17 +318,28 @@ var make = Effect.fn("PluginHost.make")(function* (plugin, pluginID = "test") {
       list: (input) => {
         const ref = locationRef(input);
         if (ref && !isCurrentLocation(ref))
-          return runtime.location.mcp.list(ref);
+          return Effect.gen(function* () {
+            const location2 = yield* exports_location.Service;
+            const mcp2 = yield* exports_mcp.Service;
+            return {
+              location: new exports_location.Info({
+                directory: location2.directory,
+                workspaceID: location2.workspaceID,
+                project: location2.project
+              }),
+              data: yield* mcp2.servers()
+            };
+          }).pipe(Effect.provide(locations.get(ref)));
         return response(mcp.servers());
       },
       reload: mcp.reload,
-      transform: (callback) => mcp.transform((draft) => {
+      transform: (callback) => mcp.transform((editor) => {
         callback({
-          list: () => draft.list().map(([name, config]) => [name, mutable(config)]),
-          get: (name) => mutable(draft.get(name)),
-          set: (name, config) => draft.set(name, Schema.decodeUnknownSync(ServerConfig)(config)),
-          update: draft.update,
-          remove: draft.remove
+          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
         });
       })
     },
@@ -322,23 +355,23 @@ var make = Effect.fn("PluginHost.make")(function* (plugin, pluginID = "test") {
     reference: {
       list: () => response(reference.list()),
       reload: reference.reload,
-      transform: (callback) => reference.transform((draft) => {
+      transform: (callback) => reference.transform((editor) => {
         callback({
-          add: (name, source) => draft.add(name, Schema.decodeUnknownSync(exports_reference.Source)(source)),
-          remove: draft.remove,
-          list: draft.list
+          add: (name, source) => editor.add(name, Schema.decodeUnknownSync(exports_reference.Source)(source)),
+          remove: editor.remove,
+          list: editor.list
         });
       })
     },
     skill: {
       list: () => response(skill.list()),
       reload: skill.reload,
-      transform: (callback) => skill.transform((draft) => {
+      transform: (callback) => skill.transform((editor) => {
         callback({
-          list: () => mutable(draft.list()),
-          add: (value) => draft.add(Schema.decodeUnknownSync(exports_skill.Info)(value)),
-          update: draft.update,
-          remove: draft.remove
+          list: () => mutable(editor.list()),
+          add: (value) => editor.add(Schema.decodeUnknownSync(exports_skill.Info)(value)),
+          update: editor.update,
+          remove: editor.remove
         });
       })
     },
@@ -367,44 +400,69 @@ var make = Effect.fn("PluginHost.make")(function* (plugin, pluginID = "test") {
         providerID: input.providerID === undefined ? undefined : exports_websearch.ID.make(input.providerID)
       })),
       reload: websearch.reload,
-      transform: (callback) => websearch.transform((draft) => {
+      transform: (callback) => websearch.transform((editor) => {
         callback({
-          add: (definition) => draft.add({
+          add: (definition) => editor.add({
             id: exports_websearch.ID.make(definition.id),
             name: definition.name,
             execute: definition.execute
           }),
           default: {
-            get: draft.default.get,
-            set: (selection) => draft.default.set(selection === false || selection === "random" ? selection : exports_websearch.ID.make(selection))
+            get: editor.default.get,
+            set: (selection) => editor.default.set(selection === false || selection === "random" ? selection : exports_websearch.ID.make(selection))
           }
         });
       })
     },
     session: {
       hook: (name, callback, options) => hooks.register("session", name, callback, options),
-      create: (input) => runtime.session.create({
+      create: (input) => sessions.create({
         id: input?.id,
         title: input?.title,
         agent: input?.agent,
         model: input?.model,
         location: input?.location ?? exports_location.Ref.make({ directory: location.directory, workspaceID: location.workspaceID })
       }),
-      get: (input) => runtime.session.get(input.sessionID),
-      switchAgent: runtime.session.switchAgent,
-      switchModel: runtime.session.switchModel,
-      prompt: runtime.session.prompt,
-      generate: (input) => runtime.session.generate(input).pipe(Effect.map((text) => ({ text }))),
-      command: runtime.session.command,
-      rename: runtime.session.rename,
-      move: runtime.session.move,
-      synthetic: runtime.session.synthetic,
-      interrupt: (input) => runtime.session.interrupt(input.sessionID, { continue: input.continue }).pipe(Effect.map((interrupted) => ({ interrupted }))),
-      wait: (input) => runtime.session.wait(input.sessionID),
-      context: (input) => runtime.session.context(input.sessionID)
+      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 requirements = LayerNode.group([
+  exports_app.node,
+  exports_agent.node,
+  exports_aisdk.node,
+  exports_catalog.node,
+  exports_command.node,
+  exports_bus.node,
+  exports_integration.node,
+  exports_kv.node,
+  exports_mcp.node,
+  exports_location.node,
+  exports_reference.node,
+  exports_rpc.node,
+  exports_skill.node,
+  exports_tool.node,
+  exports_vcs.node,
+  exports_websearch.node,
+  exports_generate.node,
+  exports_permission.node,
+  exports_hooks.node,
+  exports_session.node,
+  exports_persistent_pty.node,
+  exports_location_service_map.node
+]);
 function storage(kv, pluginID) {
   const namespace = `plugin:${pluginID.split("").map((value) => value.charCodeAt(0).toString(16).padStart(4, "0")).join("")}:`;
   return {
@@ -469,4 +527,4 @@ function credential(value) {
   return exports_credential.OAuth.make({ ...value, methodID: exports_integration.MethodID.make(value.methodID) });
 }
 
-export { make, storage, exports_host };
+export { make, requirements, storage, exports_host };

package/dist/chunks/event-logger-pmxccgjm.js

@@ -0,0 +1,70 @@
+import {
+  exports_context
+} from "./event-logger-z4wj20et.js";
+import {
+  exports_service as exports_service2
+} from "./event-logger-esv5q40e.js";
+import {
+  exports_service
+} from "./event-logger-6bxzghb6.js";
+import {
+  exports_model_request
+} from "./event-logger-4vcd31gm.js";
+import {
+  exports_history
+} from "./event-logger-7kvqks8y.js";
+import {
+  exports_database
+} from "./event-logger-hr3zcmss.js";
+import {
+  __export
+} from "./event-logger-vpjkya7h.js";
+
+// src/session/generate.ts
+var exports_generate = {};
+__export(exports_generate, {
+  SessionGenerate: () => exports_generate,
+  generate: () => generate
+});
+import { LLMClient, Message } from "@opencode-ai/ai";
+import { Effect } from "effect";
+var generate = Effect.fn("SessionGenerate.generate")(function* (input) {
+  const instances = yield* exports_service.Service;
+  const database = yield* exports_database.Service;
+  const llm = yield* LLMClient.Service;
+  return yield* Effect.gen(function* () {
+    yield* exports_service2.awaitActivation;
+    const context = yield* exports_context.Service;
+    const selection = yield* context.select(input.session.id);
+    const model = yield* context.resolveModel(selection.session);
+    const history = yield* exports_history.preview(database.db, selection.session.id, selection.instructions);
+    const transcript = exports_model_request.baseTranscript({
+      agent: selection.agent.info,
+      model,
+      tools: selection.tools,
+      initial: history.initial,
+      messages: history.messages
+    });
+    const prepared = yield* context.prepare({
+      scope: { session: selection.session, agentID: selection.agent.id, model, tools: selection.tools },
+      transcript: {
+        system: transcript.system,
+        messages: [
+          ...transcript.messages,
+          ...history.instructionUpdate ? [Message.system(history.instructionUpdate)] : [],
+          Message.user(input.prompt)
+        ]
+      }
+    });
+    yield* Effect.logInfo("sending session generation request", {
+      sessionID: selection.session.id,
+      providerID: model.ref.providerID,
+      modelID: model.ref.id
+    });
+    const response = yield* llm.generate(prepared.request, prepared.options);
+    yield* Effect.logInfo("session generation usage diagnostic", { usage: response.usage });
+    return response.text;
+  }).pipe(instances.provide(input.session));
+});
+
+export { generate, exports_generate };

package/dist/chunks/{websearch-7ks83nc4.js → event-logger-pnnr4jav.js}

@@ -1,10 +1,10 @@
 import {
   SQLiteEffectDatabase
-} from "./websearch-snd64xsa.js";
+} from "./event-logger-wntga0jy.js";
 import {
   mapResultRow,
   resolveNullableObjectPaths
-} from "./websearch-k8b45nas.js";
+} from "./event-logger-k8b45nas.js";
 
 // src/database/drizzle/sqlite-core/effect/session.ts
 import * as Cause from "effect/Cause";

package/dist/chunks/{websearch-v6wdqan0.js → event-logger-prqhf714.js}

@@ -1,23 +1,23 @@
 import {
   exports_skill
-} from "./websearch-h8nbdcx9.js";
+} from "./event-logger-kzzx546a.js";
 import {
   exports_permission
-} from "./websearch-682366gn.js";
+} from "./event-logger-mvhmw1qg.js";
 import {
   __export
-} from "./websearch-rvfvac9x.js";
+} from "./event-logger-vpjkya7h.js";
 
 // src/tool/plugin/skill.ts
 var exports_skill2 = {};
 __export(exports_skill2, {
-  toModelOutput: () => toModelOutput,
-  name: () => name,
-  description: () => description,
-  SkillTool: () => exports_skill2,
-  Plugin: () => Plugin,
+  Input: () => Input,
   Output: () => Output,
-  Input: () => Input
+  Plugin: () => Plugin,
+  SkillTool: () => exports_skill2,
+  description: () => description,
+  name: () => name,
+  toModelOutput: () => toModelOutput
 });
 import { ToolFailure } from "@opencode-ai/ai";
 import { Effect, Schema } from "effect";
@@ -45,7 +45,7 @@ var Plugin = {
     const fs = yield* FSUtil.Service;
     const skills = yield* exports_skill.Service;
     const permission = yield* exports_permission.Service;
-    yield* ctx.tool.transform((draft) => draft.add({
+    yield* ctx.tool.transform((editor) => editor.add({
       name,
       options: { codemode: false },
       description,

package/dist/chunks/{websearch-bh1wr8rq.js → event-logger-pves38xm.js}

@@ -1,16 +1,16 @@
 import {
   exports_app
-} from "./websearch-50jxp3hw.js";
+} from "./event-logger-hs51b0fc.js";
 import {
   __export
-} from "./websearch-rvfvac9x.js";
+} from "./event-logger-vpjkya7h.js";
 
 // src/plugin/websearch/tavily.ts
 var exports_tavily = {};
 __export(exports_tavily, {
-  endpoint: () => endpoint,
+  Plugin: () => Plugin,
   WebSearchTavily: () => exports_tavily,
-  Plugin: () => Plugin
+  endpoint: () => endpoint
 });
 import { define } from "@opencode-ai/plugin/effect/plugin";
 import { Duration, Effect, Schema } from "effect";
@@ -33,19 +33,19 @@ var Plugin = define({
   id: "opencode.websearch.tavily",
   effect: Effect.fn("WebSearchTavily.Plugin")(function* (ctx) {
     const http = yield* HttpClient.HttpClient;
-    yield* ctx.integration.transform((draft) => {
-      draft.update("tavily", (integration) => integration.name = "Tavily");
-      draft.method.update({
+    yield* ctx.integration.transform((editor) => {
+      editor.update("tavily", (integration) => integration.name = "Tavily");
+      editor.method.update({
         integrationID: "tavily",
         method: { type: "key" }
       });
-      draft.method.update({
+      editor.method.update({
         integrationID: "tavily",
         method: { type: "env", names: ["TAVILY_API_KEY"] }
       });
     });
-    yield* ctx.websearch.transform((draft) => {
-      draft.add({
+    yield* ctx.websearch.transform((editor) => {
+      editor.add({
         id: "tavily",
         name: "Tavily",
         execute: (input) => Effect.gen(function* () {