@opencode/core 0.0.0-dev-20300 → 0.0.0-dev-20307

package/dist/chunks/{event-logger-cr1rmkmp.js → config-4kd7e6ys.js}

@@ -1,18 +1,18 @@
 import {
   Service50
-} from "./event-logger-h896pcm5.js";
+} from "./config-h896pcm5.js";
 import {
   awaitActivation2
-} from "./event-logger-1x11rq2a.js";
+} from "./config-9sh4wc5j.js";
 import {
-  Service37
-} from "./event-logger-9bfk5xdd.js";
+  Service42
+} from "./config-vk0rzmvc.js";
 import {
   unavailable2
-} from "./event-logger-vzs5sf6e.js";
+} from "./config-vzs5sf6e.js";
 import {
   __export
-} from "./event-logger-9rqn6x4v.js";
+} from "./config-9rqn6x4v.js";
 
 // src/session/shell.ts
 var exports_shell3 = {};
@@ -23,7 +23,7 @@ __export(exports_shell3, {
 import { Effect } from "effect";
 var start2 = Effect.fn("SessionShell.start")(function* (input) {
   const instances = yield* Service50;
-  const shell = yield* awaitActivation2.pipe(Effect.andThen(Service37), instances.provide(input.session));
+  const shell = yield* awaitActivation2.pipe(Effect.andThen(Service42), instances.provide(input.session));
   const info = yield* shell.create({
     command: input.command,
     cwd: input.session.location.directory,

package/dist/chunks/{event-logger-p2864vt2.js → config-4kmetaym.js}

@@ -1,53 +1,53 @@
 import {
-  Service83,
-  node87
-} from "./event-logger-nez6t23e.js";
+  Service82,
+  node86
+} from "./config-d7syg0tc.js";
 import {
-  node49
-} from "./event-logger-fepyq996.js";
+  node68
+} from "./config-syj77zjw.js";
 import {
-  Service11,
-  node13
-} from "./event-logger-tpxm4wg4.js";
+  Service9,
+  node11
+} from "./config-yfcxk4hn.js";
 import {
-  Service27
-} from "./event-logger-1x11rq2a.js";
+  Service32
+} from "./config-9sh4wc5j.js";
 import {
   node25,
   ID3
-} from "./event-logger-txcf0vz9.js";
+} from "./config-5fn2wwsq.js";
 import {
   Service4,
-  node6
-} from "./event-logger-5xtgfte3.js";
+  node5
+} from "./config-p37cw4rj.js";
 import {
   requirements2,
   guarded2,
   list2
-} from "./event-logger-8pnxeyxd.js";
+} from "./config-32775zb7.js";
 import {
-  make4,
+  make3,
   LoadError2
-} from "./event-logger-rdcxwqtg.js";
+} from "./config-gvw0fbgk.js";
 import {
   Updated2,
-  Service5,
-  node7
-} from "./event-logger-vq7dkmg6.js";
+  Service2,
+  node3
+} from "./config-s8fxn872.js";
 import {
   Service3,
-  node5
-} from "./event-logger-k79tzb9n.js";
+  node4
+} from "./config-0jq9fyba.js";
 import {
   __export
-} from "./event-logger-9rqn6x4v.js";
+} from "./config-9rqn6x4v.js";
 
 // src/plugin/supervisor.ts
 var exports_supervisor = {};
 __export(exports_supervisor, {
   PluginSupervisor: () => exports_supervisor,
-  layer: () => layer4,
-  node: () => node4
+  layer: () => layer3,
+  node: () => node2
 });
 import { Event } from "@opencode/schema/config";
 import { Cause, Effect, Layer, Queue, Stream } from "effect";
@@ -125,13 +125,13 @@ var resolve = Effect.fn("PluginSupervisor.resolve")(function* (modules, pre, pos
     pending: [...pending]
   };
 });
