@opencode/core 2.0.19 → 2.0.21

package/dist/chunks/{ripgrep-fgmy5dam.js → job-w85vjd23.js}

@@ -1,58 +1,58 @@
 import {
   Service83,
-  node86
-} from "./ripgrep-jyx4k4a6.js";
+  node87
+} from "./job-vdqv4tww.js";
 import {
-  Service74,
-  node76
-} from "./ripgrep-01g11k9t.js";
+  Service75,
+  node79
+} from "./job-x01dckpp.js";
 import {
   Service81,
-  node84
-} from "./ripgrep-vcctfkdr.js";
+  node85
+} from "./job-k9rsy0a9.js";
 import {
   Ref4,
   Service80,
-  node83
-} from "./ripgrep-87ppwq26.js";
+  node84
+} from "./job-frdvpnjn.js";
 import {
   canonical3
-} from "./ripgrep-hpgwsqwz.js";
+} from "./job-pdpyt1kt.js";
 import {
   SessionEvent2
-} from "./ripgrep-ec1grn59.js";
+} from "./job-ec1grn59.js";
 import {
-  Service51,
-  node53
-} from "./ripgrep-9gz1cjgc.js";
+  Service67,
+  node71
+} from "./job-kfcwqfca.js";
 import {
-  Service45,
-  node47
-} from "./ripgrep-jceb99ws.js";
+  Service24,
+  node27
+} from "./job-deaeaxqh.js";
 import {
   __export
-} from "./ripgrep-9rqn6x4v.js";
+} from "./job-9rqn6x4v.js";
 
 // src/location-lifecycle.ts
 var exports_location_lifecycle = {};
 __export(exports_location_lifecycle, {
   LocationLifecycle: () => exports_location_lifecycle,
-  Service: () => Service16,
-  node: () => node18
+  Service: () => Service21,
+  node: () => node24
 });
 import { Context, Effect, Layer, Schema } from "effect";
 import { makeLocationNode } from "@opencode/util/effect/app-node";
 import { LocationEvent } from "@opencode/schema/location-event";
 var isSessionEvent = Schema.is(SessionEvent2.Durable);
 
