@opencode/core 0.0.0-reserved → 2.0.0

package/dist/chunks/aisdk-native-v5dw3fed.js

@@ -0,0 +1,74 @@
+import {
+  Service80
+} from "./aisdk-native-vfccn5yp.js";
+import {
+  Service42
+} from "./aisdk-native-81rrwt6s.js";
+import {
+  awaitActivation2
+} from "./aisdk-native-1x11rq2a.js";
+import {
+  provenance2
+} from "./aisdk-native-msq0jde0.js";
+import {
+  preview2
+} from "./aisdk-native-pvvztgda.js";
+import {
+  baseTranscript2
+} from "./aisdk-native-k996mbzp.js";
+import {
+  Service21
+} from "./aisdk-native-bxz5a0az.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/session/generate.ts
+var exports_generate = {};
+__export(exports_generate, {
+  SessionGenerate: () => exports_generate,
+  generate: () => generate3
+});
+import { LLMClient, Message } from "@opencode/ai";
+import { Effect } from "effect";
+var generate3 = Effect.fn("SessionGenerate.generate")(function* (input) {
+  const instances = yield* Service42;
+  const database = yield* Service80;
+  const llm = yield* LLMClient.Service;
+  return yield* Effect.gen(function* () {
+    yield* awaitActivation2;
+    const context = yield* Service21;
+    const selection = yield* context.select(input.session.id);
+    const model = yield* context.resolveModel(selection.session);
+    const history = yield* preview2(database.db, selection.session.id, selection.instructions, provenance2(model) ?? "local");
+    const transcript = baseTranscript2({
+      agent: selection.agent.info,
+      model,
+      tools: selection.tools,
+      initial: history.initial,
+      messages: history.messages
+    });
+    const prepared = yield* context.request.generate({
+      session: selection.session,
+      agent: selection.agent.id,
+      model,
+      tools: selection.tools,
+      system: transcript.system,
+      messages: [
+        ...transcript.messages,
+        ...history.instructionUpdate ? [Message.system(history.instructionUpdate)] : [],
+        Message.user(input.prompt)
+      ]
+    });
+    yield* Effect.logInfo("sending session generation request", {
+      sessionID: selection.session.id,
+      providerID: model.ref.providerID,
+      modelID: model.ref.id
+    });
+    const response = yield* llm.generate(prepared.request, prepared.options);
+    yield* Effect.logInfo("session generation usage diagnostic", { usage: response.usage });
+    return response.text;
+  }).pipe(instances.provide(input.session));
+});
+
+export { generate3, exports_generate };

package/dist/chunks/aisdk-native-v6yxqhem.js

