@opencode/core 2.0.2 → 2.0.4

package/dist/chunks/{location-services-5adankya.js → location-4v7ac2af.js}

@@ -1,66 +1,66 @@
 import {
-  Service67
-} from "./location-services-2gv9ss0t.js";
+  Service75
+} from "./location-qx4vf964.js";
 import {
-  Service69
-} from "./location-services-fe7neb4g.js";
+  Service64
+} from "./location-7x9k4znd.js";
 import {
-  ID6,
+  ID4,
   Result2,
   ProviderRequiredError2,
   DisabledError2,
   RequestError2,
-  Service61
-} from "./location-services-tf1j6dqp.js";
+  Service20
+} from "./location-txrndw2w.js";
 import {
   __export
-} from "./location-services-9rqn6x4v.js";
+} from "./location-9rqn6x4v.js";
 
 // src/tool/plugin/websearch.ts
 var exports_websearch = {};
 __export(exports_websearch, {
-  Input: () => Input11,
+  Input: () => Input6,
   NO_RESULTS: () => NO_RESULTS2,
-  Plugin: () => Plugin12,
+  Plugin: () => Plugin6,
   WebSearchTool: () => exports_websearch,
-  description: () => description5,
-  name: () => name11
+  description: () => description3,
+  name: () => name6
 });
 import { ToolFailure } from "@opencode/ai";
 import { Effect, Schema, Semaphore } from "effect";
 import { HttpClientError } from "effect/unstable/http";
-var name11 = "websearch";
+var name6 = "websearch";
 var NO_RESULTS2 = "No search results found. Please try a different query.";
 var providerSelectionLock = Semaphore.makeUnsafe(1);
 var httpErrors = new Map([
   [429, "Web search rate limited (HTTP 429)"],
   [401, "Web search authentication failed (HTTP 401)"]
 ]);
