@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-4zfy2va0.js

@@ -0,0 +1,173 @@
+import {
+  SQLiteEffectUpdateBuilder
+} from "./permission-zfxc0ze5.js";
+import {
+  SQLiteEffectRelationalQueryBuilder
+} from "./permission-bxdhjb3y.js";
+import {
+  SQLiteEffectSelectBuilder
+} from "./permission-mwceq5am.js";
+import {
+  SQLiteEffectInsertBuilder
+} from "./permission-erj4j75s.js";
+import {
+  SQLiteEffectDeleteBase
+} from "./permission-g9yygpzr.js";
+import {
+  SQLiteEffectCountBuilder
+} from "./permission-0f48qthw.js";
+import {
+  SQLiteEffectRaw
+} from "./permission-s7whb9gt.js";
+
+// src/database/drizzle/sqlite-core/effect/db.ts
+import { Effect } from "effect";
+import { entityKind } from "drizzle-orm/entity";
+import { SelectionProxyHandler } from "drizzle-orm/selection-proxy";
+import { sql } from "drizzle-orm/sql/sql";
+import { QueryBuilder } from "drizzle-orm/sqlite-core/query-builders/query-builder";
+import { WithSubquery } from "drizzle-orm/subquery";
+class SQLiteEffectDatabase {
+  dialect;
+  session;
+  rowModeRQB;
+  forbidJsonb;
+  static [entityKind] = "SQLiteEffectDatabase";
+  query;
+  constructor(dialect, session, relations, rowModeRQB, forbidJsonb) {
+    this.dialect = dialect;
+    this.session = session;
+    this.rowModeRQB = rowModeRQB;
+    this.forbidJsonb = forbidJsonb;
+    this._ = {
+      relations,
+      session
+    };
+    this.query = {};
+    for (const [tableName, relation] of Object.entries(relations)) {
+      this.query[tableName] = new SQLiteEffectRelationalQueryBuilder(relations, relations[relation.name].table, relation, dialect, session, rowModeRQB, forbidJsonb);
+    }
+    this.$cache = {
+      invalidate: (_params) => Effect.void
+    };
+  }
+  $with = (alias, selection) => {
+    const self = this;
+    const as = (qb) => {
+      if (typeof qb === "function") {
+        qb = qb(new QueryBuilder(self.dialect));
+      }
+      return new Proxy(new WithSubquery(qb.getSQL(), selection ?? ("getSelectedFields" in qb ? qb.getSelectedFields() ?? {} : {}), alias, true), new SelectionProxyHandler({ alias, sqlAliasedBehavior: "alias", sqlBehavior: "error" }));
+    };
+    return { as };
+  };
+  $cache;
+  $count(source, filters) {
+    return new SQLiteEffectCountBuilder({ source, filters, session: this.session });
+  }
+  with(...queries) {
+    const self = this;
+    function select(fields) {
+      return new SQLiteEffectSelectBuilder({
+        fields: fields ?? undefined,
+        session: self.session,
+        dialect: self.dialect,
+        withList: queries
+      });
+    }
+    function selectDistinct(fields) {
+      return new SQLiteEffectSelectBuilder({
+        fields: fields ?? undefined,
+        session: self.session,
+        dialect: self.dialect,
+        withList: queries,
+        distinct: true
+      });
+    }
+    function update(table) {
+      return new SQLiteEffectUpdateBuilder(table, self.session, self.dialect, queries);
+    }
+    function insert(into) {
+      return new SQLiteEffectInsertBuilder(into, self.session, self.dialect, queries);
+    }
+    function delete_(from) {
+      return new SQLiteEffectDeleteBase(from, self.session, self.dialect, queries);
+    }
+    return { select, selectDistinct, update, insert, delete: delete_ };
+  }
+  select(fields) {
+    return new SQLiteEffectSelectBuilder({ fields: fields ?? undefined, session: this.session, dialect: this.dialect });
+  }
+  selectDistinct(fields) {
+    return new SQLiteEffectSelectBuilder({
+      fields: fields ?? undefined,
+      session: this.session,
+      dialect: this.dialect,
+      distinct: true
+    });
+  }
+  update(table) {
+    return new SQLiteEffectUpdateBuilder(table, this.session, this.dialect);
+  }
+  insert(into) {
+    return new SQLiteEffectInsertBuilder(into, this.session, this.dialect);
+  }
+  delete(from) {
+    return new SQLiteEffectDeleteBase(from, this.session, this.dialect);
+  }
+  raw(query, action, execute) {
+    const sequel = typeof query === "string" ? sql.raw(query) : query.getSQL();
+    return new SQLiteEffectRaw(() => execute(sequel), () => sequel, action, this.dialect, (result) => result);
+  }
+  run(query) {
+    return this.raw(query, "run", (sequel) => this.session.run(sequel));
+  }
+  all(query) {
+    return this.raw(query, "all", (sequel) => this.session.all(sequel));
+  }
+  get(query) {
+    return this.raw(query, "get", (sequel) => this.session.get(sequel));
+  }
+  values(query) {
+    return this.raw(query, "values", (sequel) => this.session.values(sequel));
+  }
+  transaction = (tx, config) => this.session.transaction(tx, config);
+}
+var withReplicas = (primary, replicas, getReplica = () => replicas[Math.floor(Math.random() * replicas.length)]) => {
+  const select = (...args) => getReplica(replicas).select(...args);
+  const selectDistinct = (...args) => getReplica(replicas).selectDistinct(...args);
+  const $count = (...args) => getReplica(replicas).$count(...args);
+  const _with = (...args) => getReplica(replicas).with(...args);
+  const $with = (...args) => args.length === 1 ? getReplica(replicas).$with(args[0]) : getReplica(replicas).$with(args[0], args[1]);
+  const update = (...args) => primary.update(...args);
+  const insert = (...args) => primary.insert(...args);
+  const $delete = (...args) => primary.delete(...args);
+  const run = (...args) => primary.run(...args);
+  const all = (...args) => primary.all(...args);
+  const get = (...args) => primary.get(...args);
+  const values = (...args) => primary.values(...args);
+  const transaction = (...args) => primary.transaction(...args);
+  return {
+    ...primary,
+    update,
+    insert,
+    delete: $delete,
+    run,
+    all,
+    get,
+    values,
+    transaction,
+    $primary: primary,
+    $replicas: replicas,
+    select,
+    selectDistinct,
+    $count,
+    $with,
+    with: _with,
+    get query() {
+      return getReplica(replicas).query;
+    }
+  };
+};
+
+export { SQLiteEffectDatabase, withReplicas };

