@opencode/core 2.0.15 → 2.0.17

package/dist/chunks/{location-15y6myyc.js → schema-tjz0sjs3.js}

@@ -3,29 +3,29 @@ import {
   removed2,
   make20,
   diffByKey2
-} from "./location-rhjbct0v.js";
+} from "./schema-rhjbct0v.js";
 import {
   evaluate2
-} from "./location-cje11ec7.js";
+} from "./schema-drgwwxwg.js";
 import {
-  Service34,
-  node38
-} from "./location-xq3yw8dy.js";
+  Service27,
+  node30
+} from "./schema-vmnfmpbz.js";
 import {
   namespace2,
-  name13
-} from "./location-hvtd657f.js";
+  name14
+} from "./schema-9a5xxas0.js";
 import {
   __export
-} from "./location-9rqn6x4v.js";
+} from "./schema-9rqn6x4v.js";
 
 // src/mcp/instructions.ts
-var exports_instructions2 = {};
-__export(exports_instructions2, {
-  McpInstructions: () => exports_instructions2,
-  Service: () => Service30,
+var exports_instructions5 = {};
+__export(exports_instructions5, {
+  McpInstructions: () => exports_instructions5,
+  Service: () => Service25,
   layer: () => layer12,
-  node: () => node34
+  node: () => node28
 });
 import { makeLocationNode } from "@opencode/util/effect/app-node";
 import { Context, Effect, Layer, Schema } from "effect";
@@ -61,11 +61,11 @@ var update = (previous, current) => {
 `);
 };
 
-class Service30 extends Context.Service()("@opencode/McpInstructions") {
+class Service25 extends Context.Service()("@opencode/McpInstructions") {
 }
-var layer12 = Layer.effect(Service30, Effect.gen(function* () {
-  const mcp = yield* Service34;
-  return Service30.of({
+var layer12 = Layer.effect(Service25, Effect.gen(function* () {
+  const mcp = yield* Service27;
+  return Service25.of({
     load: Effect.fn("McpInstructions.load")(function* (permissions) {
       const source = (value) => make20({
         key: Key3.make("core/mcp-guidance"),
@@ -86,7 +86,7 @@ var layer12 = Layer.effect(Service30, Effect.gen(function* () {
         const codemode = owned[0]?.codemode !== false;
         if (codemode && !canExecute)
           return [];
-        if (!owned.some((tool) => evaluate2(name13(tool.server, tool.name), "*", permissions).effect !== "deny"))
+        if (!owned.some((tool) => evaluate2(name14(tool.server, tool.name), "*", permissions).effect !== "deny"))
           return [];
         return [
           codemode ? { server: item.server, instructions: item.instructions } : { server: item.server, instructions: item.instructions, codemode: false }
@@ -96,6 +96,6 @@ var layer12 = Layer.effect(Service30, Effect.gen(function* () {
     })
   });
 }));
-var node34 = makeLocationNode({ service: Service30, layer: layer12, deps: [node38] });
+var node28 = makeLocationNode({ service: Service25, layer: layer12, deps: [node30] });
 
-export { Service30, layer12, node34, exports_instructions2 };
+export { Service25, layer12, node28, exports_instructions5 };

package/dist/chunks/{location-yvvvp4gn.js → schema-tk9ew89t.js}

@@ -1,22 +1,22 @@
 import {
   __export
-} from "./location-9rqn6x4v.js";
+} from "./schema-9rqn6x4v.js";
 
 // src/session/environment.ts
 var exports_environment = {};
 __export(exports_environment, {
-  Service: () => Service43,
+  Service: () => Service31,
   SessionEnvironment: () => exports_environment,
-  node: () => node46
+  node: () => node34
 });
 import { Context, Effect, Layer } from "effect";
 import { makeGlobalNode } from "@opencode/util/effect/app-node";
 
-class Service43 extends Context.Service()("@opencode/SessionEnvironment") {
+class Service31 extends Context.Service()("@opencode/SessionEnvironment") {
 }
-var layer = Layer.sync(Service43, () => {
+var layer = Layer.sync(Service31, () => {
   const environments = new Map;
-  return Service43.of({
+  return Service31.of({
     get: (sessionID) => Effect.sync(() => environments.get(sessionID)),
     set: (sessionID, variables) => Effect.sync(() => {
       environments.set(sessionID, { ...variables });
@@ -26,6 +26,6 @@ var layer = Layer.sync(Service43, () => {
     })
   });
 });
-var node46 = makeGlobalNode({ service: Service43, layer, deps: [] });
+var node34 = makeGlobalNode({ service: Service31, layer, deps: [] });
 
-export { Service43, node46, exports_environment };
+export { Service31, node34, exports_environment };

package/dist/chunks/{location-tvtrv512.js → schema-tvtrv512.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./location-9rqn6x4v.js";
+} from "./schema-9rqn6x4v.js";
 
 // src/id/id.ts
 var exports_id = {};

package/dist/chunks/schema-v1faaxn9.js

@@ -0,0 +1,18 @@
+import {
+  __export
+} from "./schema-9rqn6x4v.js";
+
+// src/plugin/service.ts
+var exports_service = {};
+__export(exports_service, {
+  Plugin: () => exports_service,
+  Service: () => Service24,
+  awaitActivation: () => awaitActivation2
+});
+import { Context } from "effect";
+
+class Service24 extends Context.Service()("@opencode/Plugin") {
+}
+var awaitActivation2 = Service24.use((plugins) => plugins.awaitActivation);
+
+export { Service24, awaitActivation2, exports_service };

package/dist/chunks/{location-dagkn99r.js → schema-v3sgzvyr.js}

@@ -1,7 +1,7 @@
 import {
   isCheckpoint2,
   decode2
-} from "./location-18s9r5gn.js";
+} from "./schema-ssdqnhy0.js";
 
 // src/session/runner/to-llm-message.ts
 import {

package/dist/chunks/schema-v7ytqzq6.js

@@ -0,0 +1,339 @@
+import {
+  useragent2
+} from "./schema-21fjxxq6.js";
+import {
+  Service82
+} from "./schema-cmsm0fmq.js";
+import {
+  OAuth3,
+  Event19
+} from "./schema-h3v3gq1k.js";
+import {
+  ID14,
+  MethodID2
+} from "./schema-6xg4rx5y.js";
+import {
+  key2
+} from "./schema-h6r3nrb9.js";
+import {
+  ID13,
+  aisdk2,
+  Service75
+} from "./schema-qw1f8ej3.js";
+import {
+  ID12,
+  Info26
+} from "./schema-evs9c0ef.js";
+import {
+  success2,
+  error2
+} from "./schema-pjvnvgmy.js";
+
+// src/plugin/provider/gitlab.ts
+import os from "os";
+import { Clock, Deferred, Effect, Exit, Option, Schema, Semaphore, Stream } from "effect";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import { define } from "@opencode/plugin/effect/plugin";
+import { Form } from "@opencode/schema/form";
+var providerID = ID13.gitlab;
+var integrationID = ID14.make("gitlab");
+var methodID = MethodID2.make("pkce");
+var bundledClientID = "fd180700a8f9c5d5557aca231632dd0611a1135a3bb510a741d5a988a3394fa7";
+var legacyClientID = "1d89f9fdb23ee96d4e603201f6861dab6e143c5c3c00469a018a2d94bdc03d4e";
+var gitlabComHost = "gitlab.com";
+var oauthScope = "api";
+var callbackHost = "127.0.0.1";
+var callbackPort = 8080;
+var redirectURI = `http://${callbackHost}:${callbackPort}/callback`;
+var Token = Schema.Struct({
+  access_token: Schema.NonEmptyString,
+  refresh_token: Schema.NonEmptyString,
+  expires_in: Schema.optional(Schema.Number)
+});
+var decodeError = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Struct({ error: Schema.optional(Schema.String), error_description: Schema.optional(Schema.String) })));
+var discoveryTimeout = "10 seconds";
+var refreshing = new Map;
+var refreshRetention = 60000;
+var GitLabPlugin2 = define({
+  id: "opencode.provider.gitlab",
+  effect: Effect.fn(function* (ctx) {
+    const providers = yield* Service75;
+    const bus = yield* Service82;
+    const http = yield* HttpClient.HttpClient;
+    const loading = Semaphore.makeUnsafe(1);
+    const loaded = {};
+    const load = Effect.fn("GitLabPlugin.load")(function* () {
+      const connection = yield* ctx.integration.connection.active(integrationID);
+      const stored = connection?.type === "credential" ? connection : undefined;
+      const credential = stored ? yield* ctx.integration.connection.resolve(stored).pipe(Effect.orElseSucceed(() => {
+        return;
+      })) : undefined;
+      if (!stored || !credential) {
+        loaded.models = undefined;
+        loaded.connection = undefined;
+        return;
+      }
+      const provider = yield* providers.get(providerID);
+      const instanceUrl = credential.type === "oauth" && typeof credential.metadata?.instanceUrl === "string" ? credential.metadata.instanceUrl : typeof provider?.settings?.instanceUrl === "string" ? provider.settings.instanceUrl : resolveDefaultInstanceUrl();
+      const headers = credential.type === "oauth" ? { Authorization: `Bearer ${credential.access}` } : { "PRIVATE-TOKEN": credential.key };
+      const remote = yield* Effect.tryPromise({
+        try: async (signal) => {
+          const { discoverWorkflowModels } = await import("gitlab-ai-provider");
+          return discoverWorkflowModels({
+            instanceUrl,
+            getHeaders: () => headers,
+            fetch: Object.assign((input, init) => fetch(input, { ...init, signal: init?.signal ? AbortSignal.any([init.signal, signal]) : signal }), { preconnect: fetch.preconnect })
+          }, { workingDirectory: ctx.location.directory, cacheKey: stored.id });
+        },
+        catch: (cause) => cause
+      }).pipe(Effect.timeout(discoveryTimeout), Effect.catch((cause) => Effect.logWarning("failed to discover GitLab workflow models", { cause }).pipe(Effect.as(undefined))));
+      if (key2(connection) !== key2(yield* ctx.integration.connection.active(integrationID)))
+        return;
+      loaded.models = remote?.models;
+      loaded.connection = connection;
+    });
+    yield* ctx.integration.transform((editor) => {
+      editor.method.update({
+        integrationID,
+        method: {
+          id: methodID,
+          type: "oauth",
+          label: "Login with GitLab (OAuth)",
+          form: Form.Fields.make([
+            {
+              type: "string",
+              key: "instanceUrl",
+              title: "GitLab instance URL",
+              description: "Leave the default to use gitlab.com, or enter your self-managed GitLab URL.",
+              placeholder: resolveDefaultInstanceUrl(),
+              default: resolveDefaultInstanceUrl(),
+              pattern: "^https?://\\S+$"
+            }
+          ])
+        },
+        label: (value) => new URL(credentialInstanceUrl(value.metadata)).host,
+        refresh: (value) => {
+          const instanceUrl = credentialInstanceUrl(value.metadata);
+          const clientID = (typeof value.metadata?.clientID === "string" ? value.metadata.clientID : undefined) || process.env.GITLAB_OAUTH_CLIENT_ID?.trim() || legacyClientID;
+          return singleFlight(`${instanceUrl}\x00${value.refresh}`, exchange(http, instanceUrl, clientID, { grant_type: "refresh_token", refresh_token: value.refresh, redirect_uri: redirectURI }, describeRefreshFailure).pipe(Effect.flatMap((tokens) => credential(instanceUrl, clientID, tokens))));
+        },
+        authorize: (answer) => Effect.gen(function* () {
+          const override = process.env.GITLAB_OAUTH_CLIENT_ID?.trim();
+          const clientID = override || bundledClientID;
+          const url = new URL((typeof answer.instanceUrl === "string" ? answer.instanceUrl.trim() : "") || resolveDefaultInstanceUrl());
+          const instanceUrl = `${url.origin}${url.pathname.replace(/\/+$/, "")}`;
+          if (!override && url.host !== gitlabComHost)
+            return yield* Effect.fail(new Error(`The bundled GitLab OAuth application only exists on ${gitlabComHost}. To sign in to ${url.host},` + ` register an OAuth application there with redirect URI ${redirectURI} and the \`${oauthScope}\`` + ` scope (not marked "Confidential"), then set GITLAB_OAUTH_CLIENT_ID to its application ID.`));
+          const verifier = Buffer.from(crypto.getRandomValues(new Uint8Array(32))).toString("base64url");
+          const challenge = Buffer.from(yield* Effect.promise(() => crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier)))).toString("base64url");
+          const state = Buffer.from(crypto.getRandomValues(new Uint8Array(32))).toString("base64url");
+          const callback = yield* Deferred.make();
+          const { createServer } = yield* Effect.promise(() => import("node:http"));
+          const server = createServer((request, response) => {
+            const url = new URL(request.url ?? "/", `http://${callbackHost}`);
+            if (request.method !== "GET" || url.pathname !== "/callback") {
+              response.writeHead(404).end();
+              return;
+            }
+            const error = callbackError(url.searchParams, state);
+            if (error) {
+              response.writeHead(400, { "Content-Type": "text/html" }).end(error2(error, { provider: "GitLab" }));
+              Effect.runSync(Deferred.fail(callback, new Error(error)));
+              return;
+            }
+            if (!Effect.runSync(Deferred.succeed(callback, { code: url.searchParams.get("code") ?? "", response })))
+              response.writeHead(409).end("OAuth callback already received");
+          });
+          yield* Effect.addFinalizer(() => Effect.sync(() => {
+            server.close();
+            server.closeAllConnections();
+          }));
+          yield* listen(server);
+          return {
+            mode: "auto",
+            url: `${instanceUrl}/oauth/authorize?${new URLSearchParams({
+              client_id: clientID,
+              redirect_uri: redirectURI,
+              response_type: "code",
+              state,
+              scope: oauthScope,
+              code_challenge: challenge,
+              code_challenge_method: "S256"
+            }).toString()}`,
+            instructions: "Complete authorization in your browser. This window will close automatically.",
+            callback: Effect.gen(function* () {
+              const request = yield* Deferred.await(callback);
+              const respond = (error) => Effect.sync(() => request.response.writeHead(error ? 400 : 200, { "Content-Type": "text/html" }).end(error ? error2(error, { provider: "GitLab" }) : success2({ provider: "GitLab" })));
+              return yield* exchange(http, instanceUrl, clientID, {
+                grant_type: "authorization_code",
+                code: request.code,
+                redirect_uri: redirectURI,
+                code_verifier: verifier
+              }, describeGrantFailure).pipe(Effect.flatMap((tokens) => credential(instanceUrl, clientID, tokens)), Effect.tap(() => respond()), Effect.tapError((error) => respond(error.message)), Effect.onInterrupt(() => Effect.sync(() => request.response.destroy())));
+            })
+          };
+        })
+      });
+    });
+    yield* ctx.provider.transform((editor) => {
+      const item = editor.get(providerID);
+      if (!item || !loaded.models?.length)
+        return;
+      editor.add({
+        info: item.provider,
+        sourceConnection: loaded.connection,
+        models: [
+          ...item.models.values(),
+          ...loaded.models.filter((model) => !item.models.has(model.id)).map((model) => ({
+            ...Info26.default(providerID, ID12.make(model.id)),
+            name: `Agent Platform (${model.name})`,
+            package: aisdk2("gitlab-ai-provider"),
+            settings: { workflowRef: model.ref },
+            capabilities: { tools: true, input: ["text", "image", "pdf"], output: ["text"] },
+            limit: { context: model.context, output: model.output }
+          }))
+        ]
+      });
+    });
+    const refresh = () => loading.withPermit(load().pipe(Effect.andThen(ctx.provider.reload())));
+    yield* bus.subscribe(Event19.Switched).pipe(Stream.filter((event) => event.data.integrationID === integrationID), Stream.runForEach(refresh), Effect.forkScoped({ startImmediately: true }));
+    yield* refresh().pipe(Effect.forkScoped);
+    yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+      if (evt.package !== "gitlab-ai-provider")
+        return;
+      const mod = yield* Effect.promise(() => import("gitlab-ai-provider"));
+      evt.sdk = mod.createGitLab({
+        ...evt.options,
+        instanceUrl: typeof evt.options.instanceUrl === "string" ? evt.options.instanceUrl : process.env.GITLAB_INSTANCE_URL ?? "https://gitlab.com",
+        apiKey: typeof evt.options.apiKey === "string" ? evt.options.apiKey : process.env.GITLAB_TOKEN,
+        aiGatewayHeaders: {
+          "User-Agent": `${useragent2(ctx.app)} gitlab-ai-provider/${mod.VERSION} (${os.platform()} ${os.release()}; ${os.arch()})`,
+          "anthropic-beta": "context-1m-2025-08-07",
+          ...evt.options.aiGatewayHeaders
+        },
+        featureFlags: {
+          duo_agent_platform_agentic_chat: true,
+          duo_agent_platform: true,
+          ...evt.options.featureFlags
+        }
+      });
+    }));
+    yield* ctx.aisdk.hook("language", Effect.fn(function* (evt) {
+      if (evt.model.providerID !== ID13.gitlab)
+        return;
+      const featureFlags = typeof evt.options.featureFlags === "object" && evt.options.featureFlags ? evt.options.featureFlags : {};
+      const id = evt.model.modelID ?? evt.model.id;
+      if (id.startsWith("duo-workflow-")) {
+        const gitlab = yield* Effect.promise(() => import("gitlab-ai-provider"));
+        const workflowRef = typeof evt.model.settings?.workflowRef === "string" ? evt.model.settings.workflowRef : undefined;
+        const workflowDefinition = typeof evt.model.settings?.workflowDefinition === "string" ? evt.model.settings.workflowDefinition : undefined;
+        const language = evt.sdk.workflowChat(gitlab.isWorkflowModel(id) ? id : "duo-workflow", {
+          featureFlags,
+          workflowDefinition
+        });
+        if (workflowRef)
+          language.selectedModelRef = workflowRef;
+        evt.language = language;
+        return;
+      }
+      evt.language = evt.sdk.agenticChat(id, {
+        aiGatewayHeaders: evt.options.aiGatewayHeaders,
+        featureFlags
+      });
+    }));
+  })
+});
+function resolveDefaultInstanceUrl() {
+  return process.env.GITLAB_INSTANCE_URL ?? "https://gitlab.com";
+}
+function credentialInstanceUrl(metadata) {
+  const value = metadata?.instanceUrl;
+  return typeof value === "string" && value ? value : resolveDefaultInstanceUrl();
+}
+function describeClient(clientID) {
+  const source = clientID === bundledClientID ? "bundled default" : clientID === legacyClientID ? "opencode-gitlab-auth application" : "from GITLAB_OAUTH_CLIENT_ID";
+  return `client_id used: ${clientID.slice(0, 12)}... (${source})`;
+}
+function describeGrantFailure(detail, clientID) {
+  const custom = clientID !== bundledClientID;
+  const hints = [
+    "the authorization code was already used, or came from an older login attempt. Codes are" + " single-use and bound to one PKCE verifier, so a stale browser tab or a reloaded callback" + " page fails here. Start a completely fresh login.",
+    `redirect_uri sent: ${redirectURI} — the application must register this exactly`,
+    describeClient(clientID)
+  ];
+  if (custom) {
+    hints.push("confirm that application registers the redirect URI above, grants the `api` scope, and is" + ' NOT marked "Confidential" (PKCE requires a public client). Unset GITLAB_OAUTH_CLIENT_ID to' + " fall back to the bundled application.");
+  }
+  return `${detail}
+
+Likely causes:
+- ${hints.join(`
+- `)}`;
+}
+function describeRefreshFailure(detail, clientID) {
+  return `${detail}
+
+The GitLab refresh token was revoked, expired, or issued to a different OAuth` + ` application (${describeClient(clientID)}). Sign in to GitLab again.`;
+}
+function exchange(http, instanceUrl, clientID, body, describe) {
+  return Effect.gen(function* () {
+    const response = yield* http.execute(HttpClientRequest.post(`${instanceUrl}/oauth/token`).pipe(HttpClientRequest.bodyUrlParams({ ...body, client_id: clientID }))).pipe(Effect.mapError(() => new Error("GitLab token exchange request failed")));
+    if (response.status < 200 || response.status >= 300) {
+      const parsed = Option.getOrUndefined(decodeError(yield* response.text.pipe(Effect.orElseSucceed(() => ""))));
+      const detail = parsed?.error_description || parsed?.error || `HTTP ${response.status}`;
+      const rejected = parsed?.error === "invalid_grant" || parsed?.error === "invalid_client";
+      return yield* Effect.fail(new Error(rejected ? describe(detail, clientID) : detail));
+    }
+    return yield* HttpClientResponse.schemaBodyJson(Token)(response).pipe(Effect.mapError(() => new Error("Invalid GitLab token response")));
+  });
+}
+function credential(instanceUrl, clientID, tokens) {
+  return Effect.map(Clock.currentTimeMillis, (now) => OAuth3.make({
+    type: "oauth",
+    methodID,
+    access: tokens.access_token,
+    refresh: tokens.refresh_token,
+    expires: now + (tokens.expires_in ?? 7200) * 1000,
+    metadata: { instanceUrl, clientID }
+  }));
+}
+function singleFlight(key, effect) {
+  return Effect.gen(function* () {
+    const now = yield* Clock.currentTimeMillis;
+    refreshing.forEach((entry, entryKey) => {
+      if (entry.until < now)
+        refreshing.delete(entryKey);
+    });
+    const existing = refreshing.get(key);
+    if (existing)
+      return yield* Deferred.await(existing.attempt);
+    const attempt = Deferred.makeUnsafe();
+    refreshing.set(key, { attempt, until: Number.POSITIVE_INFINITY });
+    return yield* effect.pipe(Effect.onExit((exit) => Effect.map(Clock.currentTimeMillis, (settledAt) => {
+      if (Exit.isSuccess(exit))
+        refreshing.set(key, { attempt, until: settledAt + refreshRetention });
+      if (Exit.isFailure(exit))
+        refreshing.delete(key);
+      Deferred.doneUnsafe(attempt, exit);
+    })));
+  });
+}
+function callbackError(params, state) {
+  if (params.get("state") !== state)
+    return "Invalid OAuth state";
+  if (params.has("error"))
+    return params.get("error_description") || params.get("error") || "Authorization denied";
+  return params.get("code")?.trim() ? undefined : "Missing authorization code";
+}
+function listen(server) {
+  return Effect.callback((resume) => {
+    const onError = (error) => resume(Effect.fail(error));
+    server.once("error", onError);
+    server.listen(callbackPort, callbackHost, () => {
+      server.off("error", onError);
+      resume(Effect.void);
+    });
+  }).pipe(Effect.mapError((cause) => ("code" in cause) && cause.code === "EADDRINUSE" ? new Error(`GitLab login needs local port ${callbackPort}, but it is already in use. Stop the process using that port and try again.`) : cause));
+}
+
+export { GitLabPlugin2 };

