@opencode-ai/core 0.0.0-dev-17471

package/dist/types/mcp/index.d.ts

@@ -0,0 +1,225 @@
+export * as MCP from "./index.js";
+import { Mcp } from "@opencode-ai/schema/mcp";
+import { ConfigMCP } from "@opencode-ai/schema/config/mcp";
+import { Cause, Context, Effect, Layer, Schema } from "effect";
+import { Config } from "../config.js";
+import { Credential } from "../credential.js";
+import { Bus } from "../bus.js";
+import { Environment } from "../environment/index.js";
+import { Form } from "../form.js";
+import { Integration } from "../integration.js";
+import { Location } from "../location.js";
+export declare const ServerName: Schema.brand<Schema.String, "MCP.ServerName">;
+export type ServerName = typeof ServerName.Type;
+export declare const Status: Schema.toTaggedUnion<"status", readonly [Schema.Struct<{
+    readonly status: Schema.Literal<"connected">;
+}>, Schema.Struct<{
+    readonly status: Schema.Literal<"pending">;
+}>, Schema.Struct<{
+    readonly status: Schema.Literal<"disabled">;
+}>, Schema.Struct<{
+    readonly status: Schema.Literal<"failed">;
+    readonly error: Schema.String;
+}>, Schema.Struct<{
+    readonly status: Schema.Literal<"needs_auth">;
+}>]>;
+export type Status = Mcp.Status;
+declare const ServerInfo_base: Schema.Class<ServerInfo, Schema.Struct<{
+    readonly name: Schema.brand<Schema.String, "MCP.ServerName">;
+    readonly status: Schema.toTaggedUnion<"status", readonly [Schema.Struct<{
+        readonly status: Schema.Literal<"connected">;
+    }>, Schema.Struct<{
+        readonly status: Schema.Literal<"pending">;
+    }>, Schema.Struct<{
+        readonly status: Schema.Literal<"disabled">;
+    }>, Schema.Struct<{
+        readonly status: Schema.Literal<"failed">;
+        readonly error: Schema.String;
+    }>, Schema.Struct<{
+        readonly status: Schema.Literal<"needs_auth">;
+    }>]>;
+    readonly integrationID: Schema.optional<Schema.brand<Schema.String, "Integration.ID">>;
+}>, {}>;
+export declare class ServerInfo extends ServerInfo_base {
+}
+declare const ServerInstructions_base: Schema.Class<ServerInstructions, Schema.Struct<{
+    readonly server: Schema.brand<Schema.String, "MCP.ServerName">;
+    readonly instructions: Schema.String;
+}>, {}>;
+export declare class ServerInstructions extends ServerInstructions_base {
+}
+declare const Tool_base: Schema.Class<Tool, Schema.Struct<{
+    readonly server: Schema.brand<Schema.String, "MCP.ServerName">;
+    readonly name: Schema.String;
+    readonly codemode: Schema.optional<Schema.Boolean>;
+    readonly description: Schema.optional<Schema.String>;
+    readonly inputSchema: Schema.optional<Schema.Unknown>;
+    readonly outputSchema: Schema.optional<Schema.Unknown>;
+}>, {}>;
+export declare class Tool extends Tool_base {
+}
+export declare const ToolResultContent: Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"text">;
+    readonly text: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"media">;
+    readonly data: Schema.String;
+    readonly mimeType: Schema.String;
+}>]>;
+export type ToolResultContent = typeof ToolResultContent.Type;
+declare const ToolResult_base: Schema.Class<ToolResult, Schema.Struct<{
+    readonly server: Schema.brand<Schema.String, "MCP.ServerName">;
+    readonly tool: Schema.String;
+    readonly isError: Schema.Boolean;
+    readonly structured: Schema.optional<Schema.Unknown>;
+    readonly content: Schema.$Array<Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"media">;
+        readonly data: Schema.String;
+        readonly mimeType: Schema.String;
+    }>]>>;
+}>, {}>;
+export declare class ToolResult extends ToolResult_base {
+}
+declare const PromptArgument_base: Schema.Class<PromptArgument, Schema.Struct<{
+    readonly name: Schema.String;
+    readonly description: Schema.optional<Schema.String>;
+    readonly required: Schema.optional<Schema.Boolean>;
+}>, {}>;
+export declare class PromptArgument extends PromptArgument_base {
+}
+declare const Prompt_base: Schema.Class<Prompt, Schema.Struct<{
+    readonly server: Schema.brand<Schema.String, "MCP.ServerName">;
+    readonly name: Schema.String;
+    readonly description: Schema.optional<Schema.String>;
+    readonly arguments: Schema.optional<Schema.$Array<typeof PromptArgument>>;
+}>, {}>;
+export declare class Prompt extends Prompt_base {
+}
+declare const PromptMessage_base: Schema.Class<PromptMessage, Schema.Struct<{
+    readonly role: Schema.String;
+    readonly content: Schema.Unknown;
+}>, {}>;
+export declare class PromptMessage extends PromptMessage_base {
+}
+declare const PromptResult_base: Schema.Class<PromptResult, Schema.Struct<{
+    readonly server: Schema.brand<Schema.String, "MCP.ServerName">;
+    readonly name: Schema.String;
+    readonly messages: Schema.$Array<typeof PromptMessage>;
+}>, {}>;
+export declare class PromptResult extends PromptResult_base {
+}
+export declare const Resource: Schema.Struct<{
+    readonly server: Schema.String;
+    readonly name: Schema.String;
+    readonly uri: Schema.String;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly mimeType: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+}>;
+export type Resource = Mcp.Resource;
+export declare const ResourceTemplate: Schema.Struct<{
+    readonly server: Schema.String;
+    readonly name: Schema.String;
+    readonly uriTemplate: Schema.String;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly mimeType: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+}>;
+export type ResourceTemplate = Mcp.ResourceTemplate;
+export declare const ResourceCatalog: Schema.Struct<{
+    readonly resources: Schema.$Array<Schema.Struct<{
+        readonly server: Schema.String;
+        readonly name: Schema.String;
+        readonly uri: Schema.String;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly mimeType: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>;
+    readonly templates: Schema.$Array<Schema.Struct<{
+        readonly server: Schema.String;
+        readonly name: Schema.String;
+        readonly uriTemplate: Schema.String;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly mimeType: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>;
+}>;
+export type ResourceCatalog = Mcp.ResourceCatalog;
+export declare const ResourceContentPart: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"text">;
+    readonly uri: Schema.String;
+    readonly text: Schema.String;
+    readonly mimeType: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"blob">;
+    readonly uri: Schema.String;
+    readonly blob: Schema.String;
+    readonly mimeType: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+}>]>;
+export type ResourceContentPart = Mcp.ResourceContentPart;
+export declare const ResourceContent: Schema.Struct<{
+    readonly server: Schema.String;
+    readonly uri: Schema.String;
+    readonly contents: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly uri: Schema.String;
+        readonly text: Schema.String;
+        readonly mimeType: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"blob">;
+        readonly uri: Schema.String;
+        readonly blob: Schema.String;
+        readonly mimeType: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>]>>;
+}>;
+export type ResourceContent = Mcp.ResourceContent;
+declare const NotFoundError_base: Schema.Class<NotFoundError, Schema.TaggedStruct<"MCP.NotFoundError", {
+    readonly server: Schema.brand<Schema.String, "MCP.ServerName">;
+}>, Cause.YieldableError>;
+export declare class NotFoundError extends NotFoundError_base {
+    get message(): string;
+}
+declare const ToolCallError_base: Schema.Class<ToolCallError, Schema.TaggedStruct<"MCP.ToolCallError", {
+    readonly server: Schema.brand<Schema.String, "MCP.ServerName">;
+    readonly tool: Schema.String;
+    readonly message: Schema.String;
+}>, Cause.YieldableError>;
+export declare class ToolCallError extends ToolCallError_base {
+}
+export interface Interface {
+    readonly servers: () => Effect.Effect<ServerInfo[]>;
+    readonly add: (server: ServerName | string, config: typeof ConfigMCP.Server.Type) => Effect.Effect<void>;
+    readonly connect: (server: ServerName | string) => Effect.Effect<void, NotFoundError>;
+    readonly disconnect: (server: ServerName | string) => Effect.Effect<void, NotFoundError>;
+    readonly remove: (server: ServerName | string) => Effect.Effect<void, NotFoundError>;
+    readonly tools: () => Effect.Effect<Tool[]>;
+    readonly callTool: (input: {
+        readonly server: ServerName | string;
+        readonly name: string;
+        readonly args?: Record<string, unknown>;
+    }) => Effect.Effect<ToolResult, NotFoundError | ToolCallError>;
+    readonly instructions: () => Effect.Effect<ServerInstructions[]>;
+    readonly prompts: () => Effect.Effect<Prompt[]>;
+    readonly prompt: (input: {
+        readonly server: ServerName | string;
+        readonly name: string;
+        readonly args?: Record<string, string>;
+    }) => Effect.Effect<PromptResult | undefined, NotFoundError>;
+    readonly resourceCatalog: () => Effect.Effect<ResourceCatalog>;
+    readonly readResource: (input: {
+        readonly server: ServerName | string;
+        readonly uri: string;
+    }) => Effect.Effect<ResourceContent | undefined, NotFoundError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/MCP", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const Options: Schema.Struct<{
+    readonly clientInfo: Schema.optional<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly version: Schema.String;
+    }>>;
+}>;
+export type Options = typeof Options.Type;
+export declare const layer: (options?: Options) => Layer.Layer<Service, never, Bus.Service | Location.Service | Credential.Service | Form.Service | Integration.Service | Config.Service | Environment.Service>;
+export declare function configured(options?: Options): import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"location">>;
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"location">>;