package/dist/chunks/permission-4zzdwbaz.js

@@ -0,0 +1,18 @@
+import {
+  createProviderPlugin
+} from "./permission-0zz82cjq.js";
+import {
+  __require
+} from "./permission-rvfvac9x.js";
+
+// src/plugin/provider/alibaba.ts
+var AlibabaPlugin = createProviderPlugin({
+  id: "opencode.provider.alibaba",
+  package: "@ai-sdk/alibaba",
+  load: async (options) => {
+    const { createAlibaba } = await import("@ai-sdk/alibaba");
+    return createAlibaba(options);
+  }
+});
+
+export { AlibabaPlugin };

package/dist/chunks/permission-50jxp3hw.js

@@ -0,0 +1,35 @@
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/app.ts
+var exports_app = {};
+__export(exports_app, {
+  useragent: () => useragent,
+  node: () => node,
+  make: () => make,
+  layer: () => layer,
+  configured: () => configured,
+  Metadata: () => Metadata,
+  App: () => exports_app
+});
+import { Context, Layer } from "effect";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+var Metadata = Context.Reference("@opencode/App", {
+  defaultValue: () => make()
+});
+function make(input = {}) {
+  return {
+    name: input.name ?? "opencode",
+    version: input.version ?? "unknown",
+    channel: input.channel ?? "unknown"
+  };
+}
+function useragent(app) {
+  return `opencode/${app.channel}/${app.version}/${app.name}`;
+}
+var layer = (input) => Layer.succeed(Metadata, make(input));
+var configured = (input) => makeGlobalNode({ service: Metadata, layer: layer(input), deps: [] });
+var node = configured();
+
+export { Metadata, make, useragent, layer, configured, node, exports_app };

package/dist/chunks/permission-52jzav25.js