@@ -0,0 +1,105 @@
+import {
+  fromPromise2
+} from "./aisdk-native-zr2ceqn5.js";
+import {
+  Service36
+} from "./aisdk-native-39dcxt5x.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/plugin/module.ts
+var exports_module = {};
+__export(exports_module, {
+  LoadError: () => LoadError2,
+  PluginModule: () => exports_module,
+  make: () => make4
+});
+import { Host } from "@opencode/plugin/host";
+import { createPluginSources } from "@opencode/plugin/source";
+import { Npm } from "@opencode/util/npm";
+import { Deferred, Effect, FiberSet, PubSub, Schema, Stream } from "effect";
+import path from "path";
+import { stat } from "node:fs/promises";
+import { fileURLToPath, pathToFileURL } from "url";
+var make4 = Effect.fn("PluginModule.make")(function* () {
+  const watcher = yield* Service36;
+  const scope = yield* Effect.scope;
+  const runPromise = yield* FiberSet.makeRuntimePromise();
+  const changes = yield* PubSub.unbounded();
+  const watched = new Set;
+  const watch = Effect.fn("PluginModule.watch")(function* (file) {
+    if (watched.has(file))
+      return;
+    watched.add(file);
+    const ready = yield* Deferred.make();
+    const target = yield* Effect.promise(() => watchTarget(file));
+    const updates = yield* watcher.subscribe(target, Deferred.succeed(ready, undefined));
+    yield* updates.pipe(Stream.runForEach(() => PubSub.publish(changes, undefined)), Effect.ensuring(Deferred.succeed(ready, undefined)), Effect.forkIn(scope, { startImmediately: true }));
+    yield* Deferred.await(ready);
+  });
+  const sources = yield* Effect.acquireRelease(Effect.sync(() => createPluginSources((file) => runPromise(watch(file)))), (sources) => Effect.sync(() => sources.dispose()));
+  return {
+    load: (operation, options) => load(operation, sources, options),
+    changes: () => Stream.fromPubSub(changes)
+  };
+});
+function watchTarget(file) {
+  return stat(file).then((info) => ({ path: file, type: info.isDirectory() ? "directory" : "file" }), (cause) => {
+    if (path.dirname(file) === file)
+      throw cause;
+    return watchTarget(path.dirname(file));
+  });
+}
+var Module = Schema.Struct({
+  default: Schema.Union([
+    Schema.Struct({
+      id: Schema.String,
+      effect: Schema.declare((input) => typeof input === "function")
+    }),
+    Schema.Struct({
+      id: Schema.String,
+      setup: Schema.declare((input) => typeof input === "function")
+    })
+  ])
+});
+
+class LoadError2 extends Schema.TaggedError()("PluginModule.LoadError", {
+  message: Schema.String,
+  cause: Schema.optional(Schema.Defect())
+}) {
+}
+var load = Effect.fn("PluginModule.load")(function* (operation, sources, options) {
+  const local = path.isAbsolute(operation.target);
+  const npm = yield* Npm.Service;
+  const installed = local ? undefined : options?.install === false ? yield* npm.resolve(operation.target) : yield* npm.add(operation.target);
+  const entrypoints = local && (yield* Effect.promise(() => stat(operation.target))).isFile() ? { server: pathToFileURL(operation.target).href } : yield* Effect.sync(() => Host.resolve(installed ?? { directory: operation.target }));
+  const entrypoint = entrypoints.server;
+  if (!local && options?.install === false && !entrypoint)
+    return { pending: true };
+  if (!entrypoint)
+    return yield* new LoadError2({ message: `Plugin entrypoint not found: ${operation.target}` });
+  yield* Effect.log({ msg: "loading plugin", id: operation.target, entrypoint });
+  const loaded = yield* Effect.promise(() => local ? sources.read(entrypoint) : Host.load(entrypoint).then((module) => ({ module, version: installed?.revision })));
+  const value = (yield* Schema.decodeUnknownEffect(Module)(loaded.module).pipe(Effect.mapError((cause) => new LoadError2({
+    message: "Plugin must export a default definition with an id and an effect or setup function.",
+    cause
+  })))).default;
+  const plugin = "effect" in value ? value : fromPromise2(value);
+  return {
+    id: plugin.id,
+    features: {
+      ...entrypoints.tui ? { tui: true } : {},
+      ...entrypoints.rpc ? { rpc: true } : {}
+    },
+    revision: JSON.stringify([operation, loaded.version]),
+    source: path.isAbsolute(operation.target) ? { type: "local", path: fileURLToPath(entrypoint) } : {
+      type: "package",
+      target: operation.target,
+      ...installed?.version ? { version: installed.version } : {}
+    },
+    effect: (host) => plugin.effect({ ...host, options: operation.options })
+  };
+});
+
+export { make4, LoadError2, exports_module };

package/dist/chunks/aisdk-native-v9kga7nj.js

