@opencode/core 2.1.2 → 2.1.4

package/dist/chunks/{repository-cache-1ycwwje8.js → location-c34bh8hr.js}

@@ -1,41 +1,41 @@
 import {
   makeUnsafe2
-} from "./repository-cache-dpkg50ah.js";
+} from "./location-8jztxfpf.js";
 import {
   Service85,
   node89
-} from "./repository-cache-z1fx9rk1.js";
+} from "./location-wedh6qfb.js";
 import {
-  Event21,
-  Service84,
-  node88
-} from "./repository-cache-ke7rr379.js";
+  Event19,
+  Service80,
+  node84
+} from "./location-v0ajt838.js";
 import {
-  Service81,
-  node85
-} from "./repository-cache-8pvf9cdd.js";
+  Service82,
+  node86
+} from "./location-5ysrq0ad.js";
 import {
-  Service52,
-  node54
-} from "./repository-cache-24ra19qx.js";
+  Service60,
+  node62
+} from "./location-r20swzxr.js";
 import {
   ID15,
-  Service80,
-  node84
-} from "./repository-cache-gtdxectv.js";
+  Service79,
+  node83
+} from "./location-w67r90k6.js";
 import {
   reconcile2,
   create3
-} from "./repository-cache-rdw6cm16.js";
+} from "./location-vd3b3yk9.js";
 import {
   ID14,
   MethodID2,
-  Service79,
-  node83
-} from "./repository-cache-t8z4ntba.js";
+  Service78,
+  node82
+} from "./location-dgj49q4q.js";
 import {
   __export
-} from "./repository-cache-9rqn6x4v.js";
+} from "./location-9rqn6x4v.js";
 
 // src/mcp/index.ts
 var exports_mcp4 = {};
@@ -49,12 +49,12 @@ __export(exports_mcp4, {
   ResourceContent: () => ResourceContent2,
   ResourceTemplate: () => ResourceTemplate2,
   ServerName: () => ServerName2,
-  Service: () => Service29,
+  Service: () => Service39,
   Status: () => Status2,
   ToolCallError: () => ToolCallError2,
   configured: () => configured4,
-  layer: () => layer14,
-  node: () => node32
+  layer: () => layer17,
+  node: () => node42
 });
 import { Mcp } from "@opencode/schema/mcp";
 import { McpEvent } from "@opencode/schema/mcp-event";
@@ -98,12 +98,13 @@ var unavailable = (server, status) => {
       return `MCP server "${server}" is not connected.`;
   }
 };
+var FALLBACK_LIST_TIMEOUT = "5 seconds";
 var GLOBAL_ELICITATION_SESSION_ID = "global";
 var URL_ELICITATION_FIELD_KEY = "elicitation";
 var endpointLoads = makeUnsafe2();
 var cloneConfig = (config) => structuredClone(config);
 
