@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-n9rwdya5.js

@@ -0,0 +1,375 @@
+import {
+  exports_runtime
+} from "./permission-h487ttse.js";
+import {
+  exports_websearch
+} from "./permission-08m6gcy4.js";
+import {
+  exports_command
+} from "./permission-d4a2h60z.js";
+import {
+  exports_tool
+} from "./permission-2qdvkq1m.js";
+import {
+  exports_hooks
+} from "./permission-t2j2ttmx.js";
+import {
+  exports_app
+} from "./permission-50jxp3hw.js";
+import {
+  exports_reference
+} from "./permission-anrqexna.js";
+import {
+  exports_catalog
+} from "./permission-849eva8b.js";
+import {
+  exports_integration
+} from "./permission-zxzx89zt.js";
+import {
+  exports_aisdk
+} from "./permission-d076mabj.js";
+import {
+  exports_credential
+} from "./permission-d5t1sv80.js";
+import {
+  exports_skill
+} from "./permission-zr271bqv.js";
+import {
+  exports_agent
+} from "./permission-0c101nc9.js";
+import {
+  exports_workspace
+} from "./permission-n6t016aw.js";
+import {
+  exports_model
+} from "./permission-xfd1xnk3.js";
+import {
+  exports_bus
+} from "./permission-r5ce0emk.js";
+import {
+  exports_provider
+} from "./permission-d6vvk673.js";
+import {
+  exports_location
+} from "./permission-1e2ryyac.js";
+import {
+  AbsolutePath
+} from "./permission-j07kk359.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/plugin/host.ts
+var exports_host = {};
+__export(exports_host, {
+  make: () => make,
+  PluginHost: () => exports_host
+});
+import { EventManifest } from "@opencode-ai/schema/event-manifest";
+import { Effect, Schema, Stream } from "effect";
+var mutable = (value) => value;
+var make = Effect.fn("PluginHost.make")(function* (plugin) {
+  const app = yield* exports_app.Metadata;
+  const agents = yield* exports_agent.Service;
+  const aisdk = yield* exports_aisdk.Service;
+  const catalog = yield* exports_catalog.Service;
+  const commands = yield* exports_command.Service;
+  const bus = yield* exports_bus.Service;
+  const integration = yield* exports_integration.Service;
+  const location = yield* exports_location.Service;
+  const reference = yield* exports_reference.Service;
+  const skill = yield* exports_skill.Service;
+  const tools = yield* exports_tool.Service;
+  const websearch = yield* exports_websearch.Service;
+  const hooks = yield* exports_hooks.Service;
+  const runtime = yield* exports_runtime.Service;
+  const locationInfo = () => new exports_location.Info({
+    directory: location.directory,
+    workspaceID: location.workspaceID,
+    project: location.project
+  });
+  const locationRef = (input) => input?.location === undefined ? undefined : exports_location.Ref.make({
+    directory: AbsolutePath.make(input.location.directory ?? location.directory),
+    workspaceID: input.location.workspace === undefined ? location.workspaceID : exports_workspace.ID.make(input.location.workspace)
+  });
+  const isCurrentLocation = (ref) => ref.directory === location.directory && ref.workspaceID === location.workspaceID;
+  const response = (effect) => effect.pipe(Effect.map((data) => ({ location: locationInfo(), data })));
+  return {
+    app,
+    options: {},
+    agent: {
+      get: (input) => {
+        const ref = locationRef(input);
+        const output = ref && !isCurrentLocation(ref) ? runtime.location.agent.list(ref).pipe(Effect.map((result) => ({
+          ...result,
+          data: result.data.find((agent) => agent.id === input.agentID)
+        }))) : response(agents.get(input.agentID));
+        return output.pipe(Effect.flatMap((result) => result.data ? Effect.succeed({ ...result, data: result.data }) : Effect.fail(new Error(`Agent not found: ${input.agentID}`))));
+      },
+      list: (input) => {
+        const ref = locationRef(input);
+        if (ref && !isCurrentLocation(ref))
+          return runtime.location.agent.list(ref);
+        return agents.list().pipe(Effect.map((data) => ({ location: locationInfo(), data })));
+      },
+      reload: agents.reload,
+      transform: (callback) => agents.transform((draft) => {
+        callback({
+          list: () => mutable(draft.list()),
+          get: (id) => mutable(draft.get(exports_agent.ID.make(id))),
+          default: (id) => draft.default(id === undefined ? undefined : exports_agent.ID.make(id)),
+          update: (id, update) => draft.update(exports_agent.ID.make(id), update),
+          remove: (id) => draft.remove(exports_agent.ID.make(id))
+        });
+      })
+    },
+    aisdk: {
+      hook: (name, callback) => {
+        if (name === "sdk") {
+          return aisdk.hook.sdk((event) => {
+            const output = {
+              model: mutable(event.model),
+              package: event.package,
+              options: event.options,
+              sdk: event.sdk
+            };
+            return Reflect.apply(callback, undefined, [output]).pipe(Effect.tap(() => Effect.sync(() => event.sdk = output.sdk)));
+          });
+        }
+        return aisdk.hook.language((event) => {
+          const output = {
+            model: mutable(event.model),
+            options: event.options,
+            sdk: event.sdk,
+            language: event.language
+          };
+          return Reflect.apply(callback, undefined, [output]).pipe(Effect.tap(() => Effect.sync(() => event.language = output.language)));
+        });
+      }
+    },
+    catalog: {
+      provider: {
+        list: () => response(catalog.provider.available()),
+        get: (input) => catalog.provider.get(exports_provider.ID.make(input.providerID)).pipe(Effect.flatMap((provider) => provider === undefined ? Effect.fail(new Error(`Provider not found: ${input.providerID}`)) : response(Effect.succeed(provider))))
+      },
+      model: {
+        list: () => response(catalog.model.available()),
+        default: () => response(catalog.model.default())
+      },
+      reload: catalog.reload,
+      transform: (callback) => catalog.transform((draft) => {
+        callback({
+          provider: {
+            list: () => mutable(draft.provider.list()),
+            get: (id) => mutable(draft.provider.get(exports_provider.ID.make(id))),
+            update: (id, update) => draft.provider.update(exports_provider.ID.make(id), update),
+            remove: (id) => draft.provider.remove(exports_provider.ID.make(id))
+          },
+          model: {
+            get: (providerID, modelID) => mutable(draft.model.get(exports_provider.ID.make(providerID), exports_model.ID.make(modelID))),
+            update: (providerID, modelID, update) => draft.model.update(exports_provider.ID.make(providerID), exports_model.ID.make(modelID), update),
+            remove: (providerID, modelID) => draft.model.remove(exports_provider.ID.make(providerID), exports_model.ID.make(modelID)),
+            default: {
+              get: draft.model.default.get,
+              set: (providerID, modelID) => draft.model.default.set(exports_provider.ID.make(providerID), exports_model.ID.make(modelID))
+            }
+          }
+        });
+      })
+    },
+    command: {
+      list: () => response(commands.list()),
+      reload: commands.reload,
+      transform: (callback) => commands.transform((draft) => {
+        callback(draft);
+      })
+    },
+    event: {
+      subscribe: () => bus.subscribe().pipe(Stream.filter(EventManifest.isServer))
+    },
+    integration: {
+      list: () => response(integration.list()),
+      get: (input) => response(integration.get(exports_integration.ID.make(input.integrationID))),
+      connect: {
+        key: (input) => integration.connection.key({
+          integrationID: exports_integration.ID.make(input.integrationID),
+          key: input.key,
+          answer: input.answer,
+          label: input.label
+        })
+      },
+      oauth: {
+        connect: (input) => response(integration.oauth.connect({
+          integrationID: exports_integration.ID.make(input.integrationID),
+          methodID: exports_integration.MethodID.make(input.methodID),
+          answer: input.answer,
+          label: input.label
+        })),
+        status: (input) => response(integration.oauth.status({
+          integrationID: exports_integration.ID.make(input.integrationID),
+          attemptID: exports_integration.AttemptID.make(input.attemptID)
+        })),
+        complete: (input) => integration.oauth.complete({
+          integrationID: exports_integration.ID.make(input.integrationID),
+          attemptID: exports_integration.AttemptID.make(input.attemptID),
+          code: input.code
+        }),
+        cancel: (input) => integration.oauth.cancel({
+          integrationID: exports_integration.ID.make(input.integrationID),
+          attemptID: exports_integration.AttemptID.make(input.attemptID)
+        })
+      },
+      command: {
+        connect: (input) => response(integration.command.connect({
+          integrationID: exports_integration.ID.make(input.integrationID),
+          methodID: exports_integration.MethodID.make(input.methodID),
+          label: input.label
+        })),
+        status: (input) => response(integration.command.status({
+          integrationID: exports_integration.ID.make(input.integrationID),
+          attemptID: exports_integration.AttemptID.make(input.attemptID)
+        })),
+        cancel: (input) => integration.command.cancel({
+          integrationID: exports_integration.ID.make(input.integrationID),
+          attemptID: exports_integration.AttemptID.make(input.attemptID)
+        })
+      },
+      reload: integration.reload,
+      connection: {
+        active: (id) => integration.connection.active(exports_integration.ID.make(id)),
+        resolve: (connection) => integration.connection.resolve(connection.type === "credential" ? { ...connection, id: exports_credential.ID.make(connection.id) } : connection)
+      },
+      transform: (callback) => integration.transform((draft) => {
+        callback({
+          list: () => mutable(draft.list()),
+          get: (id) => mutable(draft.get(exports_integration.ID.make(id))),
+          update: (id, update) => draft.update(exports_integration.ID.make(id), update),
+          remove: (id) => draft.remove(exports_integration.ID.make(id)),
+          method: {
+            list: (id) => draft.method.list(exports_integration.ID.make(id)),
+            update: (input) => draft.method.update(methodImplementation(input)),
+            remove: (id, method) => draft.method.remove(exports_integration.ID.make(id), Schema.decodeUnknownSync(exports_integration.Method)(method))
+          }
+        });
+      })
+    },
+    plugin: {
+      list: () => response(plugin.list())
+    },
+    reference: {
+      list: () => response(reference.list()),
+      reload: reference.reload,
+      transform: (callback) => reference.transform((draft) => {
+        callback({
+          add: (name, source) => draft.add(name, Schema.decodeUnknownSync(exports_reference.Source)(source)),
+          remove: draft.remove,
+          list: draft.list
+        });
+      })
+    },
+    skill: {
+      list: () => response(skill.list()),
+      reload: skill.reload,
+      transform: (callback) => skill.transform((draft) => {
+        callback({
+          list: () => mutable(draft.list()),
+          add: (value) => draft.add(Schema.decodeUnknownSync(exports_skill.Info)(value)),
+          update: draft.update,
+          remove: draft.remove
+        });
+      })
+    },
+    shell: {
+      hook: (name, callback) => hooks.register("shell", name, callback)
+    },
+    tool: {
+      transform: (callback) => tools.transform((draft) => callback({
+        add: (tool) => draft.add(tool)
+      })).pipe(Effect.orDie, Effect.as({ dispose: Effect.void })),
+      hook: (name, callback) => hooks.register("tool", name, callback)
+    },
+    websearch: {
+      providers: () => response(websearch.providers()),
+      query: (input) => response(websearch.query({
+        query: input.query,
+        providerID: input.providerID === undefined ? undefined : exports_websearch.ID.make(input.providerID)
+      })),
+      reload: websearch.reload,
+      transform: (callback) => websearch.transform((draft) => {
+        callback({
+          add: (definition) => draft.add({
+            id: exports_websearch.ID.make(definition.id),
+            name: definition.name,
+            execute: definition.execute
+          }),
+          default: {
+            get: draft.default.get,
+            set: (providerID) => draft.default.set(exports_websearch.ID.make(providerID))
+          }
+        });
+      })
+    },
+    session: {
+      hook: (name, callback) => hooks.register("session", name, callback),
+      create: (input) => runtime.session.create({
+        id: input?.id,
+        title: input?.title,
+        agent: input?.agent,
+        model: input?.model,
+        location: input?.location ?? exports_location.Ref.make({ directory: location.directory, workspaceID: location.workspaceID })
+      }),
+      get: (input) => runtime.session.get(input.sessionID),
+      prompt: runtime.session.prompt,
+      generate: (input) => runtime.session.generate(input).pipe(Effect.map((text) => ({ text }))),
+      command: runtime.session.command,
+      rename: runtime.session.rename,
+      synthetic: runtime.session.synthetic,
+      interrupt: (input) => runtime.session.interrupt(input.sessionID),
+      wait: (input) => runtime.session.wait(input.sessionID)
+    }
+  };
+});
+function methodImplementation(input) {
+  if ("authorize" in input) {
+    const refresh = input.refresh;
+    return {
+      integrationID: exports_integration.ID.make(input.integrationID),
+      method: { ...input.method, id: exports_integration.MethodID.make(input.method.id) },
+      authorize: (answer) => input.authorize(answer).pipe(Effect.map((authorization) => {
+        if (authorization.mode === "auto") {
+          return {
+            ...authorization,
+            callback: authorization.callback.pipe(Effect.map(credential))
+          };
+        }
+        return {
+          ...authorization,
+          callback: (code) => authorization.callback(code).pipe(Effect.map(credential))
+        };
+      })),
+      ...refresh ? { refresh: (value) => refresh(value).pipe(Effect.map(credential)) } : {},
+      ...input.label ? { label: input.label } : {}
+    };
+  }
+  if (input.method.type === "env") {
+    return {
+      integrationID: exports_integration.ID.make(input.integrationID),
+      method: input.method
+    };
+  }
+  if (input.method.type === "command") {
+    return {
+      integrationID: exports_integration.ID.make(input.integrationID),
+      method: { ...input.method, id: exports_integration.MethodID.make(input.method.id) }
+    };
+  }
+  return {
+    integrationID: exports_integration.ID.make(input.integrationID),
+    method: input.method
+  };
+}
+function credential(value) {
+  return exports_credential.OAuth.make({ ...value, methodID: exports_integration.MethodID.make(value.methodID) });
+}
+
+export { make, exports_host };