-class Service16 extends Context.Service()("@opencode/LocationLifecycle") {
+class Service21 extends Context.Service()("@opencode/LocationLifecycle") {
 }
-var layer = Layer.effect(Service16, Effect.gen(function* () {
+var layer = Layer.effect(Service21, Effect.gen(function* () {
   const bus = yield* Service83;
   const location = yield* Service80;
-  const permission = yield* Service51;
-  const forms = yield* Service74;
-  const rpc = yield* Service45;
+  const permission = yield* Service67;
+  const forms = yield* Service75;
+  const rpc = yield* Service24;
   const project = yield* Service81;
   const scope = yield* Effect.scope;
   yield* project.activate(location.project.id);
@@ -75,15 +75,15 @@ var layer = Layer.effect(Service16, Effect.gen(function* () {
       location: Ref4.make({ directory: location.directory, workspaceID: location.workspaceID })
     });
   }).pipe(Effect.uninterruptible));
-  return Service16.of({
+  return Service21.of({
     isClosed: () => closed,
     shutdown
   });
 }));
-var node18 = makeLocationNode({
-  service: Service16,
+var node24 = makeLocationNode({
+  service: Service21,
   layer,
-  deps: [node86, node83, node53, node84, node76, node47]
+  deps: [node87, node84, node71, node85, node79, node27]
 });
 
-export { Service16, node18, exports_location_lifecycle };
+export { Service21, node24, exports_location_lifecycle };

package/dist/chunks/{ripgrep-psazpmmj.js → job-wd3x2cqz.js}

@@ -1,10 +1,10 @@
 import {
   absoluteColumn2,
   absoluteArrayColumn2
-} from "./ripgrep-6msgmcgs.js";
+} from "./job-6msgmcgs.js";
 import {
   Timestamps2
-} from "./ripgrep-qfa1cgps.js";
+} from "./job-qfa1cgps.js";
 
 // src/project/sql.ts
 import { isNotNull, isNull, ne, or } from "drizzle-orm";

package/dist/chunks/{ripgrep-wd87259q.js → job-wd87259q.js}

@@ -1,7 +1,7 @@
 import {
   getViewSelectedFieldsRuntime2,
   orderSelectedFields2
-} from "./ripgrep-emrn6kk6.js";
+} from "./job-emrn6kk6.js";
 
 // src/database/drizzle/sqlite-core/effect/select.ts
 import { applyEffectWrapper } from "drizzle-orm/effect-core/query-effect";

package/dist/chunks/job-wm3q5ckg.js

@@ -0,0 +1,427 @@
+import {
+  useragent2
+} from "./job-2b6sywcb.js";
+import {
+  Service83
+} from "./job-vdqv4tww.js";
+import {
+  ID15,
+  OAuth3,
+  Event20,
+  Service76
+} from "./job-tbtg7k2g.js";
+import {
+  key2
+} from "./job-mpk0rfs5.js";
+import {
+  ID13,
+  MethodID2
+} from "./job-x5y9z3y2.js";
+import {
+  ID12,
+  mergeOverlay2
+} from "./job-5svcwqmc.js";
+import {
+  ID11,
+  VariantID2,
+  Info25
+} from "./job-vf68ak62.js";
+import {
+  success2,
+  error2
+} from "./job-pjvnvgmy.js";
+
+// src/plugin/provider/chatgpt.ts
+import { define } from "@opencode/plugin/effect/plugin";
+import { Deferred, Duration, Effect, Option, Schema, Semaphore, Stream } from "effect";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+var registrationClientID = "dynamic_agent_client";
+var agentName = "OpenCode";
+var issuer = "https://auth.openai.com";
+var tokenURL = `${issuer}/api/accounts/oauth/token`;
+var resource = "https://api.openai.com/v1";
+var tokenSharingScope = "chatgpt.tokens.use.direct";
+var providerID = ID12.openai;
+var integrationID = ID13.make("openai");
+var methodID = MethodID2.make("chatgpt-token-sharing");
+var modelCacheKey = (clientID) => `models:${clientID}`;
+var fallbackModels = new Set([
+  "gpt-5.5",
+  "gpt-5.5-fast",
+  "gpt-5.6-luna",
+  "gpt-5.6-luna-fast",
+  "gpt-5.6-sol",
+  "gpt-5.6-sol-fast",
+  "gpt-5.6-terra",
+  "gpt-5.6-terra-fast",
+  "gpt-6-astra",
+  "gpt-6-astra-fast"
+]);
+var nonRetryableSharingCodes = [
+  "subscription_sharing_usage_limit_exceeded",
+  "subscription_sharing_user_not_eligible",
+  "subscription_sharing_unsupported_capability",
+  "subscription_sharing_route_not_supported",
+  "subscription_sharing_invalid_user",
+  "chatpass_v2_scope_not_authorized",
+  "chatpass_v2_invalid_authorization_context"
+];
+var RemoteModel = Schema.Struct({
+  slug: Schema.String,
+  display_name: Schema.String,
+  visibility: Schema.String,
+  supported_in_api: Schema.Boolean,
+  context_window: Schema.Int.check(Schema.isGreaterThan(1)),
+  input_modalities: Schema.Array(Schema.String),
+  supported_reasoning_levels: Schema.optional(Schema.Array(Schema.Struct({ effort: Schema.String })))
+});
+var RemoteModels = Schema.Struct({ models: Schema.Array(RemoteModel) });
+var decodeCachedModels = Schema.decodeUnknownOption(Schema.Array(RemoteModel));
+var decodeMetadata = Schema.decodeUnknownOption(Schema.Struct({
+  clientID: Schema.String,
+  scopes: Schema.optional(Schema.Array(Schema.String)),
+  models: Schema.optional(Schema.Array(RemoteModel))
+}));
+var signIn = (app, savedClientID, storage) => ({
+  integrationID,
+  method: {
+    id: methodID,
+    type: "oauth",
+    label: "Sign in with ChatGPT"
+  },
+  authorize: () => Effect.gen(function* () {
+    const storedHostID = yield* storage.get("chatgpt-agent-host-id");
+    const hostID = typeof storedHostID === "string" ? storedHostID : `urn:uuid:${crypto.randomUUID()}`;
+    if (typeof storedHostID !== "string")
+      yield* storage.set("chatgpt-agent-host-id", hostID);
+    const pkce = yield* Effect.promise(generatePKCE);
+    const state = randomValue();
+    const nonce = randomValue();
+    const savedID = savedClientID();
+    const received = yield* Deferred.make();
+    const { createServer } = yield* Effect.promise(() => import("node:http"));
+    const server = createServer((request, response) => {
+      const url = new URL(request.url ?? "/", "http://127.0.0.1");
+      if (url.pathname !== "/auth/callback") {
+        response.writeHead(404).end("Not found");
+        return;
+      }
+      const error = url.searchParams.get("error_description") ?? url.searchParams.get("error");
+      const authorizationCode = url.searchParams.get("code");
+      if (error) {
+        Effect.runFork(Deferred.fail(received, new Error(error)));
+        response.writeHead(400, { "Content-Type": "text/html" }).end(error2(error, { provider: "ChatGPT" }));
+        return;
+      }
+      if (!authorizationCode || url.searchParams.get("state") !== state) {
+        const message = authorizationCode ? "Invalid OAuth state" : "Missing authorization code";
+        Effect.runFork(Deferred.fail(received, new Error(message)));
+        response.writeHead(400, { "Content-Type": "text/html" }).end(error2(message, { provider: "ChatGPT" }));
+        return;
+      }
+      if (!Effect.runSync(Deferred.succeed(received, {
+        code: authorizationCode,
+        clientID: url.searchParams.get("client_id") ?? undefined,
+        response
+      })))
+        response.writeHead(409).end("OAuth callback already received");
+    });
+    const port = yield* listen(server);
+    yield* Effect.addFinalizer(() => Effect.sync(() => server.close()));
+    const redirect = `http://127.0.0.1:${port}/auth/callback`;
+    return {
+      mode: "auto",
+      url: authorizeURL(redirect, pkce, state, nonce, savedID, hostID),
+      instructions: "Complete authorization in your browser. This window will close automatically.",
+      callback: Effect.gen(function* () {
+        const result = yield* Deferred.await(received);
+        const respond = (error) => Effect.sync(() => result.response.writeHead(error ? 400 : 200, { "Content-Type": "text/html" }).end(error ? error2(error, { provider: "ChatGPT" }) : success2({ provider: "ChatGPT" })));
+        return yield* Effect.gen(function* () {
+          if (savedID && result.clientID && result.clientID !== savedID)
+            return yield* Effect.fail(new Error("ChatGPT returned a different client than this connection. Connect again."));
+          const clientID = savedID ?? result.clientID;
+          if (!clientID)
+            return yield* Effect.fail(new Error("ChatGPT sign-in did not return a client ID. Connect again."));
+          const tokens = yield* exchange(result.code, clientID, redirect, pkce, app);
+          if (!tokens.scope?.split(" ").includes(tokenSharingScope))
+            return yield* Effect.fail(new Error("ChatGPT sign-in finished without token sharing. Sign in again and allow token sharing, or connect OpenAI with an API key."));
+          if (!tokens.id_token)
+            return yield* Effect.fail(new Error("ChatGPT sign-in did not return an ID token."));
+          yield* verifyIDToken2(tokens.id_token, clientID, nonce);
+          return credential(tokens, clientID);
+        }).pipe(Effect.tap(() => respond()), Effect.tapError((error) => respond(error instanceof Error ? error.message : "ChatGPT sign-in failed")), Effect.onInterrupt(() => Effect.sync(() => result.response.destroy())));
+      })
+    };
+  }),
+  refresh: (value) => refresh(value, app)
+});
+function listen(server) {
+  return Effect.callback((resume) => {
+    const onError = (error) => resume(Effect.fail(error));
+    server.once("error", onError);
+    server.listen(0, "127.0.0.1", () => {
+      server.off("error", onError);
+      const address = server.address();
+      if (!address || typeof address === "string")
+        return resume(Effect.fail(new Error("Missing OAuth callback port")));
+      resume(Effect.succeed(address.port));
+    });
+  });
+}
+var ChatGPTPlugin2 = define({
+  id: "opencode.provider.chatgpt",
+  effect: Effect.fn(function* (ctx) {
+    const bus = yield* Service83;
+    const credentials = yield* Service76;
+    const loading = Semaphore.makeUnsafe(1);
+    let chatgpt;
+    let available;
+    let source;
+    const load = Effect.fn("ChatGPTPlugin.load")(function* () {
+      const previous = key2(source);
+      const connection = yield* ctx.integration.connection.active(integrationID);
+      const credential = connection ? yield* ctx.integration.connection.resolve(connection).pipe(Effect.orElseSucceed(() => {
+        return;
+      })) : undefined;
+      chatgpt = credential?.type === "oauth" && credential.methodID === methodID ? credential : undefined;
+      source = chatgpt ? connection : undefined;
+      if (previous !== key2(source)) {
+        const metadata = Option.getOrUndefined(decodeMetadata(chatgpt?.metadata));
+        const stored = metadata ? yield* ctx.storage.get(modelCacheKey(metadata.clientID)) : undefined;
+        available = Option.getOrUndefined(decodeCachedModels(stored));
+      }
+    });
+    yield* ctx.integration.transform((editor) => {
+      editor.method.update(signIn(ctx.app, () => Option.getOrUndefined(decodeMetadata(chatgpt?.metadata))?.clientID, ctx.storage));
+    });
+    yield* Effect.forEach(yield* credentials.list(ID13.make("openai")), (entry) => {
+      const value = entry.value;
+      if (value.type !== "oauth" || value.methodID !== MethodID2.make("chatgpt-browser"))
+        return Effect.void;
+      const metadata = Option.getOrUndefined(decodeMetadata(value.metadata));
+      if (!metadata)
+        return Effect.void;
+      return Effect.gen(function* () {
+        const saved = yield* ctx.storage.get(modelCacheKey(metadata.clientID));
+        if (!Option.isSome(decodeCachedModels(saved)) && metadata.models)
+          yield* ctx.storage.set(modelCacheKey(metadata.clientID), metadata.models);
+        const { models: _, ...rest } = value.metadata ?? {};
+        yield* credentials.update(entry.id, {
+          value: OAuth3.make({ ...value, methodID, metadata: rest })
+        });
+      });
+    }, { discard: true });
+    yield* load();
+    yield* ctx.session.hook("retry", (event) => Effect.sync(() => {
+      if (!chatgpt || !nonRetryableSharingCodes.some((code) => event.error.response?.body.includes(code)))
+        return;
+      event.decision = { retry: false };
+    }), { providerID });
+    yield* ctx.provider.transform((providers) => {
+      const item = providers.get(providerID);
+      if (!item)
+        return;
+      if (!chatgpt || !source)
+        return;
+      providers.update(providerID, (provider) => {
+        provider.settings = mergeOverlay2(provider.settings, {
+          baseURL: resource,
+          transport: "http",
+          compaction: { type: "summary" }
+        });
+      });
+      const updated = providers.get(providerID);
+      if (!updated)
+        return;
+      providers.add({
+        info: updated.provider,
+        models: available ? deriveModels2(available, Array.from(item.models.values())) : Array.from(item.models.values()).filter((model) => fallbackModels.has(model.id)),
+        sourceConnection: source
+      });
+    });
+    yield* ctx.model.transform((models) => {
+      for (const model of models.list(providerID)) {
+        models.update(model.providerID, model.id, (draft) => {
+          if (!chatgpt)
+            return;
+          draft.settings = { ...draft.settings, compaction: { type: "summary" } };
+          if (Schema.is(Schema.Struct({ mode: Schema.Literal("pro") }))(draft.body?.reasoning)) {
+            draft.enabled = false;
+            return;
+          }
+          if (available && !available.some((remote) => remote.slug === (draft.modelID ?? draft.id))) {
+            draft.enabled = false;
+            return;
+          }
+          draft.cost = [];
+        });
+      }
+    });
+    const refreshModels = Effect.fn("ChatGPTPlugin.refreshModels")(function* () {
+      const connection = source;
+      const credential = connection?.type === "credential" ? (yield* credentials.get(ID15.make(connection.id)))?.value : undefined;
+      if (credential?.type !== "oauth" || credential.methodID !== methodID || credential.expires <= Date.now() + 60000)
+        return;
+      const metadata = Option.getOrUndefined(decodeMetadata(credential.metadata));
+      if (!metadata)
+        return;
+      const models = yield* fetchModels2(credential.access, ctx.app).pipe(Effect.timeout(15000), Effect.catch(() => Effect.logWarning("failed to refresh ChatGPT models").pipe(Effect.as(undefined))));
+      if (!models)
+        return;
+      yield* loading.withPermit(Effect.gen(function* () {
+        if (key2(connection) !== key2(source) || key2(connection) !== key2(yield* ctx.integration.connection.active(integrationID)))
+          return;
+        if (JSON.stringify(models) === JSON.stringify(available))
+          return;
+        yield* ctx.storage.set(modelCacheKey(metadata.clientID), models);
+        available = models;
+        yield* ctx.provider.reload();
+      }));
+    });
+    const reload = () => loading.withPermit(load().pipe(Effect.andThen(ctx.provider.reload()))).pipe(Effect.andThen(refreshModels().pipe(Effect.forkScoped, Effect.asVoid)));
+    yield* bus.subscribe(Event20.Switched).pipe(Stream.filter((event) => event.data.integrationID === integrationID), Stream.runForEach(reload), Effect.forkScoped({ startImmediately: true }));
+    yield* refreshModels().pipe(Effect.forkScoped);
+    yield* Effect.sleep(Duration.minutes(15)).pipe(Effect.andThen(refreshModels), Effect.forever, Effect.forkScoped);
+  })
+});
+function headers(app) {
+  return { "Content-Type": "application/x-www-form-urlencoded", "User-Agent": useragent2(app) };
+}
+function exchange(code, clientID, redirect, pkce, app) {
+  return request(tokenURL, {
+    method: "POST",
+    headers: headers(app),
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      client_id: clientID,
+      code,
+      code_verifier: pkce.verifier,
+      redirect_uri: redirect,
+      resource
+    }).toString()
+  });
+}
+function refresh(value, app) {
+  return Effect.gen(function* () {
+    const metadata = Option.getOrUndefined(decodeMetadata(value.metadata));
+    if (!metadata)
+      return yield* Effect.fail(new Error("This ChatGPT connection has no registered client ID. Connect again."));
+    const tokens = yield* request(tokenURL, {
+      method: "POST",
+      headers: headers(app),
+      body: new URLSearchParams({
+        grant_type: "refresh_token",
+        client_id: metadata.clientID,
+        refresh_token: value.refresh,
+        resource
+      }).toString()
+    });
+    return credential(tokens, metadata.clientID, metadata.scopes);
+  });
+}
+function fetchModels2(token, app, baseURL = resource) {
+  return Effect.gen(function* () {
+    const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient);
+    const response = yield* http.execute(HttpClientRequest.get(`${baseURL}/models`).pipe(HttpClientRequest.bearerToken(token), HttpClientRequest.setHeader("User-Agent", useragent2(app))));
+    const data = yield* HttpClientResponse.schemaBodyJson(RemoteModels)(response);
+    const models = data.models.filter((model) => model.visibility === "list" && model.supported_in_api);
+    if (!models.length)
+      return yield* Effect.fail(new Error("No ChatGPT models are available for this account."));
+    return models;
+  });
+}
+function deriveModels2(remote, existing) {
+  const byID = new Map(remote.map((model) => [model.slug, model]));
+  const known = new Set(existing.map((model) => model.id));
+  return [
+    ...existing.flatMap((model) => {
+      const found = byID.get(model.modelID);
+      return found ? [deriveModel(found, model)] : [];
+    }),
+    ...remote.filter((model) => !known.has(ID11.make(model.slug))).map((model) => deriveModel(model, Info25.default(ID12.openai, ID11.make(model.slug))))
+  ];
+}
+function deriveModel(remote, previous) {
+  return {
+    ...previous,
+    name: previous.id === previous.modelID ? remote.display_name : previous.name,
+    package: previous.package ?? "@opencode/ai/providers/openai",
+    capabilities: {
+      ...previous.capabilities,
+      input: remote.input_modalities.filter((modality) => modality === "text" || modality === "image")
+    },
+    variants: [
+      ...previous.variants.filter((variant) => typeof variant.settings?.reasoningEffort !== "string"),
+      ...(remote.supported_reasoning_levels ?? []).map(({ effort }) => previous.variants.find((variant) => variant.id === effort && variant.settings?.reasoningEffort === effort) ?? { id: VariantID2.make(effort), settings: { reasoningEffort: effort } })
+    ],
+    limit: { context: remote.context_window, output: previous.limit.output }
+  };
+}
+function verifyIDToken2(token, clientID, nonce, jwksURL = new URL(`${issuer}/.well-known/jwks.json`)) {
+  return Effect.tryPromise({
+    try: async () => {
+      const { createRemoteJWKSet, jwtVerify } = await import("jose");
+      const { payload } = await jwtVerify(token, createRemoteJWKSet(jwksURL), {
+        issuer,
+        audience: clientID,
+        algorithms: ["RS256"],
+        requiredClaims: ["exp", "nonce", "sub"]
+      });
+      if (typeof payload.sub !== "string" || !payload.sub.trim())
+        throw new Error("ID token subject is missing");
+      if (payload.nonce !== nonce)
+        throw new Error("ID token nonce does not match this sign-in attempt");
+    },
+    catch: (cause) => new Error("ChatGPT sign-in returned an invalid ID token.", { cause })
+  });
+}
+function request(url, init) {
+  return Effect.tryPromise({
+    try: async (signal) => {
+      const response = await fetch(url, { ...init, signal });
+      if (!response.ok)
+        throw new Error(`Request failed: ${response.status}`);
+      return response.json();
+    },
+    catch: (cause) => cause
+  });
+}
+function credential(tokens, clientID, scopes) {
+  return OAuth3.make({
+    type: "oauth",
+    methodID,
+    refresh: tokens.refresh_token,
+    access: tokens.access_token,
+    expires: Date.now() + (tokens.expires_in ?? 3600) * 1000,
+    metadata: { clientID, scopes: tokens.scope?.split(" ").filter(Boolean) ?? scopes ?? [] }
+  });
+}
+async function generatePKCE() {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~";
+  const verifier = Array.from(crypto.getRandomValues(new Uint8Array(43)), (byte) => chars[byte % chars.length]).join("");
+  const challenge = base64UrlEncode(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier)));
+  return { verifier, challenge };
+}
+function randomValue() {
+  return base64UrlEncode(crypto.getRandomValues(new Uint8Array(32)).buffer);
+}
+function base64UrlEncode(buffer) {
+  return Buffer.from(buffer).toString("base64url");
+}
+function authorizeURL(redirect, pkce, state, nonce, savedID, hostID) {
+  return `${issuer}/api/accounts/authorize?${new URLSearchParams({
+    client_id: savedID ?? registrationClientID,
+    ...savedID ? {} : { agent_name_hint: agentName },
+    ext_agent_host_id: hostID,
+    response_type: "code",
+    redirect_uri: redirect,
+    scope: `openid profile email offline_access resource.invoke ${tokenSharingScope}`,
+    resource,
+    state,
+    nonce,
+    code_challenge_method: "S256",
+    code_challenge: pkce.challenge
+  })}`;
+}
+
+export { ChatGPTPlugin2, fetchModels2, deriveModels2, verifyIDToken2 };