@@ -0,0 +1,145 @@
+import {
+  ID13,
+  Family2
+} from "./aisdk-native-jghsd1wz.js";
+import {
+  Service35
+} from "./aisdk-native-y9tfvs3x.js";
+import {
+  foldSettings2
+} from "./aisdk-native-6g46d628.js";
+
+// src/plugin/provider/lmstudio.ts
+import { define } from "@opencode/plugin/effect/plugin";
+import { Duration, Effect, Schedule, Schema, Semaphore, Stream } from "effect";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+var providerID = "lmstudio";
+var RemoteModel = Schema.Struct({
+  type: Schema.Literals(["llm", "embedding"]),
+  key: Schema.String,
+  display_name: Schema.String,
+  architecture: Schema.NullOr(Schema.String).pipe(Schema.optional),
+  loaded_instances: Schema.Array(Schema.Struct({
+    config: Schema.Struct({ context_length: Schema.Int })
+  })),
+  max_context_length: Schema.Int,
+  capabilities: Schema.Struct({
+    vision: Schema.Boolean,
+    trained_for_tool_use: Schema.Boolean
+  }).pipe(Schema.optional)
+});
+var Response = Schema.Struct({ models: Schema.Array(RemoteModel) });
+var discovery = new Map;
+var discoveryLock = Semaphore.makeUnsafe(1);
+function make5(origin = "http://127.0.0.1:1234", interval = "30 seconds") {
+  return define({
+    id: "opencode.provider.lmstudio",
+    effect: Effect.fn(function* (ctx) {
+      const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient);
+      const config = yield* Service35;
+      const source = { current: configured(yield* config.entries(), origin) };
+      const loaded = { models: [], hash: "[]" };
+      yield* ctx.integration.transform((integrations) => {
+        if (loaded.models.length === 0)
+          return;
+        integrations.remove(providerID);
+      });
+      yield* ctx.catalog.transform((catalog) => {
+        if (loaded.models.length === 0)
+          return;
+        for (const model of catalog.provider.get(providerID)?.models.values() ?? []) {
+          catalog.model.remove(providerID, model.id);
+        }
+        catalog.provider.update(providerID, (provider) => {
+          provider.name = "LM Studio";
+          provider.activation = "enabled";
+          provider.package = "@opencode/ai/providers/openai-compatible";
+          provider.settings = {
+            baseURL: source.current.baseURL,
+            provider: providerID,
+            apiKey: source.current.apiKey ?? ""
+          };
+          provider.integrationID = undefined;
+        });
+        for (const item of loaded.models) {
+          catalog.model.update(providerID, item.key, (model) => {
+            model.modelID = ID13.make(item.key);
+            model.name = item.display_name || item.key;
+            model.family = item.architecture ? Family2.make(item.architecture) : undefined;
+            model.capabilities = {
+              tools: item.capabilities?.trained_for_tool_use ?? false,
+              input: ["text", ...item.capabilities?.vision ? ["image"] : []],
+              output: ["text"]
+            };
+            const context = item.loaded_instances.length === 0 ? item.max_context_length : Math.min(...item.loaded_instances.map((instance) => instance.config.context_length));
+            if (context > 0)
+              model.limit.context = context;
+          });
+        }
+      });
+      const discover = Effect.fn("LMStudioPlugin.discover")(function* () {
+        const current = source.current;
+        if (!current.endpoint)
+          return;
+        return yield* discoveryLock.withPermit(Effect.gen(function* () {
+          const cached = discovery.get(current.endpoint);
+          if (cached && cached.apiKey === current.apiKey && Date.now() - cached.checked < Duration.toMillis(interval))
+            return { source: current, models: cached.models };
+          discovery.set(current.endpoint, {
+            checked: Date.now(),
+            apiKey: current.apiKey,
+            models: cached && cached.apiKey === current.apiKey ? cached.models : undefined
+          });
+          const request = current.apiKey ? HttpClientRequest.get(current.endpoint).pipe(HttpClientRequest.acceptJson, HttpClientRequest.bearerToken(current.apiKey)) : HttpClientRequest.get(current.endpoint).pipe(HttpClientRequest.acceptJson);
+          const response = yield* http.execute(request).pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(Response)), Effect.timeout("1 second"));
+          const models = response.models.filter((model) => model.type === "llm" && model.key.length > 0).toSorted((a, b) => a.key.localeCompare(b.key));
+          discovery.set(current.endpoint, { checked: Date.now(), apiKey: current.apiKey, models });
+          return { source: current, models };
+        }));
+      });
+      const refresh = Effect.fn("LMStudioPlugin.refresh")(function* () {
+        const result = yield* discover();
+        if (!result?.models || result.source !== source.current)
+          return;
+        const hash = JSON.stringify(result.models);
+        if (hash === loaded.hash)
+          return;
+        loaded.models = result.models;
+        loaded.hash = hash;
+        yield* ctx.integration.reload();
+        yield* ctx.catalog.reload();
+      });
+      yield* refresh().pipe(Effect.ignore, Effect.repeat(Schedule.spaced(interval)), Effect.forkScoped);
+      const reload = Effect.fn("LMStudioPlugin.reload")(function* () {
+        const next = configured(yield* config.entries(), origin);
+        if (next.baseURL === source.current.baseURL && next.apiKey === source.current.apiKey && next.endpoint === source.current.endpoint)
+          return;
+        source.current = next;
+        loaded.models = [];
+        loaded.hash = "[]";
+        yield* ctx.integration.reload();
+        yield* ctx.catalog.reload();
+        yield* refresh().pipe(Effect.ignore);
+      });
+      yield* ctx.event.subscribe().pipe(Stream.filter((event) => event.type === "config.updated"), Stream.runForEach(reload), Effect.forkScoped({ startImmediately: true }));
+    })
+  });
+}
+var LMStudioPlugin2 = make5();
+function configured(entries, origin) {
+  const settings = foldSettings2(entries, providerID, undefined);
+  const baseURL = (typeof settings?.baseURL === "string" ? settings.baseURL : `${origin.replace(/\/+$/, "")}/v1`).replace(/\/+$/, "");
+  const apiKey = typeof settings?.apiKey === "string" ? settings.apiKey : undefined;
+  if (!URL.canParse(baseURL))
+    return { baseURL, apiKey };
+  const url = new URL(baseURL);
+  if (url.protocol !== "http:" && url.protocol !== "https:")
+    return { baseURL, apiKey };
+  const prefix = url.pathname.endsWith("/v1") ? url.pathname.slice(0, -3) : url.pathname.replace(/\/+$/, "");
+  url.pathname = `${prefix}/api/v1/models`;
+  url.search = "";
+  url.hash = "";
+  return { baseURL, apiKey, endpoint: url.toString() };
+}
+
+export { make5, LMStudioPlugin2 };