package/dist/types/mcp/instructions.d.ts

@@ -0,0 +1,13 @@
+export * as McpInstructions from "./instructions.js";
+import { Context, Effect, Layer } from "effect";
+import { Agent } from "../agent.js";
+import { MCP } from "./index.js";
+import { Instructions } from "../instructions/index.js";
+export interface Interface {
+    readonly load: (agent: Agent.Selection) => Effect.Effect<Instructions.List>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/McpInstructions", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, MCP.Service>;
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"location">>;

package/dist/types/mcp/oauth.d.ts

@@ -0,0 +1,86 @@
+export * as MCPOAuth from "./oauth.js";
+import { type OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
+import type { OAuthClientInformationMixed, OAuthTokens } from "@modelcontextprotocol/sdk/shared/auth.js";
+import { Effect } from "effect";
+import { Credential } from "@opencode-ai/schema/credential";
+import { ConfigMCP } from "@opencode-ai/schema/config/mcp";
+import type { Integration } from "../integration.js";
+/** Persists the OAuth artifacts for one MCP server session: DCR client info, PKCE verifier, and tokens. */
+export interface Store {
+    readonly tokens: () => Promise<OAuthTokens | undefined>;
+    readonly saveTokens: (tokens: OAuthTokens) => Promise<void>;
+    readonly clientInformation: () => Promise<OAuthClientInformationMixed | undefined>;
+    readonly saveClientInformation: (info: OAuthClientInformationMixed) => Promise<void>;
+    readonly codeVerifier: () => Promise<string | undefined>;
+    readonly saveCodeVerifier: (verifier: string) => Promise<void>;
+}
+export interface Options {
+    /** Loopback URL the authorization server redirects back to after the user approves. */
+    readonly redirectUrl: string;
+    /** Space-delimited OAuth scopes to request when the server requires specific ones. */
+    readonly scope?: string;
+    /** CSRF state embedded in the authorization request; required by the spec and enforced by some servers.
+     * The caller is responsible for validating the value echoed back to the redirect. */
+    readonly state?: string;
+    /** Statically pre-registered client credentials from config; when set, the SDK skips dynamic registration. */
+    readonly client?: {
+        readonly id: string;
+        readonly secret?: string;
+    };
+    /** Invoked by the SDK to drop credentials it has determined are invalid (e.g. a rejected refresh token). */
+    readonly invalidate?: (scope: "all" | "client" | "tokens" | "verifier" | "discovery") => void | Promise<void>;
+    /** Receives the authorization URL so the caller can open a browser and capture the eventual code. */
+    readonly onRedirect: (url: URL) => void | Promise<void>;
+    readonly store: Store;
+}
+/**
+ * Builds the MCP SDK's OAuthClientProvider. The SDK drives dynamic client registration, PKCE, and
+ * token refresh through these callbacks; we only persist whatever it hands back via `store`.
+ */
+export declare const provider: (options: Options) => OAuthClientProvider;
+/** A Store that keeps OAuth artifacts in memory for the duration of one interactive login attempt. */
+export declare const memoryStore: () => Store;
+/** Reads the dynamically-registered client info we stash in a credential's metadata, for token refresh. */
+export declare const clientFromCredential: (credential: Credential.OAuth) => OAuthClientInformationMixed | undefined;
+/** Folds SDK tokens (plus DCR client info and the server URL) into a storable credential. */
+export declare const toCredential: (input: {
+    readonly methodID: Integration.MethodID;
+    readonly serverUrl: string;
+    readonly tokens: OAuthTokens;
+    readonly client: OAuthClientInformationMixed | undefined;
+}) => {
+    readonly type: "oauth";
+    readonly methodID: string & import("effect/Brand").Brand<"Integration.MethodID">;
+    readonly refresh: string;
+    readonly access: string;
+    readonly expires: number;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+};
+/** Reconstructs SDK tokens from a stored credential so the connect-time provider can present them. */
+export declare const toTokens: (credential: Credential.OAuth) => OAuthTokens;
+/**
+ * Runs the interactive OAuth login for one remote MCP server. Stands up a loopback callback server,
+ * lets the SDK drive DCR + PKCE to produce an authorization URL, and returns an attempt whose callback
+ * exchanges the redirect code for a storable credential. Scoped: the callback server closes with the scope.
+ */
+export declare const authorize: (input: {
+    readonly name: string;
+    readonly config: typeof ConfigMCP.Remote.Type;
+    readonly methodID: Integration.MethodID;
+}) => Effect.Effect<{
+    url: string;
+    instructions: string;
+    mode: "auto";
+    callback: Effect.Effect<{
+        readonly type: "oauth";
+        readonly methodID: string & import("effect/Brand").Brand<"Integration.MethodID">;
+        readonly refresh: string;
+        readonly access: string;
+        readonly expires: number;
+        readonly metadata?: {
+            readonly [x: string]: unknown;
+        } | undefined;
+    }, Error, never>;
+}, Error, import("effect/Scope").Scope>;

package/dist/types/mcp/stdio.d.ts

@@ -0,0 +1,29 @@
+export * as MCPStdio from "./stdio.js";
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import { Effect, Scope } from "effect";
+import { Environment } from "../environment/index.js";
+export interface Options {
+    /** Server name; only used to attribute logs. */
+    readonly server: string;
+    readonly command: string;
+    readonly args: ReadonlyArray<string>;
+    readonly cwd: string;
+    /**
+     * Environment declared by the server config, and nothing else.
+     *
+     * The host environment is merged in by the spawner via `extendEnv`, which keeps the merge on the
+     * side that actually runs the process: the local driver extends with the host's `process.env`
+     * (what the MCP SDK's transport did), while a workspace driver extends with the sandbox's own
+     * environment. Host variables therefore never cross the seam into a remote workspace.
+     */
+    readonly environment: Record<string, string>;
+}
+/**
+ * MCP stdio transport that spawns its server through the location's `Environment` instead of the
+ * SDK's host-bound `StdioClientTransport`, so a workspace-backed location runs its MCP servers
+ * wherever the rest of its execution happens.
+ *
+ * The process is acquired in the calling scope: closing the scope kills it (the spawner kills the
+ * whole process group, so descendants go too) regardless of whether the transport was closed.
+ */
+export declare const make: (options: Options) => Effect.Effect<Transport, never, Scope.Scope | Environment.Service>;

package/dist/types/mime.d.ts

@@ -0,0 +1,2 @@
+export * as Mime from "./mime.js";
+export declare function detect(bytes: Uint8Array): "application/octet-stream" | "image/png" | "image/jpeg" | "image/gif" | "image/webp" | "application/pdf" | "image/bmp" | "image/avif" | "text/plain";

package/dist/types/model-resolver.d.ts

@@ -0,0 +1,103 @@
+export * as ModelResolver from "./model-resolver.js";
+import { LanguageModel } from "@opencode-ai/ai";
+import { Context, Effect, Layer, Schema } from "effect";
+import { AISDK } from "./aisdk.js";
+import { Catalog } from "./catalog.js";
+import { Credential } from "./credential.js";
+import { Integration } from "./integration.js";
+import { Capabilities, Info, Ref, VariantID } from "./model.js";
+import { Npm } from "@opencode-ai/util/npm";
+import { Provider } from "./provider.js";
+declare const VariantUnavailableError_base: Schema.Class<VariantUnavailableError, Schema.TaggedStruct<"SessionRunnerModel.VariantUnavailableError", {
+    readonly providerID: Schema.brand<Schema.String, "Provider.ID"> & {
+        opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+        anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+        openai: string & import("effect/Brand").Brand<"Provider.ID">;
+        google: string & import("effect/Brand").Brand<"Provider.ID">;
+        googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+        githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+        amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+        azure: string & import("effect/Brand").Brand<"Provider.ID">;
+        openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+        mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+        gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+    };
+    readonly modelID: Schema.brand<Schema.String, "Model.ID">;
+    readonly variant: Schema.brand<Schema.String, "Model.VariantID">;
+}>, import("effect/Cause").YieldableError>;
+export declare class VariantUnavailableError extends VariantUnavailableError_base {
+    get message(): string;
+}
+declare const UnsupportedPackageError_base: Schema.Class<UnsupportedPackageError, Schema.TaggedStruct<"SessionRunnerModel.UnsupportedPackageError", {
+    readonly providerID: Schema.brand<Schema.String, "Provider.ID"> & {
+        opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+        anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+        openai: string & import("effect/Brand").Brand<"Provider.ID">;
+        google: string & import("effect/Brand").Brand<"Provider.ID">;
+        googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+        githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+        amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+        azure: string & import("effect/Brand").Brand<"Provider.ID">;
+        openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+        mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+        gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+    };
+    readonly modelID: Schema.brand<Schema.String, "Model.ID">;
+    readonly package: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class UnsupportedPackageError extends UnsupportedPackageError_base {
+    get message(): string;
+}
+declare const UnresolvedProviderVariablesError_base: Schema.Class<UnresolvedProviderVariablesError, Schema.TaggedStruct<"SessionRunnerModel.UnresolvedProviderVariablesError", {
+    readonly providerID: Schema.brand<Schema.String, "Provider.ID"> & {
+        opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+        anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+        openai: string & import("effect/Brand").Brand<"Provider.ID">;
+        google: string & import("effect/Brand").Brand<"Provider.ID">;
+        googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+        githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+        amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+        azure: string & import("effect/Brand").Brand<"Provider.ID">;
+        openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+        mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+        gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+    };
+    readonly modelID: Schema.brand<Schema.String, "Model.ID">;
+    readonly variables: Schema.$Array<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+export declare class UnresolvedProviderVariablesError extends UnresolvedProviderVariablesError_base {
+    get message(): string;
+}
+export type Error = VariantUnavailableError | UnsupportedPackageError | UnresolvedProviderVariablesError | Integration.AuthorizationError;
+export interface Resolved {
+    /** Route-level model for provider requests; its id is the provider API model id, which may differ from the catalog id. */
+    readonly model: LanguageModel;
+    /** Selected catalog identity. Durable records and displays must use this, never the API model id. */
+    readonly ref: Ref;
+    /** Catalog capabilities used to shape requests before provider lowering. */
+    readonly capabilities: Capabilities;
+    /** Catalog pricing in dollars per million tokens. */
+    readonly cost: Info["cost"];
+}
+export interface Interface {
+    readonly resolve: (requested?: Ref) => Effect.Effect<Resolved | undefined, Error>;
+    readonly resolveModel: (model: Info, variant?: VariantID) => Effect.Effect<Resolved, Error>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/ModelResolver", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const withVariant: (model: Info, variantID: VariantID | undefined) => Effect.Effect<Info, VariantUnavailableError>;
+export interface Dependencies {
+    readonly loadPackage?: (specifier: string) => Effect.Effect<Provider.ProviderPackage, Provider.LoadError>;
+    readonly loadAISDK?: (model: Info) => Effect.Effect<LanguageModel, AISDK.InitError>;
+}
+export declare const fromCatalogModel: (model: Info, credential?: Credential.Value, dependencies?: Dependencies) => Effect.Effect<LanguageModel, UnsupportedPackageError | UnresolvedProviderVariablesError>;
+export declare const resolveModel: (model: Info, variant: VariantID | undefined, credential?: Credential.Value, dependencies?: Dependencies) => Effect.Effect<LanguageModel<{
+    readonly [x: string]: {
+        readonly [x: string]: unknown;
+    };
+}>, VariantUnavailableError | UnsupportedPackageError | UnresolvedProviderVariablesError, never>;
+export declare const supported: (model: Info) => boolean;
+/** Resolves catalog selections into runtime models for the current Location. */
+export declare const layer: Layer.Layer<Service, never, Npm.Service | AISDK.Service | Integration.Service | Catalog.Service>;
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"location">>;