package/dist/chunks/{ripgrep-m3ra8jyf.js → job-wpv4xhp3.js}

@@ -1,28 +1,28 @@
 import {
   Service80
-} from "./ripgrep-87ppwq26.js";
+} from "./job-frdvpnjn.js";
 import {
   latest2,
-  Service66
-} from "./ripgrep-gn9knv9y.js";
+  Service51
+} from "./job-f09mb087.js";
 import {
-  Service14
-} from "./ripgrep-wpj1vscs.js";
+  Service56
+} from "./job-jk9p3pr1.js";
 import {
   make10
-} from "./ripgrep-73tb2d7t.js";
+} from "./job-73tb2d7t.js";
 import {
   observe2
-} from "./ripgrep-qsdy395h.js";
+} from "./job-qsdy395h.js";
 import {
   __export
-} from "./ripgrep-9rqn6x4v.js";
+} from "./job-9rqn6x4v.js";
 
 // src/config/plugin/formatter.ts
 var exports_formatter = {};
 __export(exports_formatter, {
   ConfigFormatterPlugin: () => exports_formatter,
-  Plugin: () => Plugin3
+  Plugin: () => Plugin10
 });
 import { define } from "@opencode/plugin/effect/plugin";
 import { FSUtil } from "@opencode/util/fs-util";
@@ -30,11 +30,11 @@ import { Global } from "@opencode/util/global";
 import { Npm } from "@opencode/util/npm";
 import { AppProcess } from "@opencode/util/process";
 import { Effect } from "effect";
-var Plugin3 = define({
+var Plugin10 = define({
   id: "opencode.config.formatter",
   effect: Effect.fn(function* (ctx) {
-    const config = yield* Service66;
-    const formatter = yield* Service14;
+    const config = yield* Service51;
+    const formatter = yield* Service56;
     const fs = yield* FSUtil.Service;
     const global = yield* Global.Service;
     const location = yield* Service80;
@@ -74,4 +74,4 @@ var Plugin3 = define({
   })
 });
 
-export { Plugin3, exports_formatter };
+export { Plugin10, exports_formatter };