@@ -0,0 +1,13 @@
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/session/prompt-cache-key.ts
+var exports_prompt_cache_key = {};
+__export(exports_prompt_cache_key, {
+  make: () => make,
+  SessionPromptCacheKey: () => exports_prompt_cache_key
+});
+var make = (sessionID) => /^ses_[0-9a-f]{64}$/.test(sessionID) ? sessionID.slice(4) : sessionID;
+
+export { make, exports_prompt_cache_key };

package/dist/chunks/permission-56p2m126.js

@@ -0,0 +1,31 @@
+import {
+  exports_provider
+} from "./permission-d6vvk673.js";
+
+// src/plugin/provider/zenmux.ts
+import { Effect } from "effect";
+import { define } from "@opencode-ai/plugin/effect/plugin";
+var ZenmuxPlugin = define({
+  id: "opencode.provider.zenmux",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.catalog.transform((evt) => {
+      for (const item of evt.provider.list()) {
+        if (!exports_provider.isAISDK(item.provider.package))
+          continue;
+        if (exports_provider.packageName(item.provider.package) !== "@ai-sdk/openai-compatible")
+          continue;
+        if (item.provider.settings?.baseURL !== "https://zenmux.ai/api/v1")
+          continue;
+        evt.provider.update(item.provider.id, (provider) => {
+          provider.headers = {
+            "HTTP-Referer": "https://opencode.ai/",
+            "X-Title": "opencode",
+            ...provider.headers
+          };
+        });
+      }
+    });
+  })
+});
+
+export { ZenmuxPlugin };

package/dist/chunks/permission-57tzwnz4.js

@@ -0,0 +1,107 @@
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/codemode/catalog.ts
+var exports_catalog = {};
+__export(exports_catalog, {
+  summarize: () => summarize,
+  Summary: () => Summary,
+  Entry: () => Entry,
+  CodeModeCatalog: () => exports_catalog
+});
+import { Schema } from "effect";
+var Entry = Schema.Struct({
+  path: Schema.String,
+  description: Schema.String,
+  signature: Schema.String,
+  pinned: Schema.optionalKey(Schema.Boolean)
+});
+var Listing = Schema.Struct({
+  path: Schema.String,
+  line: Schema.String
+});
+var Namespace = Schema.Struct({
+  name: Schema.String,
+  count: Schema.Number,
+  entries: Schema.Array(Listing)
+});
+var Summary = Schema.Struct({
+  total: Schema.Number,
+  shown: Schema.Number,
+  namespaces: Schema.Array(Namespace)
+});
+var DESCRIPTION_LIMIT = 120;
+var CHARACTERS_PER_TOKEN = 4;
+var INLINE_BUDGET = 2000;
+function summarize(entries, budget = INLINE_BUDGET) {
+  const namespaces = [...Map.groupBy(entries, (entry) => entry.path.split(".", 1)[0] ?? entry.path)].sort(([left], [right]) => {
+    if (left < right)
+      return -1;
+    if (left > right)
+      return 1;
+    return 0;
+  }).map(([name, namespaceEntries]) => {
+    const listings = namespaceEntries.map((entry) => {
+      const firstLine = entry.description.split(`
+`, 1)[0]?.trim() ?? "";
+      const description = firstLine.length > DESCRIPTION_LIMIT ? firstLine.slice(0, DESCRIPTION_LIMIT - 3) + "..." : firstLine;
+      const suffix = description.length === 0 ? "" : ` // ${description}`;
+      return { path: entry.path, line: `  - ${entry.signature}${suffix}` };
+    }).toSorted((left, right) => {
+      if (left.path < right.path)
+        return -1;
+      if (left.path > right.path)
+        return 1;
+      return 0;
+    });
+    const ranked = rankListings(listings);
+    const pinned = new Set(namespaceEntries.filter((entry) => entry.pinned).map((entry) => listings.find((listing) => listing.path === entry.path)).filter((listing) => listing !== undefined));
+    return {
+      name,
+      listings,
+      selectionOrder: ranked.filter((candidate) => !pinned.has(candidate.listing)),
+      selectedListings: pinned,
+      selectionIndex: 0
+    };
+  });
+  const active = new Set(namespaces);
+  let remaining = budget - namespaces.flatMap((namespace) => namespace.listings.filter((listing) => namespace.selectedListings.has(listing))).reduce((total, listing) => total + Math.round(listing.line.length / CHARACTERS_PER_TOKEN), 0);
+  while (active.size > 0) {
+    for (const namespace of active) {
+      const candidate = namespace.selectionOrder[namespace.selectionIndex];
+      if (!candidate || candidate.cost > remaining) {
+        active.delete(namespace);
+        continue;
+      }
+      namespace.selectedListings.add(candidate.listing);
+      namespace.selectionIndex += 1;
+      remaining -= candidate.cost;
+      if (namespace.selectionIndex === namespace.selectionOrder.length)
+        active.delete(namespace);
+    }
+  }
+  const namespaceSummaries = namespaces.map((namespace) => ({
+    name: namespace.name,
+    count: namespace.listings.length,
+    entries: namespace.listings.filter((listing) => namespace.selectedListings.has(listing))
+  }));
+  return {
+    total: entries.length,
+    shown: namespaceSummaries.reduce((total, namespace) => total + namespace.entries.length, 0),
+    namespaces: namespaceSummaries
+  };
+}
+function rankListings(listings) {
+  return listings.map((listing) => ({ listing, cost: Math.round(listing.line.length / CHARACTERS_PER_TOKEN) })).toSorted((left, right) => {
+    if (left.cost !== right.cost)
+      return left.cost - right.cost;
+    if (left.listing.path < right.listing.path)
+      return -1;
+    if (left.listing.path > right.listing.path)
+      return 1;
+    return 0;
+  });
+}
+
+export { Entry, Summary, summarize, exports_catalog };