package/dist/chunks/{location-8ec97xvv.js → schema-v9315egx.js}

@@ -1,18 +1,18 @@
 import {
-  Service49
-} from "./location-c8bydgjz.js";
+  Service41
+} from "./schema-vqfzq50h.js";
 import {
   awaitActivation2
-} from "./location-n95b3jav.js";
+} from "./schema-v1faaxn9.js";
 import {
   SkillNotFoundError2
-} from "./location-ygg1f209.js";
+} from "./schema-0e81x99y.js";
 import {
-  Service59
-} from "./location-dgpq7z8n.js";
+  Service56
+} from "./schema-wx7ymqfy.js";
 import {
   __export
-} from "./location-9rqn6x4v.js";
+} from "./schema-9rqn6x4v.js";
 
 // src/session/skill.ts
 var exports_skill4 = {};
@@ -22,8 +22,8 @@ __export(exports_skill4, {
 });
 import { Effect } from "effect";
 var get4 = Effect.fn("SessionSkill.get")(function* (input) {
-  const instances = yield* Service49;
-  const skills = yield* awaitActivation2.pipe(Effect.andThen(Service59), instances.provide(input.session));
+  const instances = yield* Service41;
+  const skills = yield* awaitActivation2.pipe(Effect.andThen(Service56), instances.provide(input.session));
   const skill = yield* skills.get(input.skill);
   if (!skill)
     return yield* new SkillNotFoundError2({ skill: input.skill });

package/dist/chunks/{location-vh4x57nh.js → schema-vbb1pxgn.js}

@@ -1,30 +1,30 @@
 import {
-  Service78
-} from "./location-8s04dv6n.js";
+  Service79
+} from "./schema-wxnc2egh.js";
 import {
-  Service57
-} from "./location-r99pq75w.js";
+  Service60
+} from "./schema-9cjj4wa1.js";
 import {
-  Service12,
+  Service59,
   readText2,
   syncTextBom2
-} from "./location-0kxfmfxf.js";
+} from "./schema-rb4e480n.js";
 import {
-  Service69
-} from "./location-vdwcy635.js";
+  Service57
+} from "./schema-6yy39kvx.js";
 import {
-  Service64
-} from "./location-cje11ec7.js";
+  Service65
+} from "./schema-drgwwxwg.js";
 import {
-  Service15,
+  Service35,
   resolvePath2
-} from "./location-kxqn5q5s.js";
+} from "./schema-jjf6303y.js";
 import {
   fileDiff2
-} from "./location-6prwharc.js";
+} from "./schema-6prwharc.js";
 import {
   __export
-} from "./location-9rqn6x4v.js";
+} from "./schema-9rqn6x4v.js";
 
 // src/tool/plugin/edit.ts
 var exports_edit = {};