package/dist/chunks/aisdk-native-vcmavarf.js

@@ -0,0 +1,61 @@
+import {
+  useragent2
+} from "./aisdk-native-cjg4xdhd.js";
+import {
+  ID18
+} from "./aisdk-native-33n3bzdy.js";
+
+// src/plugin/provider/gitlab.ts
+import os from "os";
+import { Effect } from "effect";
+import { define } from "@opencode/plugin/effect/plugin";
+var GitLabPlugin2 = define({
+  id: "opencode.provider.gitlab",
+  effect: Effect.fn(function* (ctx) {
+    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 !== ID18.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
+      });
+    }));
+  })
+});
+
+export { GitLabPlugin2 };

package/dist/chunks/aisdk-native-veqvce7d.js

@@ -0,0 +1,15 @@
+import {
+  createProviderPlugin2
+} from "./aisdk-native-ym463w8f.js";
+
+// src/plugin/provider/perplexity.ts
+var PerplexityPlugin2 = createProviderPlugin2({
+  id: "opencode.provider.perplexity",
+  package: "@ai-sdk/perplexity",
+  load: async (options) => {
+    const { createPerplexity } = await import("@ai-sdk/perplexity");
+    return createPerplexity(options);
+  }
+});
+
+export { PerplexityPlugin2 };

package/dist/chunks/aisdk-native-vfccn5yp.js