package/dist/chunks/permission-5a5ch9ts.js

@@ -0,0 +1,31 @@
+// src/github-copilot/responses/tool/code-interpreter.ts
+import { createProviderToolFactoryWithOutputSchema } from "@ai-sdk/provider-utils";
+import { z } from "zod/v4";
+var codeInterpreterInputSchema = z.object({
+  code: z.string().nullish(),
+  containerId: z.string()
+});
+var codeInterpreterOutputSchema = z.object({
+  outputs: z.array(z.discriminatedUnion("type", [
+    z.object({ type: z.literal("logs"), logs: z.string() }),
+    z.object({ type: z.literal("image"), url: z.string() })
+  ])).nullish()
+});
+var codeInterpreterArgsSchema = z.object({
+  container: z.union([
+    z.string(),
+    z.object({
+      fileIds: z.array(z.string()).optional()
+    })
+  ]).optional()
+});
+var codeInterpreterToolFactory = createProviderToolFactoryWithOutputSchema({
+  id: "openai.code_interpreter",
+  inputSchema: codeInterpreterInputSchema,
+  outputSchema: codeInterpreterOutputSchema
+});
+var codeInterpreter = (args = {}) => {
+  return codeInterpreterToolFactory(args);
+};
+
+export { codeInterpreterInputSchema, codeInterpreterOutputSchema, codeInterpreterArgsSchema, codeInterpreterToolFactory, codeInterpreter };

package/dist/chunks/permission-5m82aax9.js