package/dist/chunks/permission-nesb2rcz.js

@@ -0,0 +1,18 @@
+import {
+  ProjectTable
+} from "./permission-88jbfw8z.js";
+import {
+  Timestamps
+} from "./permission-sem2g21k.js";
+
+// src/permission/sql.ts
+import { sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
+var PermissionTable = sqliteTable("permission", {
+  id: text().$type().primaryKey(),
+  project_id: text().$type().notNull().references(() => ProjectTable.id, { onDelete: "cascade" }),
+  action: text().notNull(),
+  resource: text().notNull(),
+  ...Timestamps
+}, (table) => [uniqueIndex("permission_project_action_resource_idx").on(table.project_id, table.action, table.resource)]);
+
+export { PermissionTable };

package/dist/chunks/permission-nkm1m8dz.js

@@ -0,0 +1,25 @@
+// src/database/migration/20260213144116_wakeful_the_professor.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260213144116_wakeful_the_professor",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`control_account\` (
+          \`email\` text NOT NULL,
+          \`url\` text NOT NULL,
+          \`access_token\` text NOT NULL,
+          \`refresh_token\` text NOT NULL,
+          \`token_expiry\` integer,
+          \`active\` integer NOT NULL,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL,
+          CONSTRAINT \`control_account_pk\` PRIMARY KEY(\`email\`, \`url\`)
+        );
+      `);
+    });
+  }
+};
+var _20260213144116_wakeful_the_professor_default = migration;
+
+export { _20260213144116_wakeful_the_professor_default };