-class Service29 extends Context.Service()("@opencode/MCP") {
+class Service39 extends Context.Service()("@opencode/MCP") {
 }
 var Options4 = Schema.Struct({
   clientInfo: Schema.optional(Schema.Struct({
@@ -111,17 +112,20 @@ var Options4 = Schema.Struct({
     version: Schema.String
   }))
 });
-var layer14 = (options) => Layer.effect(Service29, Effect.gen(function* () {
-  const location = yield* Service81;
-  const environment = yield* Service52;
+var layer17 = (options) => Layer.effect(Service39, Effect.gen(function* () {
+  const location = yield* Service82;
+  const environment = yield* Service60;
   const bus = yield* Service85;
-  const forms = yield* Service80;
-  const integration = yield* Service79;
-  const credentials = yield* Service84;
+  const forms = yield* Service79;
+  const integration = yield* Service78;
+  const credentials = yield* Service80;
   const root = yield* Effect.scope;
   const fork = yield* FiberSet.makeRuntime();
+  const servers = yield* Scope.fork(root, "parallel");
   const entries = new Map;
+  const attached = new Map;
   const locks = makeUnsafe2();
+  const attachedLocks = makeUnsafe2();
   const urlElicitations = new Map;
   const owned = new Set;
   const register = Effect.fnUntraced(function* (name, entry) {
@@ -145,13 +149,12 @@ var layer14 = (options) => Layer.effect(Service29, Effect.gen(function* () {
         method: { id: methodID, type: "oauth", label: name },
         authorize: () => Effect.gen(function* () {
           const { McpOAuth } = yield* Effect.promise(() => import("../mcp/oauth.js"));
-          return yield* McpOAuth.authorize({ name, config: remote, integrationID, methodID }).pipe(Effect.provideService(Service84, credentials));
+          return yield* McpOAuth.authorize({ name, config: remote, integrationID, methodID }).pipe(Effect.provideService(Service80, credentials));
         })
       });
     }).pipe(Scope.provide(scope));
   });
-  const requireServer = Effect.fnUntraced(function* (server) {
-    const name = ServerName2.make(server);
+  const requireServer = Effect.fnUntraced(function* (name) {
     const entry = entries.get(name);
     if (!entry)
       return yield* new NotFoundError4({ server: name });
@@ -161,7 +164,7 @@ var layer14 = (options) => Layer.effect(Service29, Effect.gen(function* () {
     if (entry.config.type !== "remote" || !entry.integrationID)
       return;
     const { McpOAuth } = yield* Effect.promise(() => import("../mcp/oauth.js"));
-    return yield* McpOAuth.connectProvider({ config: entry.config, integrationID: entry.integrationID }).pipe(Effect.provideService(Service84, credentials));
+    return yield* McpOAuth.connectProvider({ config: entry.config, integrationID: entry.integrationID }).pipe(Effect.provideService(Service80, credentials));
   });
   const elicitation = {
     create: (input) => Effect.gen(function* () {
@@ -265,11 +268,11 @@ var layer14 = (options) => Layer.effect(Service29, Effect.gen(function* () {
   const startServer = (name, entry) => Effect.gen(function* () {
     entry.status = { status: "pending" };
     yield* bus.publish(McpEvent.StatusChanged, { server: name });
-    const scope = yield* Scope.fork(root);
+    const scope = yield* Scope.fork(servers);
     entry.scope = scope;
     const authProvider = yield* connectProvider(entry);
     const { McpClient } = yield* Effect.promise(() => import("../mcp/client.js"));
-    const load = McpClient.connect(name, entry.config, location.directory, authProvider, elicitation, options?.clientInfo).pipe(Effect.flatMap((connection) => connection.tools().pipe(Effect.map((tools) => ({ connection, tools })))), Effect.provideService(Service52, environment), Scope.provide(scope));
+    const load = McpClient.connect(name, entry.config, location.directory, authProvider, elicitation, options?.clientInfo).pipe(Effect.flatMap((connection) => connection.tools().pipe(Effect.map((tools) => ({ connection, tools })))), Effect.provideService(Service60, environment), Scope.provide(scope));
     const result = yield* (entry.config.type === "remote" ? endpointLoads.withLock(entry.config.url)(load) : load).pipe(Effect.exit);
     if (Exit.isSuccess(result)) {
       entry.client = result.value.connection;
@@ -339,6 +342,57 @@ var layer14 = (options) => Layer.effect(Service29, Effect.gen(function* () {
     entries.delete(name);
     yield* bus.publish(McpEvent.StatusChanged, { server: name });
   });
+  const toAttachedTools = (server, tools) => tools.map((tool) => ({ ...tool, server }));
+  const detach = Effect.fnUntraced(function* (name, entry) {
+    const stack = attached.get(name) ?? [];
+    if (!stack.includes(entry))
+      return;
+    const remaining = stack.filter((item) => item !== entry);
+    const next = remaining.at(-1);
+    entry.client.onClose(() => {});
+    if (!next) {
+      attached.delete(name);
+      yield* Scope.close(entry.scope, Exit.void);
+      return yield* bus.publish(McpEvent.ToolsChanged, { server: name });
+    }
+    attached.set(name, remaining);
+    yield* Scope.close(entry.scope, Exit.void);
+    if (stack.at(-1) !== entry)
+      return;
+    const previous = next.tools;
+    yield* next.client.tools().pipe(Effect.timeout(FALLBACK_LIST_TIMEOUT), Effect.map((tools) => {
+      next.tools = toAttachedTools(name, tools);
+    }), Effect.ignore);
+    if (!isDeepStrictEqual(entry.tools, next.tools) || !isDeepStrictEqual(previous, next.tools))
+      yield* bus.publish(McpEvent.ToolsChanged, { server: name });
+  });
+  const attach = Effect.fnUntraced(function* (name, transport) {
+    const { McpClient } = yield* Effect.promise(() => import("../mcp/client.js"));
+    const scope = yield* Effect.acquireRelease(Scope.fork(root), (scope) => Scope.close(scope, Exit.void));
+    yield* Scope.addFinalizer(scope, Effect.promise(() => transport.close()).pipe(Effect.ignore));
+    let closed = false;
+    const result = yield* McpClient.connect(name, { type: "attached", transport }, location.directory, undefined, elicitation, options?.clientInfo).pipe(Effect.tap((connection) => Effect.sync(() => connection.onClose(() => {
+      closed = true;
+    }))), Effect.flatMap((connection) => connection.tools().pipe(Effect.map((tools) => ({ connection, tools })))), Effect.provideService(Service60, environment), Scope.provide(scope), Effect.onError(() => Scope.close(scope, Exit.void)), Effect.mapError((error) => error instanceof McpClient.ConnectError ? error : new McpClient.ConnectError({ server: name, message: error.message })));
+    const register = Effect.gen(function* () {
+      if (closed) {
+        yield* Scope.close(scope, Exit.void);
+        return yield* new McpClient.ConnectError({ server: name, message: "Connection closed" });
+      }
+      const entry = { scope, client: result.connection, tools: toAttachedTools(name, result.tools) };
+      attached.set(name, [...attached.get(name) ?? [], entry]);
+      const locked = (effect) => fork(effect.pipe(attachedLocks.withLock(name), Effect.ignore));
+      result.connection.onClose(() => locked(detach(name, entry)));
+      const refresh = result.connection.tools().pipe(Effect.timeout(FALLBACK_LIST_TIMEOUT), Effect.map((tools) => {
+        entry.tools = toAttachedTools(name, tools);
+      }), Effect.andThen(bus.publish(McpEvent.ToolsChanged, { server: name })));
+      result.connection.onToolsChanged(() => locked(Effect.suspend(() => attached.get(name)?.at(-1) === entry ? refresh : Effect.void)));
+      yield* Effect.logInfo("mcp client attached", { server: name, tools: entry.tools.length });
+      yield* bus.publish(McpEvent.ToolsChanged, { server: name });
+      return entry;
+    });
+    yield* Effect.acquireRelease(register.pipe(attachedLocks.withLock(name)), (entry) => detach(name, entry).pipe(attachedLocks.withLock(name)));
+  });
   let applied;
   const overrides = new Map;
   const reconcileLock = Semaphore.makeUnsafe(1);
@@ -361,7 +415,11 @@ var layer14 = (options) => Layer.effect(Service29, Effect.gen(function* () {
           yield* bus.publish(McpEvent.StatusChanged, { server: name });
           continue;
         }
-        fork(startServer(name, entry).pipe(locks.withLock(name)));
+        fork(Effect.gen(function* () {
+          if (entry.status.status !== "pending")
+            return yield* entry.startup.open;
+          yield* startServer(name, entry);
+        }).pipe(locks.withLock(name)));
       }
       return;
     }
@@ -394,7 +452,7 @@ var layer14 = (options) => Layer.effect(Service29, Effect.gen(function* () {
       yield* startServer(name, entry);
     }).pipe(locks.withLock(name));
   });
-  fork(bus.subscribe(Event21.Switched).pipe(Stream.filter((event) => owned.has(event.data.integrationID)), Stream.runForEach((event) => Effect.sync(() => fork(reconnect(event.data.integrationID))))));
+  fork(bus.subscribe(Event19.Switched).pipe(Stream.filter((event) => owned.has(event.data.integrationID)), Stream.runForEach((event) => Effect.sync(() => fork(reconnect(event.data.integrationID))))));
   const state = create3({
     name: "mcp",
     initial: () => ({
@@ -420,7 +478,7 @@ var layer14 = (options) => Layer.effect(Service29, Effect.gen(function* () {
     }),
     notify: () => reconcile2(root, fork, () => reconcileLock.withPermit(reconcile()))
   });
-  return Service29.of({
+  return Service39.of({
     transform: state.transform,
     reload: state.reload,
     servers: Effect.fn("MCP.servers")(function* () {
@@ -454,11 +512,29 @@ var layer14 = (options) => Layer.effect(Service29, Effect.gen(function* () {
       overrides.set(name, false);
       yield* state.reload();
     }),
+    attach: Effect.fn("MCP.attach")(function* (client, transport) {
+      yield* attach(ServerName2.make(client), transport);
+    }),
     tools: Effect.fn("MCP.tools")(function* () {
-      return Array.from(entries.values()).flatMap((entry) => entry.tools ?? []).toSorted((a, b) => a.server.localeCompare(b.server) || a.name.localeCompare(b.name));
+      const clients = Array.from(attached.values()).flatMap((stack) => stack.at(-1)?.tools ?? []);
+      const shadowed = new Set(clients.map((tool) => `${tool.server}\x00${tool.name}`));
+      return [
+        ...Array.from(entries.values()).flatMap((entry) => entry.tools ?? []).filter((tool) => !shadowed.has(`${tool.server}\x00${tool.name}`)),
+        ...clients
+      ].toSorted((a, b) => a.server.localeCompare(b.server) || a.name.localeCompare(b.name));
     }),
     callTool: Effect.fn("MCP.callTool")(function* (input) {
-      const target = yield* requireServer(input.server);
+      const server = ServerName2.make(input.server);
+      const client = attached.get(server)?.at(-1);
+      if (client && (client.tools.some((tool) => tool.name === input.name) || !entries.has(server))) {
+        const result = yield* client.client.callTool({ name: input.name, args: input.args, sessionID: input.sessionID }).pipe(Effect.mapError((error) => new ToolCallError2({
+          server,
+          tool: input.name,
+          message: `MCP tool "${input.name}" on client "${server}" failed: ${error.message}`
+        })));
+        return { ...result, server, tool: input.name };
+      }
+      const target = yield* requireServer(server);
       yield* target.entry.startup.await;
       if (!target.entry.client)
         return yield* new ToolCallError2({
@@ -485,7 +561,7 @@ var layer14 = (options) => Layer.effect(Service29, Effect.gen(function* () {
       return Array.from(entries.values()).flatMap((entry) => entry.prompts ?? []).toSorted((a, b) => a.server.localeCompare(b.server) || a.name.localeCompare(b.name));
     }),
     prompt: Effect.fn("MCP.prompt")(function* (input) {
-      const target = yield* requireServer(input.server);
+      const target = yield* requireServer(ServerName2.make(input.server));
       yield* target.entry.startup.await;
       if (!target.entry.client)
         return;
@@ -502,14 +578,14 @@ var layer14 = (options) => Layer.effect(Service29, Effect.gen(function* () {
       return mergeCatalogs(catalogs);
     }),
     resources: Effect.fn("MCP.resources")(function* (input) {
-      const target = yield* requireServer(input.server);
+      const target = yield* requireServer(ServerName2.make(input.server));
       yield* target.entry.startup.await;
       if (!target.entry.client)
         return ResourceCatalog2.make({ resources: [], templates: [] });
       return mergeCatalogs([yield* loadCatalog(target.name, target.entry, target.entry.client)]);
     }),
     readResource: Effect.fn("MCP.readResource")(function* (input) {
-      const target = yield* requireServer(input.server);
+      const target = yield* requireServer(ServerName2.make(input.server));
       yield* target.entry.startup.await;
       if (!target.entry.client)
         return;
@@ -532,12 +608,12 @@ function mergeCatalogs(catalogs) {
 }
 function configured4(options) {
   return makeLocationNode({
-    service: Service29,
-    layer: layer14(options),
-    deps: [node85, node54, node89, node84, node83, node88]
+    service: Service39,
+    layer: layer17(options),
+    deps: [node86, node62, node89, node83, node82, node84]
   });
 }
-var node32 = configured4();
+var node42 = configured4();
 function toElicitationField(key, property, required) {
   const machineTitle = /^(boolean|string|number|integer|array|object)(\s+with\b.*|\s+in\b.*)?$/i;
   const title = property.title && !machineTitle.test(property.title.trim()) ? property.title : property.description ?? key;
@@ -588,4 +664,4 @@ function toElicitationField(key, property, required) {
   }
 }
 
-export { ServerName2, PromptsChanged2, Status2, Resource2, ResourceTemplate2, ResourceCatalog2, ResourceContent2, NotFoundError4, ToolCallError2, Service29, Options4, layer14, configured4, node32, exports_mcp4 };
+export { ServerName2, PromptsChanged2, Status2, Resource2, ResourceTemplate2, ResourceCatalog2, ResourceContent2, NotFoundError4, ToolCallError2, Service39, Options4, layer17, configured4, node42, exports_mcp4 };

package/dist/chunks/{repository-cache-0javqkgf.js → location-c3cfh5w6.js}

@@ -1,31 +1,31 @@
 import {
   AbsolutePath2
-} from "./repository-cache-z5v4ffb3.js";
+} from "./location-z5v4ffb3.js";
 import {
   __export
-} from "./repository-cache-9rqn6x4v.js";
+} from "./location-9rqn6x4v.js";
 
 // src/project/schema.ts
 var exports_schema = {};
 __export(exports_schema, {
   Current: () => Current3,
   Event: () => Event20,
-  ID: () => ID17,
-  Info: () => Info28,
+  ID: () => ID18,
+  Info: () => Info29,
   ProjectSchema: () => exports_schema,
-  UpdateInput: () => UpdateInput5,
+  UpdateInput: () => UpdateInput4,
   Vcs: () => Vcs3
 });
 import { Schema } from "effect";
 import { Project } from "@opencode/schema/project";
-var ID17 = Project.ID;
+var ID18 = Project.ID;
 var Current3 = Project.Current;
-var Info28 = Project.Info;
-var UpdateInput5 = Project.UpdateInput;
+var Info29 = Project.Info;
+var UpdateInput4 = Project.UpdateInput;
 var Event20 = Project.Event;
 var Vcs3 = Schema.Struct({
   type: Project.Vcs,
   store: AbsolutePath2
 });
 
-export { ID17, Current3, Info28, UpdateInput5, Event20, Vcs3, exports_schema };
+export { ID18, Current3, Info29, UpdateInput4, Event20, Vcs3, exports_schema };

package/dist/chunks/{repository-cache-tt8gc4fv.js → location-c8666r4c.js}

@@ -1,19 +1,19 @@
 import {
   policy3
-} from "./repository-cache-fcy631f0.js";
+} from "./location-n0p0277s.js";
 import {
   SessionEvent2
-} from "./repository-cache-ec1grn59.js";
+} from "./location-ec1grn59.js";
 import {
   __export
-} from "./repository-cache-9rqn6x4v.js";
+} from "./location-9rqn6x4v.js";
 
 // src/session/runner/retry.ts
 var exports_retry = {};
 __export(exports_retry, {
   SessionRunnerRetry: () => exports_retry,
   isRetryable: () => isRetryable2,
-  make: () => make10,
+  make: () => make9,
   policy: () => policy2
 });
 import { isRetryable as isRetryable2 } from "@opencode/ai";
@@ -39,7 +39,7 @@ var policy2 = (sessionID) => Effect.gen(function* () {
     return { retry: true, attempt: next.attempt, delay: normalized };
   });
 });
-var make10 = (bus, sessionID) => Effect.gen(function* () {
+var make9 = (bus, sessionID) => Effect.gen(function* () {
   const decide = yield* policy2(sessionID);
   const wait = (input) => Effect.gen(function* () {
     const scheduled = yield* Clock.currentTimeMillis;
@@ -56,4 +56,4 @@ var make10 = (bus, sessionID) => Effect.gen(function* () {
   return { decide, wait };
 });
 
-export { isRetryable2, policy2, make10, exports_retry };
+export { isRetryable2, policy2, make9, exports_retry };

package/dist/chunks/{repository-cache-ys3h2zrn.js → location-ckr4b3py.js}

@@ -1,56 +1,56 @@
 import {
   Service85,
   node89
-} from "./repository-cache-z1fx9rk1.js";
+} from "./location-wedh6qfb.js";
 import {
-  node60
-} from "./repository-cache-ey9nrxd1.js";
+  node61
+} from "./location-s56jz2hb.js";
 import {
-  Service3,
-  node4
-} from "./repository-cache-w94dkyq7.js";
+  Service10,
+  node12
+} from "./location-t35vpv8z.js";
 import {
-  Service18
-} from "./repository-cache-3g642jy4.js";
+  Service25
+} from "./location-ytvhabzn.js";
 import {
-  Service22
-} from "./repository-cache-vnkjks7b.js";
+  Service28
+} from "./location-00ve6mdn.js";
 import {
-  node21,
-  ID2
-} from "./repository-cache-cmkn1bh9.js";
+  node20,
+  ID3
+} from "./location-hfkcnh3h.js";
 import {
-  Service9,
-  node10
-} from "./repository-cache-6f890ccd.js";
+  Service2,
+  node3
+} from "./location-kmzgegqq.js";
 import {
   requirements2,
   guarded2,
   list2
-} from "./repository-cache-rvyd7pdz.js";
+} from "./location-jbt1xm3n.js";
 import {
   make3,
   LoadError2
-} from "./repository-cache-y1yvzwwp.js";
+} from "./location-kp4ctdbn.js";
 import {
   Updated2,
+  Service3,
+  node4
+} from "./location-hwqvnpa6.js";
+import {
   Service4,
   node5
-} from "./repository-cache-5j9zz1y4.js";
-import {
-  Service8,
-  node9
-} from "./repository-cache-hwjyn0yt.js";
+} from "./location-0gbb59p9.js";
 import {
   __export
-} from "./repository-cache-9rqn6x4v.js";
+} from "./location-9rqn6x4v.js";
 
 // src/plugin/supervisor.ts
 var exports_supervisor = {};
 __export(exports_supervisor, {
   PluginSupervisor: () => exports_supervisor,
   layer: () => layer3,
-  node: () => node3
+  node: () => node2
 });
 import { Event } from "@opencode/schema/config";
 import { Cause, Effect, Layer, Queue, Stream } from "effect";
@@ -127,7 +127,7 @@ var resolve = Effect.fn("PluginSupervisor.resolve")(function* (modules, pre, pos
     failures: [
       ...failures.values(),
       ...ordered.filter(duplicate).map((plugin) => ({
-        id: ID2.make(plugin.id),
+        id: ID3.make(plugin.id),
         source: plugin.source ?? { type: "builtin" },
         state: { status: "failed", error: `Duplicate plugin ID: ${plugin.id}` },
         features: { server: true, ...plugin.features }
@@ -137,14 +137,14 @@ var resolve = Effect.fn("PluginSupervisor.resolve")(function* (modules, pre, pos
   };
 });
 var layer3 = Layer.effectDiscard(Effect.gen(function* () {
-  const managed = yield* Service18;
-  const registry = yield* Service22;
-  const sdk = yield* Service4;
-  const instance = yield* Service9;
-  const sources = yield* Service3;
+  const managed = yield* Service25;
+  const registry = yield* Service28;
+  const sdk = yield* Service3;
+  const instance = yield* Service2;
+  const sources = yield* Service10;
   const modules = yield* make3();
   const bus = yield* Service85;
-  const updates = yield* Service8;
+  const updates = yield* Service4;
   const internal = yield* list2();
   let release = yield* registry.hold();
   yield* Effect.addFinalizer(() => release ?? Effect.void);
@@ -220,14 +220,14 @@ var layer3 = Layer.effectDiscard(Effect.gen(function* () {
   })), Effect.forkScoped({ startImmediately: true }));
 }));
 var nodeDeps = [
-  node21,
-  node5,
-  node10,
+  node20,
   node4,
-  node9,
+  node3,
+  node12,
+  node5,
   node89,
   Npm.node,
-  node60,
+  node61,
   requirements2
 ];
 function pluginSource(target) {
@@ -235,6 +235,6 @@ function pluginSource(target) {
     return { type: "local", path: target };
   return { type: "package", target };
 }
-var node3 = makeLocationNode({ name: "plugin-supervisor", layer: layer3, deps: nodeDeps });
+var node2 = makeLocationNode({ name: "plugin-supervisor", layer: layer3, deps: nodeDeps });
 
-export { layer3, node3, exports_supervisor };
+export { layer3, node2, exports_supervisor };

package/dist/chunks/{repository-cache-kkq0x60e.js → location-cp65cvxr.js}

@@ -2,16 +2,16 @@ import {
   ID13,
   aisdk2,
   mergeOverlay2
-} from "./repository-cache-1hyfwtsr.js";
+} from "./location-ght5gt7k.js";
 import {
-  ID8,
+  ID7,
   VariantID2,
   Family2,
-  Info18
-} from "./repository-cache-hnvjv21h.js";
+  Info17
+} from "./location-6b66j3w1.js";
 import {
   __export
-} from "./repository-cache-9rqn6x4v.js";
+} from "./location-9rqn6x4v.js";
 
 // src/github-copilot/models.ts
 var exports_models = {};
@@ -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 = ID7.make(id);
     if (result.has(key))
       continue;
     result.set(key, build(key, model, baseURL));
@@ -118,10 +118,10 @@ 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 Info18.make({
-    ...Info18.default(ID13.githubCopilot, id),
+  return Info17.make({
+    ...Info17.default(ID13.githubCopilot, id),
     id,
-    modelID: ID8.make(remote.id),
+    modelID: ID7.make(remote.id),
     providerID: ID13.githubCopilot,
     family: previous?.family ?? Family2.make(remote.capabilities.family),
     name: previous?.name ?? remote.name,