@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-fcgysgr5.js

@@ -0,0 +1,202 @@
+import {
+  useragent2
+} from "./repository-j4z2qnee.js";
+import {
+  OAuth3,
+  Service75
+} from "./repository-sztg2hv4.js";
+import {
+  ID13,
+  MethodID2
+} from "./repository-0zkv00cg.js";
+import {
+  ID16
+} from "./repository-pye8sh6e.js";
+
+// src/plugin/provider/xai.ts
+import { define } from "@opencode/plugin/effect/plugin";
+import { Clock, Effect, Option, Schema } from "effect";
+var clientID = "b1a00492-073a-47ea-816f-4c329264a828";
+var issuer = "https://auth.x.ai/oauth2";
+var deviceGrant = "urn:ietf:params:oauth:grant-type:device_code";
+var scope = "openid profile email offline_access grok-cli:access api:access";
+var pollingSafetyMargin = 3000;
+var browserMethodID = MethodID2.make("browser");
+var deviceMethodID = MethodID2.make("device");
+var providerID = ID16.make("xai");
+var Token = Schema.Struct({
+  access_token: Schema.String,
+  refresh_token: Schema.optional(Schema.String),
+  expires_in: Schema.optional(Schema.Number)
+});
+var Device = Schema.Struct({
+  device_code: Schema.String,
+  user_code: Schema.String,
+  verification_uri: Schema.String,
+  verification_uri_complete: Schema.optional(Schema.String),
+  expires_in: Schema.optional(Schema.Number),
+  interval: Schema.optional(Schema.Number)
+});
+var DeviceError = Schema.Struct({
+  error: Schema.optional(Schema.String),
+  error_description: Schema.optional(Schema.String)
+});
+var decodeDeviceError = Schema.decodeUnknownOption(Schema.fromJsonString(DeviceError));
+var device = (app) => ({
+  integrationID: ID13.make("xai"),
+  method: {
+    id: deviceMethodID,
+    type: "oauth",
+    label: "SuperGrok Subscription"
+  },
+  authorize: () => request(`${issuer}/device/code`, {
+    method: "POST",
+    headers: headers(app),
+    body: new URLSearchParams({ client_id: clientID, scope, referrer: "opencode" }).toString()
+  }, Device).pipe(Effect.flatMap((value) => Clock.currentTimeMillis.pipe(Effect.map((created) => {
+    const lifetime = positiveSeconds(value.expires_in, 0);
+    return {
+      mode: "auto",
+      url: value.verification_uri_complete ?? value.verification_uri,
+      instructions: `Open ${value.verification_uri} on any device and enter code: ${value.user_code}`,
+      ...lifetime ? { expiresAt: created + lifetime * 1000 } : {},
+      callback: poll(value, app).pipe(Effect.flatMap((tokens) => credential(deviceMethodID, tokens)))
+    };
+  })))),
+  refresh: (value) => refresh(deviceMethodID, OAuth3.make({ ...value, methodID: deviceMethodID }), app)
+});
+var XAIPlugin2 = define({
+  id: "opencode.provider.xai",
+  effect: Effect.fn(function* (ctx) {
+    const credentials = yield* Service75;
+    yield* Effect.forEach(yield* credentials.list(ID13.make("xai")), (credential) => {
+      if (credential.value.type !== "oauth" || credential.value.methodID !== browserMethodID)
+        return Effect.void;
+      return credentials.update(credential.id, {
+        value: OAuth3.make({ ...credential.value, methodID: deviceMethodID })
+      });
+    }, { discard: true });
+    yield* ctx.integration.transform((editor) => {
+      editor.update("xai", (integration) => {
+        integration.name = "xAI";
+      });
+      editor.method.update(device(ctx.app));
+      editor.method.update({ integrationID: "xai", method: { type: "key", label: "Manually enter API Key" } });
+    });
+    yield* ctx.catalog.transform((catalog) => {
+      const provider = catalog.provider.get(providerID);
+      if (!provider)
+        return;
+      for (const model of provider.models.values()) {
+        catalog.model.update(providerID, model.id, (draft) => {
+          draft.capabilities.responsesWebsockets = true;
+          draft.websocket = true;
+        });
+      }
+    });
+  })
+});
+function refresh(methodID, value, app) {
+  return request(`${issuer}/token`, {
+    method: "POST",
+    headers: headers(app),
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: value.refresh,
+      client_id: clientID
+    }).toString()
+  }, Token).pipe(Effect.flatMap((tokens) => credential(methodID, tokens, value.refresh, value.metadata)));
+}
+function poll(device, app) {
+  return Effect.gen(function* () {
+    const started = yield* Clock.currentTimeMillis;
+    const expires = started + positiveSeconds(device.expires_in, 300) * 1000;
+    const loop = (interval) => Effect.gen(function* () {
+      if ((yield* Clock.currentTimeMillis) >= expires) {
+        return yield* Effect.fail(new Error("xAI device authorization timed out"));
+      }
+      const response = yield* send(`${issuer}/token`, {
+        method: "POST",
+        headers: headers(app),
+        body: new URLSearchParams({
+          grant_type: deviceGrant,
+          client_id: clientID,
+          device_code: device.device_code
+        }).toString()
+      });
+      if (response.ok)
+        return yield* decode(response, Token);
+      const error = yield* Effect.promise(() => response.text()).pipe(Effect.map((body) => Option.getOrUndefined(decodeDeviceError(body))), Effect.orElseSucceed(() => {
+        return;
+      }));
+      if (error?.error === "authorization_pending") {
+        return yield* Effect.sleep(interval + pollingSafetyMargin).pipe(Effect.andThen(loop(interval)));
+      }
+      if (error?.error === "slow_down") {
+        const next = interval + 5000;
+        return yield* Effect.sleep(next + pollingSafetyMargin).pipe(Effect.andThen(loop(next)));
+      }
+      if (error?.error === "access_denied" || error?.error === "authorization_denied") {
+        return yield* Effect.fail(new Error("xAI device authorization was denied"));
+      }
+      if (error?.error === "expired_token") {
+        return yield* Effect.fail(new Error("xAI device code expired - please re-run login"));
+      }
+      const detail = error?.error_description ?? error?.error;
+      return yield* Effect.fail(new Error(`xAI device token exchange failed (${response.status})${detail ? `: ${detail}` : ""}`));
+    });
+    return yield* loop(Math.max(positiveSeconds(device.interval, 5) * 1000, 1000));
+  });
+}
+function request(url, init, schema) {
+  return send(url, init).pipe(Effect.flatMap((response) => {
+    if (response.ok)
+      return decode(response, schema);
+    return Effect.promise(() => response.text()).pipe(Effect.flatMap((detail) => Effect.fail(new Error(`xAI request failed (${response.status})${detail ? `: ${detail}` : ""}`))));
+  }));
+}
+function send(url, init) {
+  return Effect.tryPromise({
+    try: (signal) => fetch(url, { ...init, signal }),
+    catch: (cause) => cause
+  });
+}
+function decode(response, schema) {
+  return Effect.promise(() => response.json()).pipe(Effect.map(Schema.decodeUnknownSync(schema)));
+}
+function credential(methodID, tokens, currentRefresh, metadata) {
+  const refresh = tokens.refresh_token ?? currentRefresh;
+  if (!refresh)
+    return Effect.fail(new Error("xAI token response is missing refresh_token"));
+  return Effect.succeed(OAuth3.make({
+    type: "oauth",
+    methodID,
+    refresh,
+    access: tokens.access_token,
+    expires: tokenExpiration(tokens),
+    metadata
+  }));
+}
+function tokenExpiration(tokens) {
+  if (tokens.expires_in)
+    return Date.now() + positiveSeconds(tokens.expires_in, 3600) * 1000;
+  const payload = tokens.access_token.split(".")[1];
+  if (!payload)
+    return Date.now() + 3600 * 1000;
+  const claims = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Struct({ exp: Schema.optional(Schema.Number) })))(Buffer.from(payload, "base64url").toString());
+  const expiration = Option.getOrUndefined(claims)?.exp;
+  return expiration ? expiration * 1000 : Date.now() + 3600 * 1000;
+}
+function headers(app) {
+  return {
+    "Content-Type": "application/x-www-form-urlencoded",
+    Accept: "application/json",
+    "User-Agent": useragent2(app)
+  };
+}
+function positiveSeconds(value, fallback) {
+  const seconds = Number(value);
+  return Number.isFinite(seconds) && seconds > 0 ? seconds : fallback;
+}
+
+export { XAIPlugin2 };