package/dist/chunks/permission-nr76rjj3.js

@@ -0,0 +1,46 @@
+import {
+  NamedError
+} from "./permission-hzeg9cfr.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/v1/config/error.ts
+var exports_error = {};
+__export(exports_error, {
+  RemoteAuthError: () => RemoteAuthError,
+  JsonError: () => JsonError,
+  InvalidError: () => InvalidError,
+  FrontmatterError: () => FrontmatterError,
+  DirectoryTypoError: () => DirectoryTypoError,
+  ConfigErrorV1: () => exports_error
+});
+import { Schema } from "effect";
+var Issue = Schema.StructWithRest(Schema.Struct({
+  message: Schema.String,
+  path: Schema.Array(Schema.String)
+}), [Schema.Record(Schema.String, Schema.Unknown)]);
+var JsonError = NamedError.create("ConfigJsonError", {
+  path: Schema.String,
+  message: Schema.optional(Schema.String)
+});
+var InvalidError = NamedError.create("ConfigInvalidError", {
+  path: Schema.String,
+  issues: Schema.optional(Schema.Array(Issue)),
+  message: Schema.optional(Schema.String)
+});
+var FrontmatterError = NamedError.create("ConfigFrontmatterError", {
+  path: Schema.String,
+  message: Schema.String
+});
+var DirectoryTypoError = NamedError.create("ConfigDirectoryTypoError", {
+  path: Schema.String,
+  dir: Schema.String,
+  suggestion: Schema.String
+});
+var RemoteAuthError = NamedError.create("ConfigRemoteAuthError", {
+  url: Schema.String,
+  remote: Schema.String
+});
+
+export { JsonError, InvalidError, FrontmatterError, DirectoryTypoError, RemoteAuthError, exports_error };