@@ -32,7 +32,7 @@ __export(exports_edit, {
   EditTool: () => exports_edit,
   Input: () => Input12,
   Output: () => Output8,
-  Plugin: () => Plugin13,
+  Plugin: () => Plugin49,
   name: () => name12
 });
 import { ToolFailure } from "@opencode/ai";
@@ -103,15 +103,15 @@ var findLineOccurrences = (content, search) => {
     return result;
   }, []);
 };
-var Plugin13 = {
+var Plugin49 = {
   id: "opencode.tool.edit",
   effect: Effect.fn("EditTool.Plugin")(function* (ctx) {
-    const access = yield* Service15;
-    const fileMutation = yield* Service12;
-    const environment = yield* Service57;
-    const formatter = yield* Service69;
-    const location = yield* Service78;
-    const permission = yield* Service64;
+    const access = yield* Service35;
+    const fileMutation = yield* Service59;
+    const environment = yield* Service60;
+    const formatter = yield* Service57;
+    const location = yield* Service79;
+    const permission = yield* Service65;
     yield* ctx.tool.transform((editor) => editor.add({
       name: name12,
       options: { codemode: false, permission: "edit" },
@@ -194,4 +194,4 @@ var Plugin13 = {
   })
 };
 
-export { name12, Input12, Output8, Plugin13, exports_edit };
+export { name12, Input12, Output8, Plugin49, exports_edit };

package/dist/chunks/{location-veqvce7d.js → schema-veqvce7d.js}

@@ -1,6 +1,6 @@
 import {
   createProviderPlugin2
-} from "./location-ym463w8f.js";
+} from "./schema-ym463w8f.js";
 
 // src/plugin/provider/perplexity.ts
 var PerplexityPlugin2 = createProviderPlugin2({