-var layer4 = Layer.effectDiscard(Effect.gen(function* () {
-  const registry = yield* Service27;
-  const sdk = yield* Service5;
+var layer3 = Layer.effectDiscard(Effect.gen(function* () {
+  const registry = yield* Service32;
+  const sdk = yield* Service2;
   const instance = yield* Service4;
-  const sources = yield* Service11;
-  const modules = yield* make4();
-  const bus = yield* Service83;
+  const sources = yield* Service9;
+  const modules = yield* make3();
+  const bus = yield* Service82;
   const updates = yield* Service3;
   const internal = yield* list2();
   let release = yield* registry.hold();
@@ -208,13 +208,13 @@ var layer4 = Layer.effectDiscard(Effect.gen(function* () {
 }));
 var nodeDeps = [
   node25,
-  node7,
-  node6,
-  node13,
+  node3,
   node5,
-  node87,
+  node11,
+  node4,
+  node86,
   Npm.node,
-  node49,
+  node68,
   requirements2
 ];
 function pluginSource(target) {
@@ -222,6 +222,6 @@ function pluginSource(target) {
     return { type: "local", path: target };
   return { type: "package", target };
 }
-var node4 = makeLocationNode({ name: "plugin-supervisor", layer: layer4, deps: nodeDeps });
+var node2 = makeLocationNode({ name: "plugin-supervisor", layer: layer3, deps: nodeDeps });
 
-export { layer4, node4, exports_supervisor };
+export { layer3, node2, exports_supervisor };

package/dist/chunks/config-4n7khwcq.js

@@ -0,0 +1,427 @@
+import {
+  useragent2
+} from "./config-bhemr9wh.js";
+import {
+  Service82
+} from "./config-d7syg0tc.js";
+import {
+  ID10,
+  OAuth3,
+  Event16,
+  Service70
+} from "./config-arjb37bx.js";
+import {
+  key2
+} from "./config-addxnjmp.js";
+import {
+  ID9,
+  MethodID2
+} from "./config-sve1nj7a.js";
+import {
+  ID8,
+  mergeOverlay2
+} from "./config-0q3s84gs.js";
+import {
+  ID7,
+  VariantID2,
+  Info21
+} from "./config-byf60vcv.js";
+import {
+  success2,
+  error2
+} from "./config-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 = ID8.openai;
+var integrationID = ID9.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* Service82;
+    const credentials = yield* Service70;
+    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(ID9.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(ID10.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(Event16.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(ID7.make(model.slug))).map((model) => deriveModel(model, Info21.default(ID8.openai, ID7.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/{event-logger-mwwxnxty.js → config-4wwqnvbr.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./event-logger-9rqn6x4v.js";
+} from "./config-9rqn6x4v.js";
 
 // src/tool/plugin/opencode.ts
 var exports_opencode = {};
@@ -8,7 +8,7 @@ __export(exports_opencode, {
   ModelsInput: () => ModelsInput2,
   MoveInput: () => MoveInput2,
   OpenCodeTools: () => exports_opencode,
-  Plugin: () => Plugin23,
+  Plugin: () => Plugin21,
   RenameInput: () => RenameInput2
 });
 import { SystemPart, ToolFailure } from "@opencode/ai";
@@ -64,7 +64,7 @@ var ModelsOutput = Schema.Struct({
   total: Schema.Int.annotate({ description: "Number of matching models across all pages." }),
   next: Schema.NullOr(Schema.Int).annotate({ description: "Offset of the next page, or null on the last page." })
 });
-var Plugin23 = {
+var Plugin21 = {
   id: "opencode.tools",
   effect: Effect.fn("OpenCodeTools.Plugin")(function* (ctx) {
     const hook = (event) => Effect.sync(() => {
@@ -161,4 +161,4 @@ var Plugin23 = {
   })
 };
 
-export { RenameInput2, MoveInput2, ModelsInput2, Plugin23, exports_opencode };
+export { RenameInput2, MoveInput2, ModelsInput2, Plugin21, exports_opencode };