@@ -0,0 +1,150 @@
+import {
+  exports_kv
+} from "./permission-y76hsvs9.js";
+import {
+  exports_bus
+} from "./permission-r5ce0emk.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/wellknown.ts
+var exports_wellknown = {};
+__export(exports_wellknown, {
+  resolve: () => resolve,
+  node: () => node,
+  inspect: () => inspect,
+  WellKnown: () => exports_wellknown,
+  Service: () => Service,
+  RemoteConfig: () => RemoteConfig,
+  Manifest: () => Manifest,
+  Event: () => Event,
+  Config: () => Config,
+  Auth: () => Auth
+});
+import { Integration } from "@opencode-ai/schema/integration";
+import { Context, Effect, Layer, Ref, Schema, Semaphore } from "effect";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import { isDeepStrictEqual } from "node:util";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+import { httpClient } from "@opencode-ai/util/effect/app-node-platform";
+var Auth = Schema.Struct({
+  command: Schema.Array(Schema.String),
+  env: Schema.String
+}).annotate({ identifier: "WellKnown.Auth" });
+var RemoteConfig = Schema.Struct({
+  url: Schema.String,
+  headers: Schema.optional(Schema.Record(Schema.String, Schema.String))
+}).annotate({ identifier: "WellKnown.RemoteConfig" });
+var Config = Schema.Record(Schema.String, Schema.Json).annotate({ identifier: "WellKnown.Config" });
+var Manifest = Schema.Struct({
+  auth: Schema.optional(Auth),
+  config: Schema.optional(Schema.NullOr(Config)),
+  remote_config: Schema.optional(RemoteConfig)
+}).annotate({ identifier: "WellKnown.Manifest" });
+
+class Service extends Context.Service()("@opencode/WellKnown") {
+}
+var Event = {
+  Updated: exports_bus.ephemeral({ type: "wellknown.updated", schema: {} })
+};
+var inspect = Effect.fn("WellKnown.inspect")(function* (origin) {
+  const url = `${origin.replace(/\/+$/, "")}/.well-known/opencode`;
+  const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient);
+  return yield* http.execute(HttpClientRequest.get(url).pipe(HttpClientRequest.acceptJson)).pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(Manifest)), Effect.mapError((cause) => new Error(`Failed to load wellknown manifest from ${url}`, { cause })));
+});
+var resolve = Effect.fn("WellKnown.resolve")(function* (input) {
+  const manifest = yield* inspect(input.origin);
+  return yield* resolveEntry({ origin: input.origin, integrationID: Integration.ID.make(input.origin.replace(/\/+$/, "")), manifest }, input.variables ?? {});
+});
+var resolveEntry = Effect.fnUntraced(function* (entry, variables) {
+  const configs = entry.manifest.config ? [entry.manifest.config] : [];
+  if (!entry.manifest.remote_config)
+    return configs;
+  const substitute = (value) => value.replace(/\{env:([^}]+)\}/g, (_, name) => variables[name] ?? process.env[name] ?? "");
+  const url = substitute(entry.manifest.remote_config.url);
+  const headers = Object.fromEntries(Object.entries(entry.manifest.remote_config.headers ?? {}).map(([key, value]) => [key, substitute(value)]));
+  const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient);
+  const remote = yield* http.execute(HttpClientRequest.get(url).pipe(HttpClientRequest.acceptJson, HttpClientRequest.setHeaders(headers))).pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(Config)), Effect.mapError((cause) => new Error(`Failed to load wellknown remote config from ${url}`, { cause })));
+  if (Schema.is(Config)(remote.config))
+    return [...configs, remote.config];
+  return [...configs, remote];
+});
+var sourcesKey = "wellknown:sources";
+var Sources = Schema.Array(Schema.String);
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const http = yield* HttpClient.HttpClient;
+  const kv = yield* exports_kv.Service;
+  const bus = yield* exports_bus.Service;
+  const cache = yield* Ref.make(new Map);
+  const lock = Semaphore.makeUnsafe(1);
+  const load = Effect.fn("WellKnown.load")(function* () {
+    const value = yield* kv.get(sourcesKey);
+    const origins = Schema.is(Sources)(value) ? value : [];
+    const current = yield* Ref.get(cache);
+    const entries = yield* Effect.forEach(origins, (origin) => {
+      const cached = current.get(origin);
+      if (cached)
+        return Effect.succeed(cached);
+      return inspect(origin).pipe(Effect.provideService(HttpClient.HttpClient, http), Effect.map((manifest) => ({ origin, integrationID: Integration.ID.make(origin), manifest })));
+    });
+    yield* Ref.set(cache, new Map(entries.map((entry) => [entry.origin, entry])));
+    return entries;
+  });
+  const refresh = Effect.fn("WellKnown.refresh")(function* () {
+    return yield* lock.withPermit(Effect.gen(function* () {
+      const value = yield* kv.get(sourcesKey);
+      const origins = Schema.is(Sources)(value) ? value : [];
+      if (!origins.length)
+        return false;
+      const entries = yield* Effect.forEach(origins, (origin) => inspect(origin).pipe(Effect.provideService(HttpClient.HttpClient, http), Effect.map((manifest) => ({ origin, integrationID: Integration.ID.make(origin), manifest }))));
+      const next = new Map(entries.map((entry) => [entry.origin, entry]));
+      const changed = !isDeepStrictEqual(Ref.getUnsafe(cache), next);
+      if (!changed)
+        return false;
+      yield* Ref.set(cache, next);
+      yield* bus.publish(Event.Updated, {});
+      return true;
+    }));
+  });
+  return Service.of({
+    entries: load,
+    snapshot: () => Array.from(Ref.getUnsafe(cache).values()),
+    refresh,
+    add: Effect.fn("WellKnown.add")(function* (value) {
+      return yield* lock.withPermit(Effect.gen(function* () {
+        const origin = value.replace(/\/+$/, "");
+        const manifest = yield* inspect(origin).pipe(Effect.provideService(HttpClient.HttpClient, http));
+        if (!manifest.auth)
+          return yield* Effect.fail(new Error(`No authentication method found at ${origin}`));
+        const entry = { origin, integrationID: Integration.ID.make(origin), manifest };
+        const sources = yield* kv.get(sourcesKey);
+        const origins = Schema.is(Sources)(sources) ? sources : [];
+        yield* kv.set(sourcesKey, Array.from(new Set([...origins, origin])));
+        yield* Ref.update(cache, (current) => new Map(current).set(origin, entry));
+        yield* bus.publish(Event.Updated, {});
+        return entry;
+      }));
+    }),
+    remove: Effect.fn("WellKnown.remove")(function* (value) {
+      yield* lock.withPermit(Effect.gen(function* () {
+        const origin = value.replace(/\/+$/, "");
+        const sources = yield* kv.get(sourcesKey);
+        const origins = Schema.is(Sources)(sources) ? sources : [];
+        yield* kv.set(sourcesKey, origins.filter((item) => item !== origin));
+        yield* Ref.update(cache, (current) => {
+          const next = new Map(current);
+          next.delete(origin);
+          return next;
+        });
+        yield* bus.publish(Event.Updated, {});
+      }));
+    }),
+    resolve: Effect.fn("WellKnown.resolveEntry")(function* (entry, variables) {
+      return yield* resolveEntry(entry, variables).pipe(Effect.provideService(HttpClient.HttpClient, http));
+    })
+  });
+}));
+var node = makeGlobalNode({ service: Service, layer, deps: [httpClient, exports_kv.node, exports_bus.node] });
+
+export { Auth, RemoteConfig, Config, Manifest, Service, Event, inspect, resolve, node, exports_wellknown };