-var description5 = `Search the web using the user's selected search integration. Use this for current information beyond knowledge cutoff.
+var description3 = `Search the web using the user's selected search integration. Use this for current information beyond knowledge cutoff.
 
 The current year is ${new Date().getFullYear()}. Use this year when searching for recent information or current events.`;
-var Input11 = Schema.Struct({
+var Input6 = Schema.Struct({
   query: Schema.String.annotate({ description: "Websearch query" })
 });
 var Output = Schema.Struct({
-  provider: ID6,
+  provider: ID4,
   results: Schema.Array(Result2)
 });
-var Plugin12 = {
+var Plugin6 = {
   id: "opencode.tool.websearch",
   effect: Effect.fn("WebSearchTool.Plugin")(function* (ctx) {
-    const permission = yield* Service69;
-    const forms = yield* Service67;
-    const websearch = yield* Service61;
+    const permission = yield* Service64;
+    const forms = yield* Service75;
+    const websearch = yield* Service20;
     yield* ctx.tool.transform((editor) => editor.add({
-      name: name11,
+      name: name6,
       options: { codemode: false },
-      description: description5,
-      input: Input11,
+      description: description3,
+      input: Input6,
       output: Output,
       execute: (input, context) => Effect.gen(function* () {
         yield* permission.assert({
-          action: name11,
+          action: name6,
           resources: [input.query],
           save: ["*"],
           metadata: input,
@@ -173,12 +173,15 @@ ${result.content}` : ""}`;
         });
       }))
     })).pipe(Effect.orDie);
-    yield* ctx.session.hook("context", (event) => Effect.gen(function* () {
+    const hook = (event) => Effect.gen(function* () {
       const disabled = yield* websearch.default().pipe(Effect.as(false), Effect.catchTag("WebSearch.Disabled", () => Effect.succeed(true)));
       if (disabled)
-        delete event.tools[name11];
-    }));
+        delete event.tools[name6];
+    });
+    yield* ctx.session.hook("context", hook);
+    yield* ctx.session.hook("compaction", hook);
+    yield* ctx.session.hook("generate", hook);
   })
 };
 
-export { name11, NO_RESULTS2, description5, Input11, Plugin12, exports_websearch };
+export { name6, NO_RESULTS2, description3, Input6, Plugin6, exports_websearch };

package/dist/chunks/{location-services-7fyj755m.js → location-4wv5y4sh.js}

@@ -1,47 +1,51 @@
 import {
   AbsolutePath2
-} from "./location-services-922hggd3.js";
+} from "./location-922hggd3.js";
 import {
   WorktreeError2,
-  node81
-} from "./location-services-j26kwb45.js";
-import {
-  ID17
-} from "./location-services-rsym84ch.js";
+  node85
+} from "./location-c488s98d.js";
 import {
   Slug2
-} from "./location-services-gebd4c9n.js";
+} from "./location-gebd4c9n.js";
 import {
-  Service80,
-  node85
-} from "./location-services-v9b1dqp1.js";
+  Service82,
+  node86
+} from "./location-yq2q1mjm.js";
 import {
-  Service79,
-  node84
-} from "./location-services-69j49pks.js";
+  Service78,
+  node82
+} from "./location-tsjh32me.js";
 import {
   ProjectTable2
-} from "./location-services-dj2t23y0.js";
+} from "./location-8p4f9s12.js";
 import {
   WorktreeTable2
-} from "./location-services-m0jqrx5p.js";
+} from "./location-cfpkc3c9.js";
+import {
+  ID17,
+  NotFoundError11
+} from "./location-e4z3td0h.js";
 import {
-  Service74,
-  node79
-} from "./location-services-k4e7wm7p.js";
+  Ref4
+} from "./location-zyx4eyj3.js";
+import {
+  Service52,
+  node54
+} from "./location-m3dp0h2h.js";
 import {
   DirectoryUnavailableError2,
   canonical2
-} from "./location-services-gv6a8nnw.js";
+} from "./location-gv6a8nnw.js";
 import {
   make12
-} from "./location-services-1emffesh.js";
+} from "./location-t44e5ekz.js";
 import {
-  create3
-} from "./location-services-kg06axw8.js";
+  Service19
+} from "./location-tcddack9.js";
 import {
   __export
-} from "./location-services-9rqn6x4v.js";
+} from "./location-9rqn6x4v.js";
 
 // src/worktree.ts
 var exports_worktree2 = {};
@@ -49,28 +53,25 @@ __export(exports_worktree2, {
   CreateInput: () => CreateInput3,
   DestinationExistsError: () => DestinationExistsError2,
   DirectoryUnavailableError: () => DirectoryUnavailableError2,
-  Event: () => Event6,
-  Info: () => Info5,
+  Event: () => Event4,
+  Info: () => Info4,
   InvalidDirectoryError: () => InvalidDirectoryError2,
   List: () => List2,
   ListEntry: () => ListEntry3,
   OperationError: () => OperationError2,
-  RefreshResult: () => RefreshResult2,
   RemoveInput: () => RemoveInput2,
-  Service: () => Service22,
+  Service: () => Service18,
   SourceDirectoryNotFoundError: () => SourceDirectoryNotFoundError2,
   StrategyID: () => StrategyID2,
   StrategyUnavailableError: () => StrategyUnavailableError2,
-  UnsupportedLocationError: () => UnsupportedLocationError2,
   Worktree: () => exports_worktree2,
-  node: () => node26
+  node: () => node21
 });
 import { Context, Effect, Layer, Schema } from "effect";
 import { and, asc, desc, eq, isNull, sql } from "drizzle-orm";
 import path from "path";
 import { FSUtil } from "@opencode/util/fs-util";
-import { makeLocationNode } from "@opencode/util/effect/app-node";
-import { Global } from "@opencode/util/global";
+import { Node } from "@opencode/util/effect/app-node";
 import { Worktree } from "@opencode/schema/worktree";
 import { AppProcess } from "@opencode/util/process";
 import { ChildProcess } from "effect/unstable/process";
@@ -78,11 +79,7 @@ import { OperationError as OperationError2 } from "@opencode/schema/worktree";
 var StrategyID2 = Worktree.StrategyID;
 var CreateInput3 = Worktree.CreateInput;
 var RemoveInput2 = Worktree.RemoveInput;
-var RefreshResult2 = Schema.Struct({
-  updated: Schema.Array(AbsolutePath2),
-  removed: Schema.Array(AbsolutePath2)
-}).annotate({ identifier: "Worktree.RefreshResult" });
-var Info5 = Worktree.Info;
+var Info4 = Worktree.Info;
 var List2 = Worktree.List;
 var ListEntry3 = Worktree.ListEntry;
 
@@ -97,56 +94,48 @@ class InvalidDirectoryError2 extends Schema.TaggedError()("Worktree.InvalidDirec
 
 class StrategyUnavailableError2 extends Schema.TaggedError()("Worktree.StrategyUnavailableError", { strategy: StrategyID2 }) {
 }
+var Event4 = Worktree.Event;
 
-class UnsupportedLocationError2 extends Schema.TaggedError()("Worktree.UnsupportedLocationError", { directory: AbsolutePath2 }) {
-}
-var Event6 = Worktree.Event;
-
-class Service22 extends Context.Service()("@opencode/v2/Worktree") {
+class Service18 extends Context.Service()("@opencode/Worktree") {
 }
-var layer = Layer.effect(Service22, Effect.gen(function* () {
+var layer = Layer.effect(Service18, Effect.gen(function* () {
   const fs = yield* FSUtil.Service;
-  const database = yield* Service80;
+  const database = yield* Service82;
   const db = database.db;
-  const bus = yield* Service79;
+  const bus = yield* Service78;
   const processService = yield* AppProcess.Service;
-  const location = yield* Service74;
-  const global = yield* Global.Service;
-  const projectID = location.project.id;
-  const local = location.workspaceID ? Effect.fail(new UnsupportedLocationError2({ directory: location.directory })) : Effect.void;
+  const locations = yield* Service52;
   const gitStrategy = yield* make12;
-  const state = create3({
-    name: "worktree",
-    initial: () => ({
-      directory: AbsolutePath2.make(path.join(global.data, "worktree", projectID.slice(0, 6))),
-      strategies: new Map([[gitStrategy.id, gitStrategy]]),
-      selected: gitStrategy.id
-    }),
-    editor: (value) => ({
-      configure: (settings) => {
-        value.directory = settings.directory;
-      },
-      add: (strategy) => {
-        value.strategies.delete(strategy.id);
-        value.strategies.set(strategy.id, strategy);
-        value.selected = strategy.id;
-      }
-    })
+  const project = Effect.fnUntraced(function* (projectID) {
+    const row = yield* db.select().from(ProjectTable2).where(eq(ProjectTable2.id, projectID)).get().pipe(Effect.orDie);
+    if (!row)
+      return yield* new NotFoundError11({ projectID });
+    return row;
+  });
+  const load = Effect.fnUntraced(function* (directory, current) {
+    if (!(yield* fs.isDir(directory)))
+      return yield* new DirectoryUnavailableError2({ directory });
+    if (current?.directory === directory)
+      return current.get();
+    const { Plugin } = yield* Effect.promise(() => import("../plugin.js"));
+    const context = yield* locations.contextEffect(Ref4.make({ directory }));
+    yield* Context.get(context, Plugin.Service).awaitActivation;
+    return Context.get(context, Service19).get();
   });
-  const changed = Effect.fnUntraced(function* (update) {
+  const changed = Effect.fnUntraced(function* (projectID, update) {
     if (update)
-      yield* bus.publish(Event6.Updated, { projectID });
+      yield* bus.publish(Event4.Updated, { projectID });
   });
   const ops = {
-    list: Effect.fnUntraced(function* () {
+    list: Effect.fnUntraced(function* (projectID) {
       const rows = yield* db.select({ directory: WorktreeTable2.directory, strategy: WorktreeTable2.strategy }).from(WorktreeTable2).where(eq(WorktreeTable2.project_id, projectID)).orderBy(desc(WorktreeTable2.time_created), asc(WorktreeTable2.directory)).all().pipe(Effect.orDie);
       return rows.map((row) => ({ directory: row.directory, strategy: row.strategy ?? undefined }));
     }),
-    find: Effect.fnUntraced(function* (directory) {
+    find: Effect.fnUntraced(function* (projectID, directory) {
       const row = yield* db.select({ directory: WorktreeTable2.directory, strategy: WorktreeTable2.strategy }).from(WorktreeTable2).where(and(eq(WorktreeTable2.project_id, projectID), eq(WorktreeTable2.directory, directory))).get().pipe(Effect.orDie);
       return row ? { directory: row.directory, strategy: row.strategy ?? undefined } : undefined;
     }),
-    create: (input, tx) => (tx ?? db).insert(WorktreeTable2).values({
+    create: (projectID, input, tx) => (tx ?? db).insert(WorktreeTable2).values({
       project_id: projectID,
       directory: input.directory,
       strategy: input.strategy
@@ -157,12 +146,11 @@ var layer = Layer.effect(Service22, Effect.gen(function* () {
       },
       setWhere: input.replace ? undefined : input.strategy ? isNull(WorktreeTable2.strategy) : sql`false`
     }).returning({ directory: WorktreeTable2.directory }).get().pipe(Effect.orDie, Effect.map((row) => row !== undefined)),
-    remove: (directory, tx) => (tx ?? db).delete(WorktreeTable2).where(and(eq(WorktreeTable2.project_id, projectID), eq(WorktreeTable2.directory, directory))).returning({ directory: WorktreeTable2.directory }).get().pipe(Effect.orDie, Effect.map((row) => row !== undefined))
+    remove: (projectID, directory, tx) => (tx ?? db).delete(WorktreeTable2).where(and(eq(WorktreeTable2.project_id, projectID), eq(WorktreeTable2.directory, directory))).returning({ directory: WorktreeTable2.directory }).get().pipe(Effect.orDie, Effect.map((row) => row !== undefined))
   };
-  const source = Effect.fnUntraced(function* (input) {
-    const sourceDirectory = input ?? location.project.directory;
+  const source = Effect.fnUntraced(function* (projectID, sourceDirectory) {
     const resolved = yield* canonical2(fs, sourceDirectory);
-    if ((yield* ops.find(resolved)) === undefined)
+    if ((yield* ops.find(projectID, resolved)) === undefined)
       return yield* new SourceDirectoryNotFoundError2({ projectID, directory: resolved });
     return resolved;
   });
@@ -172,12 +160,12 @@ var layer = Layer.effect(Service22, Effect.gen(function* () {
       return yield* new StrategyUnavailableError2({ strategy: id });
     return found;
   });
-  const create = Effect.fn("Worktree.create")(function* (input = {}) {
-    yield* local;
-    const current = state.get();
-    const selected = yield* getStrategy(input.strategy ?? current.selected, current.strategies);
-    const directory = input.directory ?? current.directory;
-    const sourceDirectory = yield* source(input.from);
+  const create = Effect.fn("Worktree.create")(function* (input, current) {
+    const row = yield* project(input.projectID);
+    const settings = yield* load(row.worktree, current);
+    const selected = yield* getStrategy(settings.selected, settings.strategies);
+    const directory = input.directory ?? settings.directory;
+    const sourceDirectory = yield* source(input.projectID, input.from ?? row.worktree);
     yield* fs.makeDirectory(directory, { recursive: true }).pipe(Effect.orDie);
     const name = input.name ?? Slug2.create();
     let suffix = 1;
@@ -194,13 +182,12 @@ var layer = Layer.effect(Service22, Effect.gen(function* () {
       branch: input.branch
     }).pipe(Effect.mapError((error) => operationError(selected.id, "create", error)));
     const result = { directory: yield* canonical2(fs, created.directory) };
-    yield* changed(yield* ops.create({
+    yield* changed(input.projectID, yield* ops.create(input.projectID, {
       directory: result.directory,
       strategy: selected.id,
       replace: true
     }));
-    const project = yield* db.select({ commands: ProjectTable2.commands }).from(ProjectTable2).where(eq(ProjectTable2.id, projectID)).get().pipe(Effect.orDie);
-    const command = project?.commands?.start?.trim();
+    const command = row.commands?.start?.trim();
     if (command) {
       const windows = process.platform === "win32";
       yield* processService.run(ChildProcess.make(windows ? command : "bash", windows ? [] : ["-lc", command], {
@@ -215,29 +202,37 @@ var layer = Layer.effect(Service22, Effect.gen(function* () {
       })).pipe(Effect.flatMap(AppProcess.requireSuccess));
     }
     return result;
-  });
-  const remove = Effect.fn("Worktree.remove")(function* (input) {
-    yield* local;
+  }, Effect.scoped);
+  const remove = Effect.fn("Worktree.remove")(function* (input, current) {
+    const row = yield* project(input.projectID);
     const worktreeDirectory = yield* canonical2(fs, input.directory);
-    const stored = yield* ops.find(worktreeDirectory);
+    const stored = yield* ops.find(input.projectID, worktreeDirectory);
     if (!stored?.strategy)
       return yield* new InvalidDirectoryError2({ directory: worktreeDirectory });
-    const strategy = yield* getStrategy(StrategyID2.make(stored.strategy), state.get().strategies);
+    const settings = yield* load(row.worktree, current);
+    const strategy = yield* getStrategy(StrategyID2.make(stored.strategy), settings.strategies);
     yield* strategy.remove({
       directory: worktreeDirectory,
       force: input.force
     }).pipe(Effect.mapError((error) => operationError(strategy.id, "remove", error)));
-    yield* changed(yield* ops.remove(worktreeDirectory));
-  });
-  const refresh = Effect.fn("Worktree.refresh")(function* () {
-    yield* local;
-    const stored = yield* ops.list();
+    yield* changed(input.projectID, yield* ops.remove(input.projectID, worktreeDirectory));
+  }, Effect.scoped);
+  const refresh = Effect.fn("Worktree.refresh")(function* (input, current) {
+    const row = yield* project(input.projectID);
+    const settings = yield* load(row.worktree, current);
+    const stored = yield* ops.list(input.projectID);
     const checked = yield* Effect.forEach(stored, (item) => fs.isDir(item.directory).pipe(Effect.map((exists) => ({ ...item, exists }))), { concurrency: "unbounded" });
-    const strategies = Array.from(state.get().strategies.values()).toReversed();
+    const strategies = Array.from(settings.strategies.values()).toReversed();
     const discovered = new Map;
-    if (checked.some((item) => item.directory === location.project.directory && item.exists)) {
+    const roots = new Set([
+      row.worktree,
+      ...checked.filter((item) => item.exists && !item.strategy).map((item) => item.directory)
+    ]);
+    for (const directory of roots) {
+      if (!(yield* fs.isDir(directory)))
+        continue;
       for (const strategy of strategies) {
-        const entries = yield* strategy.list(location.project.directory).pipe(Effect.mapError((error) => operationError(strategy.id, "list", error)), Effect.catchTag("Worktree.DirectoryUnavailableError", () => Effect.succeed([])));
+        const entries = yield* strategy.list(directory).pipe(Effect.mapError((error) => operationError(strategy.id, "list", error)), Effect.catch((error) => Effect.logWarning("worktree discovery failed", { directory, strategy: strategy.id, error }).pipe(Effect.as([]))));
         for (const entry of entries) {
           const directory = yield* canonical2(fs, entry.directory).pipe(Effect.catchTag("Worktree.DirectoryUnavailableError", () => Effect.undefined));
           if (!directory || discovered.has(directory))
@@ -251,28 +246,25 @@ var layer = Layer.effect(Service22, Effect.gen(function* () {
     }
     const removed = checked.filter((item) => !item.exists).map((item) => item.directory);
     const changes = yield* db.transaction((tx) => Effect.all({
-      updated: Effect.filter(Array.from(discovered.values()), (item) => ops.create(item, tx)).pipe(Effect.map((items) => items.map((item) => item.directory))),
-      removed: Effect.filter(removed, (directory) => ops.remove(directory, tx))
+      updated: Effect.filter(Array.from(discovered.values()), (item) => ops.create(input.projectID, item, tx)).pipe(Effect.map((items) => items.map((item) => item.directory))),
+      removed: Effect.filter(removed, (directory) => ops.remove(input.projectID, directory, tx))
     })).pipe(Effect.orDie);
-    yield* changed(changes.updated.length > 0 || changes.removed.length > 0);
-    return changes;
-  });
-  return Service22.of({
-    transform: state.transform,
-    reload: state.reload,
-    list: Effect.fn("Worktree.list")(function* () {
-      yield* refresh();
-      return yield* ops.list();
+    yield* changed(input.projectID, changes.updated.length > 0 || changes.removed.length > 0);
+  }, Effect.scoped);
+  return Service18.of({
+    list: Effect.fn("Worktree.list")(function* (input) {
+      yield* project(input.projectID);
+      return yield* ops.list(input.projectID);
     }),
     create,
     remove,
     refresh
   });
 }));
-var node26 = makeLocationNode({
-  service: Service22,
+var node21 = Node.makeGlobalNode({
+  service: Service18,
   layer,
-  deps: [FSUtil.node, node81, node84, node85, AppProcess.node, node79, Global.node]
+  deps: [FSUtil.node, node85, node82, node86, AppProcess.node, node54]
 });
 function operationError(strategy, operation, error) {
   if (error instanceof WorktreeError2 || error instanceof DirectoryUnavailableError2 || error instanceof Worktree.OperationError)
@@ -282,4 +274,4 @@ function operationError(strategy, operation, error) {
   });
 }
 
-export { StrategyID2, CreateInput3, RemoveInput2, RefreshResult2, Info5, List2, ListEntry3, SourceDirectoryNotFoundError2, DestinationExistsError2, InvalidDirectoryError2, StrategyUnavailableError2, UnsupportedLocationError2, Event6, Service22, node26, exports_worktree2, OperationError2 };
+export { StrategyID2, CreateInput3, RemoveInput2, Info4, List2, ListEntry3, SourceDirectoryNotFoundError2, DestinationExistsError2, InvalidDirectoryError2, StrategyUnavailableError2, Event4, Service18, node21, exports_worktree2, OperationError2 };

package/dist/chunks/{location-services-n9qvx0dx.js → location-4y7mzcta.js}

@@ -1,26 +1,26 @@
 import {
   useragent2
-} from "./location-services-b3frasm9.js";
+} from "./location-1ajyz94d.js";
 import {
-  Service79
-} from "./location-services-69j49pks.js";
+  Service78
+} from "./location-tsjh32me.js";
 import {
   OAuth3,
-  Event15
-} from "./location-services-nwd6ekzm.js";
+  Event19
+} from "./location-aqxshtk7.js";
 import {
-  ID8,
+  ID14,
   MethodID2
-} from "./location-services-htcxsbd3.js";
+} from "./location-gbxnzk38.js";
 import {
   success2,
   error2
-} from "./location-services-pjvnvgmy.js";
+} from "./location-pjvnvgmy.js";
 import {
-  ID18,
+  ID13,
   mergeOverlay2,
   mergeHeaders2
-} from "./location-services-33n3bzdy.js";
+} from "./location-1gfezbxs.js";
 
 // src/plugin/provider/openai.ts
 import { define } from "@opencode/plugin/effect/plugin";
@@ -44,7 +44,7 @@ var Claims = Schema.fromJsonString(Schema.Struct({
 }));
 var decodeClaims = Schema.decodeUnknownOption(Claims);
 var browser = (app) => ({
-  integrationID: ID8.make("openai"),
+  integrationID: ID14.make("openai"),
   method: {
     id: browserMethodID,
     type: "oauth",
@@ -117,7 +117,7 @@ function addressInUse(error) {
   return "code" in error && error.code === "EADDRINUSE";
 }
 var headless = (app) => ({
-  integrationID: ID8.make("openai"),
+  integrationID: ID14.make("openai"),
   method: {
     id: headlessMethodID,
     type: "oauth",
@@ -162,7 +162,7 @@ var headless = (app) => ({
 var OpenAIPlugin2 = define({
   id: "opencode.provider.openai",
   effect: Effect.fn(function* (ctx) {
-    const bus = yield* Service79;
+    const bus = yield* Service78;
     const loading = Semaphore.makeUnsafe(1);
     let chatgpt;
     const load = Effect.fn("OpenAIPlugin.load")(function* () {
@@ -177,27 +177,28 @@ var OpenAIPlugin2 = define({
       editor.method.update(headless(ctx.app));
     });
     yield* load();
-    yield* ctx.catalog.transform((evt) => {
-      const item = evt.provider.get(ID18.openai);
+    yield* ctx.provider.transform((providers) => {
+      const item = providers.get(ID13.openai);
       if (!item)
         return;
-      for (const model of item.models.values()) {
-        evt.model.update(item.provider.id, model.id, (draft) => {
-          draft.capabilities.responsesWebsockets = true;
-          draft.websocket = true;
-        });
-      }
       if (!chatgpt)
         return;
-      item.provider.settings = mergeOverlay2(item.provider.settings, { baseURL: codexBaseURL });
       const account = chatgpt.metadata?.accountID;
-      item.provider.headers = mergeHeaders2(item.provider.headers, {
-        originator: "opencode",
-        "x-codex-beta-features": "remote_compaction_v2",
-        ...typeof account === "string" ? { "chatgpt-account-id": account } : {}
+      providers.update(item.provider.id, (provider) => {
+        provider.settings = mergeOverlay2(provider.settings, { baseURL: codexBaseURL });
+        provider.headers = mergeHeaders2(provider.headers, {
+          originator: "opencode",
+          "x-codex-beta-features": "remote_compaction_v2",
+          ...typeof account === "string" ? { "chatgpt-account-id": account } : {}
+        });
       });
-      for (const model of item.models.values()) {
-        evt.model.update(item.provider.id, model.id, (draft) => {
+    });
+    yield* ctx.model.transform((models) => {
+      for (const model of models.list(ID13.openai)) {
+        models.update(model.providerID, model.id, (draft) => {
+          draft.transport = "websocket";
+          if (!chatgpt)
+            return;
           if (Schema.is(Schema.Struct({ mode: Schema.Literal("pro") }))(draft.body?.reasoning)) {
             draft.enabled = false;
             return;
@@ -222,9 +223,9 @@ var OpenAIPlugin2 = define({
         evt.baseURL = codexBaseURL;
       evt.headers.originator = "opencode";
       evt.headers["session-id"] = evt.sessionID;
-    }), { providerID: ID18.openai });
-    const refresh = () => loading.withPermit(load().pipe(Effect.andThen(ctx.catalog.reload())));
-    yield* bus.subscribe(Event15.Switched).pipe(Stream.filter((event) => event.data.integrationID === ID8.make("openai")), Stream.runForEach(refresh), Effect.forkScoped({ startImmediately: true }));
+    }), { providerID: ID13.openai });
+    const refresh = () => loading.withPermit(load().pipe(Effect.andThen(ctx.provider.reload())));
+    yield* bus.subscribe(Event19.Switched).pipe(Stream.filter((event) => event.data.integrationID === ID14.make("openai")), Stream.runForEach(refresh), Effect.forkScoped({ startImmediately: true }));
   })
 });
 function headers(contentType, app) {