package/dist/chunks/permission-nsc0c3zb.js

@@ -0,0 +1,14 @@
+// src/database/migration/20260501142318_next_venus.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260501142318_next_venus",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`session\` ADD \`agent\` text;`);
+      yield* tx.run(`ALTER TABLE \`session\` ADD \`model\` text;`);
+    });
+  }
+};
+var _20260501142318_next_venus_default = migration;
+
+export { _20260501142318_next_venus_default };

package/dist/chunks/permission-nv7zjdpe.js

@@ -0,0 +1,56 @@
+import {
+  buildSQLiteMigrationBackfillStatements,
+  prepareSQLiteMigrationBackfill
+} from "./permission-6sc9h3ca.js";
+import {
+  GET_VERSION_FOR,
+  MIGRATIONS_TABLE_VERSIONS
+} from "./permission-f84sxdqn.js";
+
+// src/database/drizzle/up-migrations/effect-sqlite.ts
+import * as Effect from "effect/Effect";
+import { EffectDrizzleError } from "drizzle-orm/effect-core/errors";
+import { sql } from "drizzle-orm/sql/sql";
+var migrationUpgradeError = (cause) => new EffectDrizzleError({
+  message: typeof cause === "object" && cause !== null && "message" in cause && typeof cause.message === "string" ? cause.message : String(cause),
+  cause
+});
+var upgradeIfNeeded = Effect.fn("upgradeIfNeeded")(function* (migrationsTable, session, localMigrations) {
+  const tableExists = yield* session.all(sql`SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ${migrationsTable}`);
+  if (tableExists.length === 0) {
+    return { newDb: true };
+  }
+  const rows = yield* session.all(sql`SELECT name as column_name FROM pragma_table_info(${migrationsTable})`);
+  const version = GET_VERSION_FOR.sqlite(rows.map((r) => r.column_name));
+  for (let v = version;v < MIGRATIONS_TABLE_VERSIONS.sqlite; v++) {
+    const upgradeFn = upgradeFunctions[v];
+    if (!upgradeFn) {
+      return yield* new EffectDrizzleError({
+        message: `No upgrade path from migration table version ${v} to ${v + 1}`,
+        cause: { version: v }
+      });
+    }
+    yield* upgradeFn(migrationsTable, session, localMigrations);
+  }
+  return { newDb: false };
+});
+var upgradeFunctions = {
+  0: upgradeFromV0
+};
+function upgradeFromV0(migrationsTable, session, localMigrations) {
+  return Effect.gen(function* () {
+    const table = sql`${sql.identifier(migrationsTable)}`;
+    const dbRows = yield* session.all(sql`SELECT id, hash, created_at FROM ${table} ORDER BY id ASC`);
+    const statements = yield* Effect.try({
+      try: () => buildSQLiteMigrationBackfillStatements(migrationsTable, prepareSQLiteMigrationBackfill(dbRows, localMigrations)),
+      catch: migrationUpgradeError
+    });
+    yield* session.transaction((tx) => Effect.gen(function* () {
+      for (const statement of statements) {
+        yield* tx.run(statement);
+      }
+    }));
+  });
+}
+
+export { upgradeIfNeeded };