@@ -0,0 +1,82 @@
+import {
+  makeWithDefaults2
+} from "./aisdk-native-361ty1x8.js";
+import {
+  apply3
+} from "./aisdk-native-bfexjxds.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/database/database.ts
+var exports_database = {};
+__export(exports_database, {
+  Database: () => exports_database,
+  Options: () => Options11,
+  Service: () => Service80,
+  configured: () => configured13,
+  configuredClient: () => configuredClient2,
+  layer: () => layer26,
+  layerFromClient: () => layerFromClient2,
+  node: () => node85
+});
+import { sqliteLayer, supportsForeignKeyToggle, supportsTuningPragmas } from "#sqlite";
+import { Context, Effect, Layer, Schema, Semaphore } from "effect";
+import { Global } from "@opencode/util/global";
+import { isAbsolute, join } from "path";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+var makeDatabase = makeWithDefaults2();
+var Options11 = Schema.Struct({
+  path: Schema.optional(Schema.String)
+});
+
+class Service80 extends Context.Service()("@opencode/storage/Database") {
+}
+var databaseLayer = (lock) => Layer.effect(Service80, Effect.gen(function* () {
+  const db = yield* makeDatabase;
+  if (supportsTuningPragmas) {
+    yield* db.run("PRAGMA journal_mode = WAL");
+    yield* db.run("PRAGMA synchronous = NORMAL");
+    yield* db.run("PRAGMA busy_timeout = 5000");
+    yield* db.run("PRAGMA cache_size = -64000");
+    yield* db.run("PRAGMA wal_checkpoint(PASSIVE)");
+  }
+  if (supportsForeignKeyToggle)
+    yield* db.run("PRAGMA foreign_keys = ON");
+  const semaphore = yield* lock;
+  yield* semaphore.withPermit(apply3(db));
+  return { db };
+}).pipe(Effect.orDie));
+var locks = new Map;
+function lockFor(filename) {
+  const existing = locks.get(filename);
+  if (existing)
+    return existing;
+  const lock = Semaphore.makeUnsafe(1);
+  locks.set(filename, lock);
+  return lock;
+}
+function layer26(options = { path: ":memory:" }) {
+  return Layer.unwrap(Effect.gen(function* () {
+    const provide = (filename) => databaseLayer(filename === ":memory:" ? Semaphore.make(1) : Effect.succeed(lockFor(filename))).pipe(Layer.provide(sqliteLayer({ filename })));
+    const filename = options.path ?? ":memory:";
+    if (filename === ":memory:" || isAbsolute(filename))
+      return provide(filename);
+    const global = yield* Global.Service;
+    return provide(join(global.data, filename));
+  }));
+}
+var layerFromClient2 = databaseLayer(Semaphore.make(1));
+function configured13(options) {
+  return makeGlobalNode({ service: Service80, layer: layer26(options), deps: [Global.node] });
+}
+function configuredClient2(client) {
+  return makeGlobalNode({
+    service: Service80,
+    layer: layerFromClient2.pipe(Layer.provide(client)),
+    deps: [Global.node]
+  });
+}
+var node85 = configured13({ path: ":memory:" });
+
+export { Options11, Service80, layer26, layerFromClient2, configured13, configuredClient2, node85, exports_database };

package/dist/chunks/aisdk-native-vhbgy75s.js