package/dist/chunks/repository-fd410y7t.js

@@ -0,0 +1,13 @@
+// src/database/migration/20260504145000_add_sync_owner.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260504145000_add_sync_owner",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`event_sequence\` ADD \`owner_id\` text;`);
+    });
+  }
+};
+var _20260504145000_add_sync_owner_default = migration;
+
+export { _20260504145000_add_sync_owner_default };

package/dist/chunks/repository-ff9w6xrb.js

@@ -0,0 +1,96 @@
+import {
+  useragent2
+} from "./repository-j4z2qnee.js";
+import {
+  call2
+} from "./repository-56gdpj1q.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/plugin/websearch/parallel.ts
+var exports_parallel = {};
+__export(exports_parallel, {
+  Plugin: () => Plugin31,
+  WebSearchParallel: () => exports_parallel,
+  endpoint: () => endpoint2
+});
+import { define } from "@opencode/plugin/effect/plugin";
+import { Effect, Schema } from "effect";
+import { HttpClient } from "effect/unstable/http";
+var endpoint2 = "https://search.parallel.ai/mcp";
+var McpInput = Schema.Struct({
+  objective: Schema.String,
+  search_queries: Schema.Array(Schema.String),
+  model_name: Schema.String.check(Schema.isMaxLength(100)).pipe(Schema.optional)
+});
+var SearchResponse = Schema.Struct({
+  search_id: Schema.String,
+  results: Schema.Array(Schema.Struct({
+    url: Schema.String,
+    title: Schema.NullOr(Schema.String).pipe(Schema.optional),
+    publish_date: Schema.NullOr(Schema.String).pipe(Schema.optional),
+    excerpts: Schema.Array(Schema.String)
+  })),
+  warnings: Schema.NullOr(Schema.Array(Schema.Struct({
+    type: Schema.Literals(["spec_validation_warning", "input_validation_warning", "warning"]),
+    message: Schema.String,
+    detail: Schema.NullOr(Schema.Record(Schema.String, Schema.Json)).pipe(Schema.optional)
+  }))).pipe(Schema.optional),
+  usage: Schema.NullOr(Schema.Array(Schema.Struct({
+    name: Schema.String,
+    count: Schema.Int
+  }))).pipe(Schema.optional),
+  session_id: Schema.String
+});
+var McpOutput = Schema.Struct({
+  content: Schema.Array(Schema.Struct({ type: Schema.Literal("text"), text: Schema.String })),
+  structuredContent: SearchResponse
+});
+var Plugin31 = define({
+  id: "opencode.websearch.parallel",
+  effect: Effect.fn("WebSearchParallel.Plugin")(function* (ctx) {
+    const http = yield* HttpClient.HttpClient;
+    yield* ctx.integration.transform((editor) => {
+      editor.update("parallel", (integration) => integration.name = "Parallel");
+      editor.method.update({
+        integrationID: "parallel",
+        method: { type: "key" }
+      });
+      editor.method.update({
+        integrationID: "parallel",
+        method: { type: "env", names: ["PARALLEL_API_KEY"] }
+      });
+    });
+    yield* ctx.websearch.transform((editor) => {
+      editor.add({
+        id: "parallel",
+        name: "Parallel",
+        execute: (input) => Effect.gen(function* () {
+          const connection = yield* ctx.integration.connection.active("parallel");
+          const credential = connection ? yield* ctx.integration.connection.resolve(connection) : undefined;
+          const result = yield* call2(http, endpoint2, "web_search", { input: McpInput, output: McpOutput }, {
+            objective: input.query,
+            search_queries: [input.query]
+          }, {
+            "User-Agent": useragent2(ctx.app),
+            ...credential?.type === "key" ? { Authorization: `Bearer ${credential.key}` } : {}
+          });
+          return result?.structuredContent.results.map((item) => {
+            const published = item.publish_date ? Date.parse(item.publish_date) : undefined;
+            return {
+              url: item.url,
+              ...item.title ? { title: item.title } : {},
+              ...item.excerpts.length ? { content: item.excerpts.join(`
+
+`) } : {},
+              time: { ...published !== undefined && Number.isFinite(published) ? { published } : {} }
+            };
+          }) ?? [];
+        })
+      });
+    });
+  })
+});
+
+export { endpoint2, Plugin31, exports_parallel };

