@opencode/core 2.0.14 → 2.0.16

package/dist/chunks/{model-resolver-tvtrv512.js → event-logger-tvtrv512.js}

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

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

@@ -0,0 +1,339 @@
+import {
+  useragent2
+} from "./event-logger-k36bwha9.js";
+import {
+  Service83
+} from "./event-logger-4rzfcrmm.js";
+import {
+  OAuth3,
+  Event21
+} from "./event-logger-4nsq4evv.js";
+import {
+  ID14,
+  MethodID2
+} from "./event-logger-0p8kebmq.js";
+import {
+  key2
+} from "./event-logger-h6r3nrb9.js";
+import {
+  ID13,
+  aisdk2,
+  Service76
+} from "./event-logger-c99wwxqk.js";
+import {
+  ID12,
+  Info26
+} from "./event-logger-tmqa4ga1.js";
+import {
+  success2,
+  error2
+} from "./event-logger-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* Service76;
+    const bus = yield* Service83;
+    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(Event21.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/{model-resolver-fpq9acqp.js → event-logger-v6gb7zv2.js}

@@ -1,20 +1,20 @@
 import {
   __export
-} from "./model-resolver-9rqn6x4v.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/instance/service.ts
 var exports_service2 = {};
 __export(exports_service2, {
   Instance: () => exports_service2,
-  Service: () => Service59,
-  node: () => node63
+  Service: () => Service63,
+  node: () => node67
 });
 import { Context } from "effect";
 import { Node } from "@opencode/util/effect/app-node";
 import { LayerNode } from "@opencode/util/effect/layer-node";
 
-class Service59 extends Context.Service()("@opencode/Instance") {
+class Service63 extends Context.Service()("@opencode/Instance") {
 }
-var node63 = LayerNode.unbound(Service59, Node.tags.values.global);
+var node67 = LayerNode.unbound(Service63, Node.tags.values.global);
 
-export { Service59, node63, exports_service2 };
+export { Service63, node67, exports_service2 };

package/dist/chunks/{model-resolver-z2pn9625.js → event-logger-vamd4fsq.js}

@@ -1,16 +1,16 @@
 import {
   parseOption2
-} from "./model-resolver-5daktx2q.js";
+} from "./event-logger-5daktx2q.js";
 import {
   AbsolutePath2
-} from "./model-resolver-922hggd3.js";
+} from "./event-logger-922hggd3.js";
 import {
-  ID4,
+  ID6,
   Name2
-} from "./model-resolver-6mc00j80.js";
+} from "./event-logger-yjmj8nkq.js";
 import {
   __export
-} from "./model-resolver-9rqn6x4v.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/config/plugin/skill-file.ts
 var exports_skill_file = {};
@@ -55,7 +55,7 @@ function parse2(directory, filepath, content) {
   return {
     _tag: "Parsed",
     skill: {
-      id: ID4.make(id),
+      id: ID6.make(id),
       name: Name2.make(frontmatter.name ?? id),
       ...frontmatter.description === undefined ? {} : { description: frontmatter.description },
       ...autoinvoke === undefined ? {} : { autoinvoke },

package/dist/chunks/{model-resolver-veqvce7d.js → event-logger-veqvce7d.js}

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

package/dist/chunks/{model-resolver-t6794rbq.js → event-logger-vn3yw2wj.js}

@@ -1,32 +1,32 @@
 import {
   Service83,
   node87
-} from "./model-resolver-fb5x04t9.js";
+} from "./event-logger-4rzfcrmm.js";
 import {
-  Service39,
-  node42
-} from "./model-resolver-58jf3t5q.js";
+  Service42,
+  node45
+} from "./event-logger-dsvbxzrp.js";
 import {
-  Service74,
-  node78
-} from "./model-resolver-6z91g84v.js";
+  Service68,
+  node72
+} from "./event-logger-p2qeza37.js";
 import {
-  Service67,
-  node71
-} from "./model-resolver-g0kbvjej.js";
+  Service46,
+  node49
+} from "./event-logger-74wfabdn.js";
 import {
   __export
-} from "./model-resolver-9rqn6x4v.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/tool/mcp.ts
 var exports_mcp3 = {};
 __export(exports_mcp3, {
   McpTool: () => exports_mcp3,
-  Service: () => Service38,
-  layer: () => layer16,
+  Service: () => Service41,
+  layer: () => layer15,
   name: () => name14,
   namespace: () => namespace2,
-  node: () => node41
+  node: () => node44
 });
 import { ToolFailure } from "@opencode/ai";
 import { McpEvent } from "@opencode/schema/mcp-event";