@@ -0,0 +1,118 @@
+import {
+  useragent2
+} from "./aisdk-native-cjg4xdhd.js";
+import {
+  ID18
+} from "./aisdk-native-33n3bzdy.js";
+import {
+  iife2
+} from "./aisdk-native-1kg9ymc8.js";
+import {
+  configuredSettings2
+} from "./aisdk-native-6g46d628.js";
+
+// src/plugin/provider/cloudflare-ai-gateway.ts
+import os from "os";
+import { Effect, Option, Schema } from "effect";
+import { define } from "@opencode/plugin/effect/plugin";
+import { Form } from "@opencode/schema/form";
+var providerID = ID18.make("cloudflare-ai-gateway");
+var CloudflareAIGatewayPlugin2 = define({
+  id: "opencode.provider.cloudflare.ai.gateway",
+  effect: Effect.fn(function* (ctx) {
+    const configured = yield* configuredSettings2(providerID);
+    const form = iife2(() => {
+      if (typeof configured?.baseURL === "string")
+        return;
+      const accountId = process.env.CLOUDFLARE_ACCOUNT_ID || stringOption(configured ?? {}, "accountId");
+      const gatewayId = process.env.CLOUDFLARE_GATEWAY_ID || stringOption(configured ?? {}, "gatewayId") || stringOption(configured ?? {}, "gateway");
+      if (accountId && gatewayId)
+        return;
+      const accountIdForm = Form.StringField.make({
+        type: "string",
+        key: "accountId",
+        title: "Enter your Cloudflare Account ID",
+        placeholder: "e.g. 1234567890abcdef1234567890abcdef",
+        required: true
+      });
+      const gatewayIdForm = Form.StringField.make({
+        type: "string",
+        key: "gatewayId",
+        title: "Enter your Cloudflare AI Gateway ID",
+        placeholder: "e.g. my-gateway",
+        required: true
+      });
+      if (accountId)
+        return Form.Fields.make([gatewayIdForm]);
+      if (gatewayId)
+        return Form.Fields.make([accountIdForm]);
+      return Form.Fields.make([accountIdForm, gatewayIdForm]);
+    });
+    yield* ctx.integration.transform((editor) => {
+      editor.method.update({
+        integrationID: providerID,
+        method: {
+          type: "key",
+          label: "Gateway API token",
+          form
+        }
+      });
+    });
+    yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+      if (evt.package !== "ai-gateway-provider")
+        return;
+      if (evt.options.baseURL)
+        return;
+      const config = gatewayConfig(evt.options);
+      if (!config)
+        return;
+      const metadata = gatewayMetadata(evt.options);
+      const { createAiGateway } = yield* Effect.promise(() => import("ai-gateway-provider"));
+      const { createUnified } = yield* Effect.promise(() => import("ai-gateway-provider/providers/unified"));
+      const gateway = createAiGateway({
+        accountId: config.accountId,
+        gateway: config.gatewayId,
+        apiKey: config.apiKey,
+        options: gatewayOptions(evt.options, metadata, ctx.app)
+      });
+      const unified = createUnified({ apiKey: config.apiKey });
+      evt.sdk = {
+        languageModel(modelID) {
+          return gateway(unified(modelID));
+        }
+      };
+    }));
+  })
+});
+var decodeJson = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Unknown));
+function gatewayConfig(options) {
+  const accountId = process.env.CLOUDFLARE_ACCOUNT_ID ?? stringOption(options, "accountId");
+  const gatewayId = process.env.CLOUDFLARE_GATEWAY_ID ?? stringOption(options, "gatewayId") ?? stringOption(options, "gateway");
+  const apiKey = process.env.CLOUDFLARE_API_TOKEN ?? process.env.CF_AIG_TOKEN ?? stringOption(options, "apiKey");
+  if (!accountId || !gatewayId || !apiKey)
+    return;
+  return { accountId, gatewayId, apiKey };
+}
+function gatewayMetadata(options) {
+  if (options.metadata !== undefined)
+    return options.metadata;
+  const raw = options.headers?.["cf-aig-metadata"];
+  return raw ? Option.getOrUndefined(decodeJson(raw)) : undefined;
+}
+function gatewayOptions(options, metadata, app) {
+  return {
+    metadata,
+    cacheTtl: options.cacheTtl,
+    cacheKey: options.cacheKey,
+    skipCache: options.skipCache,
+    collectLog: options.collectLog,
+    headers: {
+      "User-Agent": `${useragent2(app)} cloudflare-ai-gateway (${os.platform()} ${os.release()}; ${os.arch()})`
+    }
+  };
+}
+function stringOption(options, key) {
+  return typeof options[key] === "string" ? options[key] : undefined;
+}
+
+export { CloudflareAIGatewayPlugin2 };

package/dist/chunks/aisdk-native-vv78xzwk.js

@@ -0,0 +1,46 @@
+import {
+  Service35
+} from "./aisdk-native-y9tfvs3x.js";
+import {
+  Service51
+} from "./aisdk-native-jx8g4evx.js";
+import {
+  observe2
+} from "./aisdk-native-qsdy395h.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/config/plugin/image.ts
+var exports_image = {};
+__export(exports_image, {
+  ConfigImagePlugin: () => exports_image,
+  Plugin: () => Plugin5
+});
+import { define } from "@opencode/plugin/effect/plugin";
+import { Effect } from "effect";
+var Plugin5 = define({
+  id: "opencode.config.image",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* Service35;
+    const image = yield* Service51;
+    const loaded = yield* observe2(config, ctx.event, image.reload());
+    yield* image.transform((editor) => {
+      for (const entry of loaded.entries) {
+        if (entry.type !== "document")
+          continue;
+        const configured = entry.info.media?.image;
+        if (!configured)
+          continue;
+        editor.configure({
+          ...configured.auto_resize === undefined ? {} : { autoResize: configured.auto_resize },
+          ...configured.max_width === undefined ? {} : { maxWidth: configured.max_width },
+          ...configured.max_height === undefined ? {} : { maxHeight: configured.max_height },
+          ...configured.max_base64_bytes === undefined ? {} : { maxBase64Bytes: configured.max_base64_bytes }
+        });
+      }
+    });
+  })
+});
+
+export { Plugin5, exports_image };