package/dist/chunks/repository-fmdgzt8c.js

@@ -0,0 +1,323 @@
+import {
+  ID16,
+  isAISDK2,
+  packageName2,
+  loadPackage2,
+  nativeSettings2,
+  mergeOverlay2,
+  mergeHeaders2
+} from "./repository-pye8sh6e.js";
+import {
+  Service72,
+  node76
+} from "./repository-c9wtqnwj.js";
+import {
+  map2
+} from "./repository-b6hy6gkz.js";
+import {
+  ID14,
+  VariantID2,
+  Ref4
+} from "./repository-nxamnhdf.js";
+import {
+  ID13,
+  Service74,
+  node78
+} from "./repository-0zkv00cg.js";
+import {
+  Service73,
+  node77
+} from "./repository-gtm8txn9.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/model-resolver.ts
+var exports_model_resolver = {};
+__export(exports_model_resolver, {
+  InitializationPhase: () => InitializationPhase2,
+  ModelConfigurationError: () => ModelConfigurationError3,
+  ModelInitializationError: () => ModelInitializationError3,
+  ModelResolver: () => exports_model_resolver,
+  Service: () => Service71,
+  UnresolvedProviderVariablesError: () => UnresolvedProviderVariablesError3,
+  UnsupportedCompactionError: () => UnsupportedCompactionError3,
+  UnsupportedPackageError: () => UnsupportedPackageError3,
+  VariantUnavailableError: () => VariantUnavailableError3,
+  fromCatalogModel: () => fromCatalogModel2,
+  hasPackage: () => hasPackage2,
+  layer: () => layer24,
+  node: () => node75,
+  resolveModel: () => resolveModel2,
+  withVariant: () => withVariant2
+});
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { LanguageModel, ProviderConfigurationError } from "@opencode/ai";
+import { Auth } from "@opencode/ai/route";
+import { Context, Effect, Layer, Schema, Struct } from "effect";
+import { Npm } from "@opencode/util/npm";
+class VariantUnavailableError3 extends Schema.TaggedError()("SessionRunnerModel.VariantUnavailableError", {
+  providerID: ID16,
+  modelID: ID14,
+  variant: VariantID2
+}) {
+  get message() {
+    return `Variant unavailable for ${this.providerID}/${this.modelID}: ${this.variant}`;
+  }
+}
+
+class UnsupportedPackageError3 extends Schema.TaggedError()("SessionRunnerModel.UnsupportedPackageError", {
+  providerID: ID16,
+  modelID: ID14,
+  package: Schema.String
+}) {
+  get message() {
+    return `Unsupported package for ${this.providerID}/${this.modelID}: ${this.package}`;
+  }
+}
+var InitializationPhase2 = Schema.Literals(["load", "init", "construct"]);
+
+class ModelConfigurationError3 extends Schema.TaggedError()("SessionRunnerModel.ModelConfigurationError", {
+  providerID: ID16,
+  modelID: ID14,
+  package: Schema.String,
+  detail: Schema.String
+}) {
+  get message() {
+    return `Cannot initialize ${this.providerID}/${this.modelID}: ${this.detail}`;
+  }
+}
+
+class ModelInitializationError3 extends Schema.TaggedError()("SessionRunnerModel.ModelInitializationError", {
+  providerID: ID16,
+  modelID: ID14,
+  package: Schema.String,
+  phase: InitializationPhase2,
+  detail: Schema.String
+}) {
+  get message() {
+    return `Cannot initialize ${this.providerID}/${this.modelID}: ${this.detail}`;
+  }
+}
+
+class UnresolvedProviderVariablesError3 extends Schema.TaggedError()("SessionRunnerModel.UnresolvedProviderVariablesError", {
+  providerID: ID16,
+  modelID: ID14,
+  variables: Schema.Array(Schema.String)
+}) {
+  get message() {
+    return `Cannot initialize ${this.providerID}/${this.modelID}: ${this.variables.join(", ")} ${this.variables.length === 1 ? "is" : "are"} required to resolve the provider endpoint`;
+  }
+}
+
+class UnsupportedCompactionError3 extends Schema.TaggedError()("SessionRunnerModel.UnsupportedCompactionError", {
+  providerID: ID16,
+  modelID: ID14,
+  route: Schema.String
+}) {
+  get message() {
+    return `Provider compaction is not supported by ${this.providerID}/${this.modelID} (${this.route})`;
+  }
+}
+
+class Service71 extends Context.Service()("@opencode/ModelResolver") {
+}
+var withVariant2 = (model, variantID) => {
+  const id = variantID === "default" ? undefined : variantID;
+  const variant = model.variants?.find((item) => item.id === id);
+  if (!variant && id !== undefined)
+    return Effect.fail(new VariantUnavailableError3({
+      providerID: model.providerID,
+      modelID: model.id,
+      variant: id
+    }));
+  return Effect.succeed(variant ? {
+    ...model,
+    settings: mergeOverlay2(model.settings, variant.settings),
+    headers: mergeHeaders2(model.headers, variant.headers),
+    body: mergeOverlay2(model.body, variant.body)
+  } : model);
+};
+var fromCatalogModel2 = (model, credential, dependencies) => resolveCatalogModel(model, credential, dependencies).pipe(Effect.flatMap((resolved) => validateProviderVariables(model, resolved)), Effect.flatMap((resolved) => {
+  if (model.compaction?.mode !== "provider" || resolved.route.compact?.trigger || resolved.route.compact?.endpoint)
+    return Effect.succeed(resolved);
+  return Effect.fail(new UnsupportedCompactionError3({ providerID: model.providerID, modelID: model.id, route: resolved.route.id }));
+}));
+var resolveCatalogModel = Effect.fn("ModelResolver.resolveCatalogModel")(function* (model, credential, dependencies) {
+  const resolved = prepareRuntimeModel(model, credential);
+  const packageName = packageName2(resolved.package);
+  const configuration = credential?.type === "key" ? credential.configuration : undefined;
+  const configured = { ...resolved.settings, ...credential?.metadata, ...configuration };
+  const mapping = isAISDK2(resolved.package) ? map2({
+    packageName,
+    settings: configured,
+    modelID: resolved.modelID ?? resolved.id,
+    providerID: resolved.canonical ?? resolved.providerID
+  }) : undefined;
+  const native = mapping?.package ?? packageName;
+  if (isAISDK2(resolved.package) && !mapping) {
+    const loadAISDK = dependencies?.loadAISDK;
+    if (!loadAISDK)
+      return yield* unsupported(resolved);
+    const settings = yield* prepareProviderSettings(resolved, mergeOverlay2(resolved.settings, {
+      ...nativeCredentialSettings(resolved.package ?? "", credential),
+      ...credential?.metadata,
+      ...configuration
+    }) ?? {});
+    return yield* loadAISDK({ ...resolved, settings }).pipe(Effect.mapError((error) => initialization(resolved, "init", error.cause)));
+  }
+  if (!native)
+    return yield* unsupported(resolved);
+  const specifier = native;
+  const mapped = yield* prepareProviderSettings(resolved, nativeSettings2(mapping?.settings ?? configured));
+  const module = yield* (dependencies?.loadPackage ?? loadPackage2)(specifier).pipe(Effect.mapError((error) => initialization(resolved, "load", error.cause)));
+  const settings = {
+    ...credential ? Struct.omit(mapped, ["accessToken", "apiKey", "authToken"]) : mapped,
+    ...resolved.canonical === undefined ? {} : { provider: resolved.canonical },
+    ...nativeCredentialSettings(specifier, credential),
+    headers: mergeHeaders2(mapping?.headers, resolved.headers),
+    body: mergeOverlay2(mapping?.body, resolved.body)
+  };
+  return yield* Effect.try({
+    try: () => {
+      const runtime = module.model(resolved.modelID ?? resolved.id, settings);
+      return LanguageModel.update(runtime, {
+        provider: resolved.canonical ?? resolved.providerID,
+        compatibility: resolved.compatibility ? Object.assign({}, runtime.compatibility, resolved.compatibility) : runtime.compatibility
+      });
+    },
+    catch: (cause) => cause instanceof ProviderConfigurationError ? new ModelConfigurationError3({
+      providerID: resolved.providerID,
+      modelID: resolved.id,
+      package: resolved.package ?? "unknown",
+      detail: cause.message
+    }) : initialization(resolved, "construct", cause)
+  });
+});
+function prepareRuntimeModel(model, credential) {
+  if (model.settings?.apiKey !== "" && (credential?.type !== "key" || credential.metadata === undefined))
+    return model;
+  return {
+    ...model,
+    ...model.settings?.apiKey === "" ? { settings: Struct.omit(model.settings, ["apiKey"]) } : {},
+    ...credential?.type === "key" && credential.metadata !== undefined ? { body: mergeOverlay2(model.body, credential.metadata) } : {}
+  };
+}
+function validateProviderVariables(model, resolved) {
+  const baseURL = resolved.route.endpoint.baseURL;
+  if (typeof baseURL !== "string")
+    return Effect.succeed(resolved);
+  const failure = unresolvedProviderVariables(model, baseURL);
+  return failure ? Effect.fail(failure) : Effect.succeed(resolved);
+}
+function prepareProviderSettings(model, settings) {
+  const baseURL = settings.baseURL;
+  if (typeof baseURL !== "string")
+    return Effect.succeed(settings);
+  return prepareProviderURL(model, baseURL).pipe(Effect.map((prepared) => prepared === baseURL ? settings : { ...settings, baseURL: prepared }));
+}
+function prepareProviderURL(model, baseURL) {
+  if (!baseURL.includes("${"))
+    return Effect.succeed(baseURL);
+  const prepared = baseURL.replace(/\$\{([^}]+)\}/g, (placeholder, name) => process.env[name] ?? placeholder);
+  const failure = unresolvedProviderVariables(model, prepared);
+  return failure ? Effect.fail(failure) : Effect.succeed(prepared);
+}
+function unresolvedProviderVariables(model, baseURL) {
+  const variables = new Set(Array.from(baseURL.matchAll(/\$\{([^}]+)\}/g), (match) => match[1]));
+  if (variables.size === 0)
+    return;
+  return new UnresolvedProviderVariablesError3({
+    providerID: model.providerID,
+    modelID: model.id,
+    variables: Array.from(variables)
+  });
+}
+var nativeCredentialSettings = (specifier, credential) => {
+  if (!credential)
+    return {};
+  if (credential.type === "key")
+    return { apiKey: credential.key };
+  if (specifier === "@opencode/ai/providers/anthropic" || specifier === "@opencode/ai/providers/anthropic-compatible")
+    return { authToken: credential.access };
+  if (specifier === "@opencode/ai/providers/google-vertex" || specifier.startsWith("@opencode/ai/providers/google-vertex/"))
+    return { accessToken: credential.access };
+  return { apiKey: credential.access };
+};
+var unsupported = (model) => new UnsupportedPackageError3({
+  providerID: model.providerID,
+  modelID: model.id,
+  package: model.package ?? "unknown"
+});
+var initialization = (model, phase, cause) => new ModelInitializationError3({
+  providerID: model.providerID,
+  modelID: model.id,
+  package: model.package ?? "unknown",
+  phase,
+  detail: causeMessage(cause) ?? `${phase} failed for ${model.package ?? "unknown"}`
+});
+var causeMessage = (cause) => {
+  if (typeof cause === "string")
+    return cause.trim() || undefined;
+  if (!(cause instanceof globalThis.Error))
+    return;
+  const message = cause.message.trim();
+  if (message)
+    return message;
+  return causeMessage(cause.cause);
+};
+var resolveModel2 = (model, variant, credential, dependencies) => withVariant2(model, variant).pipe(Effect.flatMap((model) => fromCatalogModel2(model, credential, dependencies)));
+var hasPackage2 = (model) => Boolean(model.package);
+var layer24 = Layer.effect(Service71, Effect.gen(function* () {
+  const catalog = yield* Service73;
+  const integrations = yield* Service74;
+  const npm = yield* Npm.Service;
+  const aisdk = yield* Service72;
+  const load = Effect.fn("ModelResolver.resolveModel")(function* (selected, variant) {
+    const provider = yield* catalog.provider.get(selected.providerID);
+    const connection = yield* integrations.connection.active(provider?.integrationID ?? ID13.make(selected.providerID));
+    const credential = connection ? yield* integrations.connection.resolve(connection) : undefined;
+    const runtimeInfo = yield* withVariant2(selected, variant);
+    const model = yield* fromCatalogModel2(runtimeInfo, credential, {
+      loadPackage: (specifier) => loadPackage2(specifier, npm),
+      loadAISDK: (model) => aisdk.model(model)
+    });
+    const runtime = provider?.activation === "enabled" && credential === undefined && !hasConfiguredAuth(runtimeInfo) && usesAPIKeyAuth(runtimeInfo.package) ? LanguageModel.update(model, { route: model.route.with({ auth: Auth.none }) }) : model;
+    return {
+      model: runtime,
+      ref: Ref4.make({
+        id: selected.id,
+        providerID: selected.providerID,
+        ...variant === undefined ? {} : { variant }
+      }),
+      capabilities: selected.capabilities,
+      cost: selected.cost,
+      limit: selected.limit,
+      compaction: selected.compaction,
+      websocket: selected.websocket ?? false
+    };
+  });
+  return Service71.of({
+    resolve: Effect.fn("ModelResolver.resolve")(function* (requested) {
+      const selected = requested ? yield* catalog.model.get(requested.providerID, requested.id) : yield* catalog.model.default().pipe(Effect.flatMap((model) => model && hasPackage2(model) ? Effect.succeed(model) : Effect.map(catalog.model.available(), (models) => models.find(hasPackage2))));
+      if (!selected)
+        return;
+      return yield* load(selected, requested?.variant);
+    }),
+    resolveModel: load
+  });
+}));
+function hasConfiguredAuth(model) {
+  return [model.settings?.apiKey, model.settings?.authToken, model.settings?.accessToken].some((value) => typeof value === "string" && value !== "");
+}
+function usesAPIKeyAuth(packageName) {
+  const name = packageName2(packageName);
+  return name === "@ai-sdk/openai" || name === "@ai-sdk/anthropic" || name === "@ai-sdk/cerebras" || name === "@ai-sdk/deepinfra" || name === "@ai-sdk/openai-compatible" || name === "@ai-sdk/google" || name === "@ai-sdk/groq" || name === "@ai-sdk/mistral" || name === "@ai-sdk/togetherai" || name === "@ai-sdk/xai" || name === "@openrouter/ai-sdk-provider" || name === "@ai-sdk/azure" || name === "@opencode/ai/providers/openai" || name?.startsWith("@opencode/ai/providers/openai/") === true || name === "@opencode/ai/providers/anthropic" || name === "@opencode/ai/providers/anthropic-compatible" || name === "@opencode/ai/providers/baseten" || name === "@opencode/ai/providers/cerebras" || name === "@opencode/ai/providers/cloudflare-ai-gateway" || name === "@opencode/ai/providers/cloudflare-workers-ai" || name === "@opencode/ai/providers/deepinfra" || name === "@opencode/ai/providers/deepseek" || name === "@opencode/ai/providers/fireworks" || name === "@opencode/ai/providers/openai-compatible" || name === "@opencode/ai/providers/google" || name === "@opencode/ai/providers/groq" || name === "@opencode/ai/providers/mistral" || name === "@opencode/ai/providers/togetherai" || name === "@opencode/ai/providers/xai" || name === "@opencode/ai/providers/openrouter" || name === "@opencode/ai/providers/azure" || name?.startsWith("@opencode/ai/providers/azure/") === true;
+}
+var node75 = makeLocationNode({
+  service: Service71,
+  layer: layer24,
+  deps: [node77, node78, Npm.node, node76]
+});
+
+export { VariantUnavailableError3, UnsupportedPackageError3, InitializationPhase2, ModelConfigurationError3, ModelInitializationError3, UnresolvedProviderVariablesError3, UnsupportedCompactionError3, Service71, withVariant2, fromCatalogModel2, resolveModel2, hasPackage2, layer24, node75, exports_model_resolver };