package/dist/chunks/permission-5p2sx24b.js

@@ -0,0 +1,56 @@
+import {
+  exports_model
+} from "./permission-xfd1xnk3.js";
+import {
+  exports_provider
+} from "./permission-d6vvk673.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/plugin/variant.ts
+var exports_variant = {};
+__export(exports_variant, {
+  generate: () => generate,
+  VariantPlugin: () => exports_variant,
+  Plugin: () => Plugin
+});
+import { Effect } from "effect";
+import { define } from "@opencode-ai/plugin/effect/plugin";
+var Plugin = define({
+  id: "opencode.variant",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.catalog.transform((catalog) => {
+      for (const record of catalog.provider.list()) {
+        for (const model of record.models.values()) {
+          catalog.model.update(model.providerID, model.id, (draft) => {
+            const generated = generate(draft, record.provider);
+            if (generated.length === 0)
+              return;
+            const variants = draft.variants ?? [];
+            const explicit = new Map(variants.map((variant) => [variant.id, variant]));
+            const generatedIDs = new Set(generated.map((variant) => variant.id));
+            draft.variants = [
+              ...generated.map((variant) => explicit.get(variant.id) ?? variant),
+              ...variants.filter((variant) => !generatedIDs.has(variant.id))
+            ];
+          });
+        }
+      }
+    });
+  })
+});
+function generate(model, provider) {
+  const packageName = model.package ?? provider?.package;
+  if (!exports_provider.isAISDK(packageName) || exports_provider.packageName(packageName) !== "@ai-sdk/openai-compatible")
+    return [];
+  const ids = `${model.id} ${model.modelID ?? ""}`.toLowerCase();
+  if (!["glm-5.2", "glm-5-2", "glm-5p2"].some((name) => ids.includes(name)))
+    return [];
+  return ["high", "max"].map((id) => ({
+    id: exports_model.VariantID.make(id),
+    settings: { reasoningEffort: id }
+  }));
+}
+
+export { Plugin, generate, exports_variant };