@@ -35,13 +35,13 @@ import { makeLocationNode } from "@opencode/util/effect/app-node";
 var namespace2 = (server) => server.replace(/[^a-zA-Z0-9_-]/g, "_");
 var name14 = (server, tool) => `${namespace2(server)}_${tool.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
 
-class Service38 extends Context.Service()("@opencode/McpTool") {
+class Service41 extends Context.Service()("@opencode/McpTool") {
 }
-var layer16 = Layer.effect(Service38, Effect.gen(function* () {
-  const mcp = yield* Service39;
-  const tools = yield* Service67;
+var layer15 = Layer.effect(Service41, Effect.gen(function* () {
+  const mcp = yield* Service42;
+  const tools = yield* Service46;
   const bus = yield* Service83;
-  const permission = yield* Service74;
+  const permission = yield* Service68;
   const lock = Semaphore.makeUnsafe(1);
   let discovered = [];
   const initial = yield* lock.withPermit(Effect.gen(function* () {
@@ -118,12 +118,12 @@ var layer16 = Layer.effect(Service38, Effect.gen(function* () {
   yield* bus.subscribe(McpEvent.ToolsChanged).pipe(Stream.runForEach(() => PubSub.publish(changes, undefined)), Effect.forkScoped({ startImmediately: true }));
   const updates = yield* PubSub.subscribe(changes);
   yield* Stream.fromSubscription(updates).pipe(Stream.debounce("100 millis"), Stream.runForEach(() => reconcile), Effect.forkScoped({ startImmediately: true }));
-  return Service38.of({ flush: Effect.asVoid(Fiber.await(initial)) });
+  return Service41.of({ flush: Effect.asVoid(Fiber.await(initial)) });
 }));
-var node41 = makeLocationNode({
-  service: Service38,
-  layer: layer16,
-  deps: [node71, node42, node87, node78]
+var node44 = makeLocationNode({
+  service: Service41,
+  layer: layer15,
+  deps: [node49, node45, node87, node72]
 });
 
-export { namespace2, name14, Service38, layer16, node41, exports_mcp3 };
+export { namespace2, name14, Service41, layer15, node44, exports_mcp3 };

package/dist/chunks/{model-resolver-4z2468ba.js → event-logger-vz8d88kv.js}

@@ -1,25 +1,25 @@
 import {
-  ID9,
+  ID13,
   aisdk2,
   mergeOverlay2
-} from "./model-resolver-38xyry6s.js";
+} from "./event-logger-c99wwxqk.js";
 import {
-  ID8,
+  ID12,
   VariantID2,
   Family2,
-  Info22
-} from "./model-resolver-7entrr9d.js";
+  Info26
+} from "./event-logger-tmqa4ga1.js";
 import {
   __export
-} from "./model-resolver-9rqn6x4v.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/github-copilot/models.ts
-var exports_models = {};
-__export(exports_models, {
-  CopilotModels: () => exports_models,
-  derive: () => derive2,
-  get: () => get2,
-  load: () => load2
+var exports_models2 = {};
+__export(exports_models2, {
+  CopilotModels: () => exports_models2,
+  derive: () => derive3,
+  get: () => get3,
+  load: () => load3
 });
 import { Money } from "@opencode/schema/money";
 import { Option, Schema } from "effect";
@@ -68,10 +68,10 @@ var RemoteModel = Schema.Struct({
 var Response = Schema.Struct({ data: Schema.Array(Schema.Unknown) });
 var decodeResponse = Schema.decodeUnknownSync(Response);
 var decodeModel = Schema.decodeUnknownOption(RemoteModel);
-async function get2(baseURL, headers, existing) {
-  return derive2(baseURL, await load2(baseURL, headers), existing);
+async function get3(baseURL, headers, existing) {
+  return derive3(baseURL, await load3(baseURL, headers), existing);
 }
-async function load2(baseURL, headers) {
+async function load3(baseURL, headers) {
   const response = await fetch(`${baseURL}/models`, {
     headers,
     signal: AbortSignal.timeout(5000)
@@ -83,7 +83,7 @@ async function load2(baseURL, headers) {
     return model && usable(model) ? [[model.id, model]] : [];
   }));
 }
-function derive2(baseURL, remote, existing) {
+function derive3(baseURL, remote, existing) {
   const result = new Map(existing.map((model) => [model.id, model]));
   for (const [id, model] of result) {
     const current = remote.get(model.modelID);
@@ -94,7 +94,7 @@ function derive2(baseURL, remote, existing) {
     result.set(id, build(id, current, baseURL, model));
   }
   for (const [id, model] of remote) {
-    const key = ID8.make(id);
+    const key = ID12.make(id);
     if (result.has(key))
       continue;
     result.set(key, build(key, model, baseURL));
@@ -118,11 +118,11 @@ function build(id, remote, baseURL, previous) {
   const usdPerMillion = prices && prices.batch_size > 0 ? 1e4 / prices.batch_size : 0;
   const version = remote.version.startsWith(`${remote.id}-`) ? remote.version.slice(remote.id.length + 1) : remote.version;
   const released = previous?.time.released || Date.parse(version);
-  return Info22.make({
-    ...Info22.default(ID9.githubCopilot, id),
+  return Info26.make({
+    ...Info26.default(ID13.githubCopilot, id),
     id,
-    modelID: ID8.make(remote.id),
-    providerID: ID9.githubCopilot,
+    modelID: ID12.make(remote.id),
+    providerID: ID13.githubCopilot,
     family: previous?.family ?? Family2.make(remote.capabilities.family),
     name: previous?.name ?? remote.name,
     package: messages ? "@opencode/ai/providers/anthropic" : aisdk2("@ai-sdk/github-copilot"),
@@ -197,4 +197,4 @@ function variants(remote, messages) {
   ];
 }
 
-export { get2, load2, derive2, exports_models };
+export { get3, load3, derive3, exports_models2 };

package/dist/chunks/{model-resolver-vzcthcp8.js → event-logger-vzcthcp8.js}

@@ -1,6 +1,6 @@
 import {
   loadSDKFactory2
-} from "./model-resolver-hjbc5kem.js";
+} from "./event-logger-hjbc5kem.js";
 
 // src/plugin/provider/dynamic.ts
 import { Effect } from "effect";

package/dist/chunks/{model-resolver-zdewk29h.js → event-logger-w2nj5ptj.js}

@@ -1,12 +1,12 @@
 import {
   AbsolutePath2
-} from "./model-resolver-922hggd3.js";
+} from "./event-logger-922hggd3.js";
 import {
   Service79
-} from "./model-resolver-cggswk6d.js";
+} from "./event-logger-fv5sjpfb.js";
 import {
   __export
-} from "./model-resolver-9rqn6x4v.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/config/discovery.ts
 var exports_discovery2 = {};

package/dist/chunks/{model-resolver-w3wsvvr9.js → event-logger-w3wsvvr9.js}

@@ -1,7 +1,7 @@
 import {
   getTableColumnsRuntime2,
   orderSelectedFields2
-} from "./model-resolver-emrn6kk6.js";
+} from "./event-logger-emrn6kk6.js";
 
 // src/database/drizzle/sqlite-core/effect/delete.ts
 import { applyEffectWrapper } from "drizzle-orm/effect-core/query-effect";