package/dist/chunks/permission-nzrjycs5.js

@@ -0,0 +1,21 @@
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/v1/config/skills.ts
+var exports_skills = {};
+__export(exports_skills, {
+  Info: () => Info,
+  ConfigSkillsV1: () => exports_skills
+});
+import { Schema } from "effect";
+var Info = Schema.Struct({
+  paths: Schema.optional(Schema.Array(Schema.String)).annotate({
+    description: "Additional paths to skill folders"
+  }),
+  urls: Schema.optional(Schema.Array(Schema.String)).annotate({
+    description: "URLs to fetch skills from (e.g., https://example.com/.well-known/skills/)"
+  })
+});
+
+export { Info, exports_skills };

package/dist/chunks/permission-p2ry9sj0.js

@@ -0,0 +1,121 @@
+import {
+  iife
+} from "./permission-ehj9csmv.js";
+import {
+  configuredSettings
+} from "./permission-gxp1x3zs.js";
+import {
+  exports_app
+} from "./permission-50jxp3hw.js";
+import {
+  exports_provider
+} from "./permission-d6vvk673.js";
+import {
+  __require
+} from "./permission-rvfvac9x.js";
+
+// src/plugin/provider/cloudflare-ai-gateway.ts
+import os from "os";
+import { Effect, Option, Schema } from "effect";
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Form } from "@opencode-ai/schema/form";
+var providerID = exports_provider.ID.make("cloudflare-ai-gateway");
+var CloudflareAIGatewayPlugin = define({
+  id: "opencode.provider.cloudflare-ai-gateway",
+  effect: Effect.fn(function* (ctx) {
+    const configured = yield* configuredSettings(providerID);
+    const form = iife(() => {
+      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((draft) => {
+      draft.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")).pipe(Effect.orDie);
+      const { createUnified } = yield* Effect.promise(() => import("ai-gateway-provider/providers/unified")).pipe(Effect.orDie);
+      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.UnknownFromJsonString);
+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": `${exports_app.useragent(app)} cloudflare-ai-gateway (${os.platform()} ${os.release()}; ${os.arch()})`
+    }
+  };
+}
+function stringOption(options, key) {
+  return typeof options[key] === "string" ? options[key] : undefined;
+}
+
+export { CloudflareAIGatewayPlugin };