@opencode/core 2.0.3 → 2.0.5

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

@@ -1,68 +1,48 @@
 export * as McpOAuth from "./oauth.js";
-import { type OAuthClientProvider, type OAuthServerInfo } from "@modelcontextprotocol/sdk/client/auth.js";
-import type { OAuthClientInformationMixed, OAuthTokens } from "@modelcontextprotocol/sdk/shared/auth.js";
-import type { FetchLike } from "@modelcontextprotocol/sdk/shared/transport.js";
+import { type FetchLike, type OAuthClientProvider, type OAuthDiscoveryState, type StoredOAuthClientInformation, type StoredOAuthTokens } from "@modelcontextprotocol/client";
 import { Effect } from "effect";
-import { Credential } from "@opencode/schema/credential";
 import { ConfigMCP } from "@opencode/schema/config/mcp";
+import { Credential } from "../credential.js";
 import type { Integration } from "../integration.js";
-/**
- * opencode's OAuth Client ID Metadata Document. Authorization servers that support CIMD accept this URL as the
- * client_id and fetch it to learn our name and redirect URIs, so no per-server dynamic registration is needed.
- */
+/** Client ID Metadata Document: servers that support CIMD accept this URL as the client_id without registration. */
 export declare const CLIENT_METADATA_URL = "https://opencode.ai/oauth/opencode/client.json";
-/** Observe OAuth failures before the SDK handles them by invalidating credentials or redirecting. */
 export declare const loggedFetch: (fields: {
     readonly server: string;
     readonly directory?: string;
 }) => Effect.Effect<FetchLike, never, never>;
-/** Persists the OAuth artifacts for one MCP server session: DCR client info, PKCE verifier, and tokens. */
+export declare const configuredDiscovery: (input: {
+    readonly config: typeof ConfigMCP.Remote.Type;
+    readonly fetchFn: FetchLike;
+}) => Promise<OAuthDiscoveryState | undefined>;
 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 tokens: () => Promise<StoredOAuthTokens | undefined>;
+    readonly saveTokens: (tokens: StoredOAuthTokens) => Promise<void>;
+    readonly clientInformation: () => Promise<StoredOAuthClientInformation | undefined>;
+    readonly saveClientInformation: (info: StoredOAuthClientInformation) => 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;
+    readonly config: typeof ConfigMCP.Remote.Type;
+    readonly store: Store;
+    /** Absent on connect: the provider then refuses to register a client or redirect, ending in needs_auth. */
+    readonly redirect?: {
+        readonly url: string;
+        readonly state: string;
+        readonly open: (url: URL) => void | Promise<void>;
     };
-    /** Use opencode's Client ID Metadata Document as the client_id instead of registering dynamically. */
     readonly clientMetadataUrl?: string;
-    /** Pre-fetched authorization server discovery so the SDK does not repeat it. */
-    readonly discovery?: OAuthServerInfo;
-    /** 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;
+    readonly discovery?: OAuthDiscoveryState;
+    readonly invalidate?: OAuthClientProvider["invalidateCredentials"];
 }
-/**
- * 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 clientFromCredential: (credential: Credential.OAuth) => StoredOAuthClientInformation | undefined;
 export declare const toCredential: (input: {
     readonly methodID: Integration.MethodID;
     readonly serverUrl: string;
-    readonly tokens: OAuthTokens;
-    readonly client: OAuthClientInformationMixed | undefined;
+    readonly tokens: StoredOAuthTokens;
+    readonly client: StoredOAuthClientInformation | undefined;
 }) => {
     readonly type: "oauth";
     readonly methodID: string & import("effect/Brand").Brand<"Integration.MethodID">;
@@ -73,16 +53,15 @@ export declare const toCredential: (input: {
         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 toTokens: (credential: Credential.OAuth) => StoredOAuthTokens;
+export declare const connectProvider: (input: {
+    readonly config: typeof ConfigMCP.Remote.Type;
+    readonly integrationID: Integration.ID;
+}) => Effect.Effect<OAuthClientProvider, never, Credential.Service>;
 export declare const authorize: (input: {
     readonly name: string;
     readonly config: typeof ConfigMCP.Remote.Type;
+    readonly integrationID: Integration.ID;
     readonly methodID: Integration.MethodID;
 }) => Effect.Effect<{
     url: string;
@@ -98,4 +77,4 @@ export declare const authorize: (input: {
             readonly [x: string]: unknown;
         } | undefined;
     }, Error, never>;
-}, Error, import("effect/Scope").Scope>;
+}, Error, import("effect/Scope").Scope | Credential.Service>;

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

@@ -1,5 +1,5 @@
 export * as McpStdio from "./stdio.js";
-import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import { type Transport } from "@modelcontextprotocol/client";
 import { Effect, Scope } from "effect";
 import { Environment } from "../environment/index.js";
 export interface Options {

package/dist/types/mime.d.ts

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

package/dist/types/modal/models.d.ts

@@ -1,3 +1,33 @@
 export * as ModalModels from "./models.js";
+import { Schema } from "effect";
 import { Model } from "../model.js";
+declare const RemoteModel: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly base_model_id: Schema.optional<Schema.String>;
+    readonly hugging_face_id: Schema.optional<Schema.String>;
+    readonly name: Schema.optional<Schema.String>;
+    readonly input_modalities: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly output_modalities: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly context_length: Schema.optional<Schema.Number>;
+    readonly max_output_length: Schema.optional<Schema.Number>;
+    readonly pricing: Schema.optional<Schema.Struct<{
+        readonly prompt: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Number]>>;
+        readonly completion: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Number]>>;
+        readonly input_cache_read: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Number]>>;
+    }>>;
+    readonly supported_sampling_parameters: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly supported_features: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly reasoning_options: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly type: Schema.Literal<"effort">;
+        readonly values: Schema.$Array<Schema.NullOr<Schema.String>>;
+    }>>>;
+    readonly interleaved: Schema.optional<Schema.Union<readonly [Schema.Boolean, Schema.Struct<{
+        readonly field: Schema.Literals<readonly ["reasoning", "reasoning_content", "reasoning_details"]>;
+    }>]>>;
+}>;
+type RemoteModel = typeof RemoteModel.Type;
 export declare function get(baseURL: string, apiKey: string, existing: readonly Model.Info[]): Promise<Map<string & import("effect/Brand").Brand<"Model.ID">, import("@opencode/schema/model").Info>>;
+export type Snapshot = readonly RemoteModel[];
+export declare function load(baseURL: string, apiKey: string): Promise<Snapshot>;
+/** Combine remote facts with source templates, never a previously transformed model result. */
+export declare function derive(baseURL: string, remote: Snapshot, existing: readonly Model.Info[]): Map<string & import("effect/Brand").Brand<"Model.ID">, import("@opencode/schema/model").Info>;

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

@@ -2,10 +2,9 @@ export * as ModelResolver from "./model-resolver.js";
 import { LanguageModel } from "@opencode/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 { Capabilities, Info, Model, Ref, VariantID } from "./model.js";
 import { Npm } from "@opencode/util/npm";
 import { Provider } from "./provider.js";
 declare const VariantUnavailableError_base: Schema.Class<VariantUnavailableError, Schema.TaggedStruct<"SessionRunnerModel.VariantUnavailableError", {
@@ -149,8 +148,8 @@ export interface Resolved {
     readonly limit: Info["limit"];
     /** Model policy overrides the provider policy; omitted means local compaction. */
     readonly compaction?: Info["compaction"];
-    /** Whether the session WebSocket may carry this model's requests when the route supports it. */
-    readonly websocket: boolean;
+    /** Model transport overrides the provider transport; omitted means HTTP. */
+    readonly transport?: Info["transport"];
 }
 export interface Interface {
     readonly resolve: (requested?: Ref) => Effect.Effect<Resolved | undefined, Error>;
@@ -170,5 +169,5 @@ export declare const resolveModel: (model: Info, variant: VariantID | undefined,
 }, import("@opencode/ai/route").CompactionOperations | undefined>, VariantUnavailableError | UnsupportedPackageError | ModelConfigurationError | ModelInitializationError | UnresolvedProviderVariablesError | UnsupportedCompactionError, never>;
 export declare const hasPackage: (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 layer: Layer.Layer<Service, never, Npm.Service | Integration.Service | Provider.Service | Model.Service | AISDK.Service>;
 export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;

package/dist/types/model.d.ts

@@ -1,6 +1,8 @@
 import { Model } from "@opencode/schema/model";
 import { Provider } from "./provider.js";
 import type { DeepMutable } from "./schema.js";
+import { Context, Effect } from "effect";
+import { State } from "./state.js";
 export declare const ID: import("effect/Schema").brand<import("effect/Schema").String, "Model.ID">;
 export type ID = typeof ID.Type;
 export declare const VariantID: import("effect/Schema").brand<import("effect/Schema").String, "Model.VariantID">;
@@ -15,13 +17,13 @@ export declare const Compatibility: import("effect/Schema").Struct<{
     readonly maxTokensField: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, import("effect/Schema").optionalKey<import("effect/Schema").Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
     readonly requireFinishReason: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Boolean>>, import("effect/Schema").optionalKey<import("effect/Schema").Boolean>, never, never>;
     readonly requireAssistantAfterTool: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Boolean>>, import("effect/Schema").optionalKey<import("effect/Schema").Boolean>, never, never>;
+    readonly supportsPromptCacheKey: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Boolean>>, import("effect/Schema").optionalKey<import("effect/Schema").Boolean>, never, never>;
 }>;
 export type Compatibility = Model.Compatibility;
 export declare const Capabilities: import("effect/Schema").Struct<{
     readonly tools: import("effect/Schema").Boolean;
     readonly input: import("effect/Schema").$Array<import("effect/Schema").String>;
     readonly output: import("effect/Schema").$Array<import("effect/Schema").String>;
-    readonly responsesWebsockets: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Boolean>>, import("effect/Schema").optionalKey<import("effect/Schema").Boolean>, never, never>;
 }> & {
     default: () => {
         tools: true;
@@ -82,7 +84,6 @@ export declare const Info: import("effect/Schema").Struct<{
         readonly tools: import("effect/Schema").Boolean;
         readonly input: import("effect/Schema").$Array<import("effect/Schema").String>;
         readonly output: import("effect/Schema").$Array<import("effect/Schema").String>;
-        readonly responsesWebsockets: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Boolean>>, import("effect/Schema").optionalKey<import("effect/Schema").Boolean>, never, never>;
     }> & {
         default: () => {
             tools: true;
@@ -180,12 +181,14 @@ export declare const Info: import("effect/Schema").Struct<{
         readonly maxTokensField: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, import("effect/Schema").optionalKey<import("effect/Schema").Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
         readonly requireFinishReason: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Boolean>>, import("effect/Schema").optionalKey<import("effect/Schema").Boolean>, never, never>;
         readonly requireAssistantAfterTool: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Boolean>>, import("effect/Schema").optionalKey<import("effect/Schema").Boolean>, never, never>;
+        readonly supportsPromptCacheKey: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Boolean>>, import("effect/Schema").optionalKey<import("effect/Schema").Boolean>, never, never>;
     }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
         readonly reasoningField: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Codec<Model.ReasoningField, Model.ReasoningField, never, never>>>, import("effect/Schema").optionalKey<import("effect/Schema").Codec<Model.ReasoningField, Model.ReasoningField, never, never>>, never, never>;
         readonly requireReasoning: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Boolean>>, import("effect/Schema").optionalKey<import("effect/Schema").Boolean>, never, never>;
         readonly maxTokensField: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, import("effect/Schema").optionalKey<import("effect/Schema").Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
         readonly requireFinishReason: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Boolean>>, import("effect/Schema").optionalKey<import("effect/Schema").Boolean>, never, never>;
         readonly requireAssistantAfterTool: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Boolean>>, import("effect/Schema").optionalKey<import("effect/Schema").Boolean>, never, never>;
+        readonly supportsPromptCacheKey: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Boolean>>, import("effect/Schema").optionalKey<import("effect/Schema").Boolean>, never, never>;
     }>>, never, never>;
     readonly package: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").String>>, import("effect/Schema").optionalKey<import("effect/Schema").String>, never, never>;
     readonly compaction: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
@@ -199,7 +202,7 @@ export declare const Info: import("effect/Schema").Struct<{
         readonly mode: import("effect/Schema").Literal<"provider">;
         readonly threshold: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Int>>, import("effect/Schema").optionalKey<import("effect/Schema").Int>, never, never>;
     }>]>>, never, never>;
-    readonly websocket: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Boolean>>, import("effect/Schema").optionalKey<import("effect/Schema").Boolean>, never, never>;
+    readonly transport: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Literals<readonly ["http", "websocket"]>>>, import("effect/Schema").optionalKey<import("effect/Schema").Literals<readonly ["http", "websocket"]>>, never, never>;
 }> & {
     default: (providerID: import("@opencode/schema/provider").ID, id: Model.ID) => {
         id: string & import("effect/Brand").Brand<"Model.ID">;
@@ -226,6 +229,37 @@ export declare const Info: import("effect/Schema").Struct<{
 };
 export type Info = Model.Info;
 export type MutableInfo = DeepMutable<Info>;
+export { Event } from "@opencode/schema/model";
+export interface Editor {
+    /** Includes disabled candidates so later transforms can re-enable them. */
+    readonly list: (providerID?: Provider.ID) => readonly MutableInfo[];
+    readonly get: (providerID: Provider.ID, modelID: ID) => MutableInfo | undefined;
+    readonly update: (providerID: Provider.ID, modelID: ID, update: (model: MutableInfo) => void) => void;
+    readonly remove: (providerID: Provider.ID, modelID: ID) => void;
+    readonly default: {
+        readonly get: () => {
+            providerID: Provider.ID;
+            modelID: ID;
+        } | undefined;
+        readonly set: (providerID: Provider.ID, modelID: ID) => void;
+    };
+    /** Coherent, read-only provider inputs, including definitions from inactive providers. */
+    readonly provider: {
+        readonly list: () => readonly Provider.Definition[];
+        readonly get: (providerID: Provider.ID) => Provider.Definition | undefined;
+    };
+}
+export interface Interface extends State.Transformable<Editor> {
+    readonly get: (providerID: Provider.ID, modelID: ID) => Effect.Effect<Info | undefined>;
+    readonly all: () => Effect.Effect<readonly Info[]>;
+    readonly available: () => Effect.Effect<readonly Info[]>;
+    readonly default: () => Effect.Effect<Info | undefined>;
+    readonly small: (providerID: Provider.ID) => Effect.Effect<Info | undefined>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/Model", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;
 export declare function compatibility(input: unknown): Compatibility | undefined;
 export declare function parse(input: string): {
     providerID: Provider.ID;

package/dist/types/permission/saved.d.ts

@@ -13,6 +13,10 @@ export declare const Info: Schema.Struct<{
     };
     readonly action: Schema.String;
     readonly resource: Schema.String;
+    readonly time: Schema.Struct<{
+        readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+        readonly updated: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    }>;
 }>;
 export type Info = typeof Info.Type;
 export declare const ListInput: Schema.Struct<{

package/dist/types/plugin/host.d.ts

@@ -3,16 +3,17 @@ import { Plugin } from "@opencode/plugin/effect";
 import { Effect } from "effect";
 import { Agent } from "../agent.js";
 import { AISDK } from "../aisdk.js";
-import { Catalog } from "../catalog.js";
 import { Command } from "../command.js";
 import { Bus } from "../bus.js";
 import { Integration } from "../integration.js";
 import { KV } from "../kv.js";
 import { Location } from "../location.js";
 import { LocationServiceMap } from "../location-service-map.js";
+import { Model } from "../model.js";
 import { Mcp } from "../mcp/index.js";
 import { Session } from "../session.js";
 import { PersistentPty } from "../persistent-pty.js";
+import { Provider } from "../provider.js";
 import { Reference } from "../reference.js";
 import { Rpc } from "../rpc.js";
 import { Skill } from "../skill.js";
@@ -20,11 +21,12 @@ import { Tool } from "../tool.js";
 import { Vcs } from "../vcs.js";
 import { WebSearch } from "../websearch.js";
 import { Worktree } from "../worktree.js";
+import { WorktreeStrategies } from "../worktree/strategies.js";
 import { Generate } from "../generate.js";
 import { Permission } from "../permission.js";
 import { PluginHooks } from "./hooks.js";
 import type { Interface } from "../plugin.js";
 import { LayerNode } from "@opencode/util/effect/layer-node";
-export declare const make: (plugin: Pick<Interface, "list">, pluginID?: string | undefined) => Effect.Effect<Plugin.Context, never, Bus.Service | Location.Service | Agent.Service | AISDK.Service | Integration.Service | Catalog.Service | Command.Service | KV.Service | PluginHooks.Service | Permission.Service | Tool.Service | Generate.Service | PersistentPty.Service | LocationServiceMap.Service | Reference.Service | Rpc.Service | WebSearch.Service | Mcp.Service | Session.Service | Skill.Service | Worktree.Service | Vcs.Service>;
-export declare const requirements: LayerNode.Graph<Bus.Service | Location.Service | Agent.Service | AISDK.Service | Integration.Service | Catalog.Service | Command.Service | KV.Service | PluginHooks.Service | Permission.Service | Tool.Service | Generate.Service | PersistentPty.Service | LocationServiceMap.Service | Reference.Service | Rpc.Service | WebSearch.Service | Mcp.Service | Session.Service | Skill.Service | Worktree.Service | Vcs.Service, PersistentPty.UnavailableError, LayerNode.Tag<"global"> | LayerNode.Tag<"location">>;
+export declare const make: (plugin: Pick<Interface, "list">, pluginID?: string | undefined) => Effect.Effect<Plugin.Context, never, Bus.Service | Location.Service | Agent.Service | Integration.Service | Provider.Service | Model.Service | AISDK.Service | Command.Service | KV.Service | PluginHooks.Service | Permission.Service | Tool.Service | Generate.Service | PersistentPty.Service | LocationServiceMap.Service | Reference.Service | Rpc.Service | WebSearch.Service | WorktreeStrategies.Service | Mcp.Service | Session.Service | Skill.Service | Worktree.Service | Vcs.Service>;
+export declare const requirements: LayerNode.Graph<Bus.Service | Location.Service | Agent.Service | Integration.Service | Provider.Service | Model.Service | AISDK.Service | Command.Service | KV.Service | PluginHooks.Service | Permission.Service | Tool.Service | Generate.Service | PersistentPty.Service | LocationServiceMap.Service | Reference.Service | Rpc.Service | WebSearch.Service | WorktreeStrategies.Service | Mcp.Service | Session.Service | Skill.Service | Worktree.Service | Vcs.Service, PersistentPty.UnavailableError, LayerNode.Tag<"global"> | LayerNode.Tag<"location">>;
 export declare function storage(kv: KV.Interface, pluginID: string): Plugin.Context["storage"];

package/dist/types/plugin/identity.d.ts

@@ -0,0 +1,7 @@
+export * as IdentityPlugin from "./identity.js";
+import { Model } from "@opencode/schema/model";
+export declare function identity(model: {
+    readonly name: string;
+    readonly ref: Model.Ref;
+}): string;
+export declare const Plugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope>;

package/dist/types/plugin/internal.d.ts

@@ -5,11 +5,13 @@ import { AppProcess } from "@opencode/util/process";
 import { Context, Effect, Scope } from "effect";
 import { HttpClient } from "effect/unstable/http";
 import { Agent } from "../agent.js";
-import { Catalog } from "../catalog.js";
+import { Model } from "../model.js";
+import { Provider } from "../provider.js";
 import { Command } from "../command.js";
 import { Config } from "../config.js";
 import { Credential } from "../credential.js";
 import { Worktree } from "../worktree.js";
+import { WorktreeStrategies } from "../worktree/strategies.js";
 import { Bus } from "../bus.js";
 import { Environment } from "../environment/index.js";
 import { FileAccess } from "../file-access.js";
@@ -46,9 +48,9 @@ import { ReadToolFileSystem } from "../tool/read-filesystem.js";
 import { Tool } from "../tool.js";
 import { ToolOutput } from "../tool-output.js";
 import { WellKnown } from "../wellknown.js";
-declare const services: readonly [typeof Agent.Service, typeof AppProcess.Service, typeof Catalog.Service, typeof Command.Service, typeof Config.Service, typeof Credential.Service, typeof Bus.Service, typeof Environment.Service, typeof FileAccess.Service, typeof FileMutation.Service, typeof Formatter.Service, typeof LocationWatcherPolicy.Service, typeof FileSystem.Service, typeof FSUtil.Service, typeof Global.Service, Context.Service<HttpClient.HttpClient, HttpClient.HttpClient>, typeof Image.Service, typeof InstructionDiscovery.Service, typeof Integration.Service, typeof Job.Service, typeof KV.Service, typeof Location.Service, typeof ModelsDev.Service, typeof Mcp.Service, typeof Npm.Service, typeof Permission.Service, typeof Form.Service, typeof ReadToolFileSystem.Service, typeof Reference.Service, typeof WebSearch.Service, typeof Ripgrep.Service, typeof Session.Service, typeof SessionCompaction.Service, typeof SessionInstructions.Service, typeof Shell.Service, typeof ShellSelect.Service, typeof Snapshot.Service, typeof Skill.Service, typeof SkillDiscovery.Service, typeof Tool.Service, typeof ToolOutput.Service, typeof Watcher.Service, typeof WellKnown.Service, typeof Worktree.Service];
+declare const services: readonly [typeof Agent.Service, typeof AppProcess.Service, typeof Provider.Service, typeof Model.Service, typeof Command.Service, typeof Config.Service, typeof Credential.Service, typeof Bus.Service, typeof Environment.Service, typeof FileAccess.Service, typeof FileMutation.Service, typeof Formatter.Service, typeof LocationWatcherPolicy.Service, typeof FileSystem.Service, typeof FSUtil.Service, typeof Global.Service, Context.Service<HttpClient.HttpClient, HttpClient.HttpClient>, typeof Image.Service, typeof InstructionDiscovery.Service, typeof Integration.Service, typeof Job.Service, typeof KV.Service, typeof Location.Service, typeof ModelsDev.Service, typeof Mcp.Service, typeof Npm.Service, typeof Permission.Service, typeof Form.Service, typeof ReadToolFileSystem.Service, typeof Reference.Service, typeof WebSearch.Service, typeof Ripgrep.Service, typeof Session.Service, typeof SessionCompaction.Service, typeof SessionInstructions.Service, typeof Shell.Service, typeof ShellSelect.Service, typeof Snapshot.Service, typeof Skill.Service, typeof SkillDiscovery.Service, typeof Tool.Service, typeof ToolOutput.Service, typeof Watcher.Service, typeof WellKnown.Service, typeof Worktree.Service, typeof WorktreeStrategies.Service];
 export type Requirements = Context.Service.Identifier<(typeof services)[number]>;
-export declare const requirements: LayerNode.Graph<Global.Service | HttpClient.HttpClient | FSUtil.Service | AppProcess.Service | Bus.Service | Location.Service | Agent.Service | Npm.Service | Credential.Service | Form.Service | Integration.Service | Catalog.Service | Command.Service | Watcher.Service | KV.Service | WellKnown.Service | Config.Service | Permission.Service | Environment.Service | Ripgrep.Service | FileSystem.Service | Image.Service | Tool.Service | FileAccess.Service | FileMutation.Service | Formatter.Service | ShellSelect.Service | Reference.Service | WebSearch.Service | Mcp.Service | ModelsDev.Service | ReadToolFileSystem.Service | SessionInstructions.Service | Session.Service | Job.Service | Shell.Service | Skill.Service | LocationWatcherPolicy.Service | InstructionDiscovery.Service | SessionCompaction.Service | Snapshot.Service | SkillDiscovery.Service | ToolOutput.Service | Worktree.Service, never, LayerNode.Tag<"global"> | LayerNode.Tag<"location">>;
+export declare const requirements: LayerNode.Graph<Global.Service | HttpClient.HttpClient | FSUtil.Service | AppProcess.Service | Bus.Service | Location.Service | Agent.Service | Npm.Service | Credential.Service | Form.Service | Integration.Service | Provider.Service | Model.Service | Command.Service | Watcher.Service | KV.Service | WellKnown.Service | Config.Service | Permission.Service | Environment.Service | Ripgrep.Service | FileSystem.Service | Image.Service | Tool.Service | FileAccess.Service | FileMutation.Service | Formatter.Service | ShellSelect.Service | Reference.Service | WebSearch.Service | WorktreeStrategies.Service | Mcp.Service | ModelsDev.Service | ReadToolFileSystem.Service | SessionInstructions.Service | Session.Service | Job.Service | Shell.Service | Skill.Service | LocationWatcherPolicy.Service | InstructionDiscovery.Service | SessionCompaction.Service | Snapshot.Service | SkillDiscovery.Service | ToolOutput.Service | Worktree.Service, never, LayerNode.Tag<"global"> | LayerNode.Tag<"location">>;
 export type InternalPlugin = Plugin<Requirements | Scope.Scope>;
 export declare const list: () => Effect.Effect<{
     pre: Plugin<Scope.Scope>[];

package/dist/types/plugin/provider/azure.d.ts

@@ -1,3 +1,4 @@
 import { AppProcess } from "@opencode/util/process";
 import { Bus } from "../../bus.js";
-export declare const AzurePlugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | AppProcess.Service | Bus.Service | import("../../catalog.js").Service>;
+import { Provider } from "../../provider.js";
+export declare const AzurePlugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | AppProcess.Service | Bus.Service | Provider.Service>;

package/dist/types/plugin/provider/cloudflare-ai-gateway.d.ts

@@ -1 +1,2 @@
-export declare const CloudflareAIGatewayPlugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | import("../../catalog.js").Service>;
+import { Provider } from "../../provider.js";
+export declare const CloudflareAIGatewayPlugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | Provider.Service>;

package/dist/types/plugin/provider/cloudflare-workers-ai.d.ts

@@ -1 +1,2 @@
-export declare const CloudflareWorkersAIPlugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | import("../../catalog.js").Service>;
+import { Provider } from "../../provider.js";
+export declare const CloudflareWorkersAIPlugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | Provider.Service>;

package/dist/types/plugin/provider/configured.d.ts

@@ -1,10 +1,9 @@
 import { Effect } from "effect";
 import type { Entry } from "@opencode/schema/config";
-import { Catalog } from "../../catalog.js";
 import { Provider } from "../../provider.js";
 export declare const configuredSettings: (id: string & import("effect/Brand").Brand<"Provider.ID">) => Effect.Effect<{
     readonly [x: string]: any;
-} | undefined, never, Catalog.Service>;
+} | undefined, never, Provider.Service>;
 export declare function foldSettings(entries: readonly Entry[], id: string, initial: Provider.Settings | undefined): {
     readonly [x: string]: any;
 } | undefined;

package/dist/types/plugin/provider/github-copilot.d.ts

@@ -1,8 +1,8 @@
 import type { SessionRequestKind } from "@opencode/plugin/effect/session";
-import { Catalog } from "../../catalog.js";
 import { Bus } from "../../bus.js";
 import { App } from "../../app.js";
-export declare const GithubCopilotPlugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | Bus.Service | Catalog.Service>;
+import { Provider } from "../../provider.js";
+export declare const GithubCopilotPlugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | Bus.Service | Provider.Service>;
 export declare function copilotEntitlementError(user: {
     chat_enabled?: boolean;
     can_signup_for_limited?: boolean;

package/dist/types/plugin/provider/modal.d.ts

@@ -1,3 +1,3 @@
 import { Bus } from "../../bus.js";
-import { Catalog } from "../../catalog.js";
-export declare const ModalPlugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | Bus.Service | Catalog.Service>;
+import { Provider } from "../../provider.js";
+export declare const ModalPlugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | Bus.Service | Provider.Service>;

package/dist/types/plugin/provider/prompt-cache-key.d.ts

@@ -0,0 +1 @@
+export declare const PromptCacheKeyPlugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope>;

package/dist/types/plugin/provider/snowflake-cortex.d.ts

@@ -2,4 +2,5 @@ import { HttpClient } from "effect/unstable/http";
 import { Bus } from "../../bus.js";
 import { Credential } from "../../credential.js";
 import { Integration } from "../../integration.js";
-export declare const SnowflakeCortexPlugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | HttpClient.HttpClient | Bus.Service | Credential.Service | Integration.Service | import("../../catalog.js").Service>;
+import { Provider } from "../../provider.js";
+export declare const SnowflakeCortexPlugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | HttpClient.HttpClient | Bus.Service | Credential.Service | Integration.Service | Provider.Service>;

package/dist/types/project/schema.d.ts

@@ -36,7 +36,6 @@ export declare const Info: Schema.Struct<{
     readonly time: Schema.Struct<{
         readonly created: Schema.Int;
         readonly updated: Schema.Int;
-        readonly initialized: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
     }>;
     readonly sandboxes: Schema.$Array<Schema.String>;
 }>;
@@ -115,7 +114,6 @@ export declare const Event: {
             readonly time: Schema.Struct<{
                 readonly created: Schema.Int;
                 readonly updated: Schema.Int;
-                readonly initialized: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
             }>;
             readonly sandboxes: Schema.$Array<Schema.String>;
         }>;
@@ -147,7 +145,6 @@ export declare const Event: {
             readonly time: Schema.Struct<{
                 readonly created: Schema.Int;
                 readonly updated: Schema.Int;
-                readonly initialized: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
             }>;
             readonly sandboxes: Schema.$Array<Schema.String>;
         }>;
@@ -202,7 +199,6 @@ export declare const Event: {
             readonly time: Schema.Struct<{
                 readonly created: Schema.Int;
                 readonly updated: Schema.Int;
-                readonly initialized: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
             }>;
             readonly sandboxes: Schema.$Array<Schema.String>;
         }>;
@@ -234,7 +230,6 @@ export declare const Event: {
             readonly time: Schema.Struct<{
                 readonly created: Schema.Int;
                 readonly updated: Schema.Int;
-                readonly initialized: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
             }>;
             readonly sandboxes: Schema.$Array<Schema.String>;
         }>;

package/dist/types/project.d.ts

@@ -44,7 +44,6 @@ export declare const Info: Schema.Struct<{
     readonly time: Schema.Struct<{
         readonly created: Schema.Int;
         readonly updated: Schema.Int;
-        readonly initialized: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
     }>;
     readonly sandboxes: Schema.$Array<Schema.String>;
 }>;

package/dist/types/provider.d.ts

@@ -1,9 +1,12 @@
 export * as Provider from "./provider.js";
-import { Effect, Schema } from "effect";
+import { Context, Effect, Schema } from "effect";
 import { Provider } from "@opencode/schema/provider";
+import { Model } from "@opencode/schema/model";
 import type { ProviderPackageDefinition } from "@opencode/ai";
 import { Npm } from "@opencode/util/npm";
 import type { DeepMutable } from "./schema.js";
+import { State } from "./state.js";
+import { IntegrationConnection } from "./integration/connection.js";
 export declare const ID: Schema.brand<Schema.String, "Provider.ID"> & {
     opencode: string & import("effect/Brand").Brand<"Provider.ID">;
     anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
@@ -105,9 +108,48 @@ export declare const Info: Schema.Struct<{
         readonly mode: Schema.Literal<"provider">;
         readonly threshold: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
     }>]>>, never, never>;
-    readonly websocket: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly transport: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["http", "websocket"]>>>, Schema.optionalKey<Schema.Literals<readonly ["http", "websocket"]>>, never, never>;
 }> & {
     empty: (id: Provider.ID) => Provider.Info;
 };
 export type Info = Provider.Info;
 export type MutableInfo = DeepMutable<Info>;
+export { Event } from "@opencode/schema/provider";
+/** Provider metadata owns its drafts; model definitions remain immutable inputs. */
+export type Definition = {
+    readonly provider: Info;
+    readonly models: ReadonlyMap<Model.ID, Model.Info>;
+    readonly sourceConnection?: IntegrationConnection.Info;
+};
+export interface Editor {
+    readonly list: () => readonly Definition[];
+    readonly get: (providerID: ID) => Definition | undefined;
+    readonly add: (definition: {
+        readonly info: Info;
+        readonly models: readonly Model.Info[];
+        readonly sourceConnection?: IntegrationConnection.Info;
+    }) => void;
+    readonly update: (providerID: ID, update: (provider: MutableInfo) => void) => void;
+    readonly remove: (providerID: ID) => void;
+    readonly models: {
+        readonly set: (providerID: ID, models: readonly Model.Info[]) => void;
+        readonly update: (providerID: ID, modelID: Model.ID, update: (model: DeepMutable<Model.Info>) => void) => void;
+        readonly remove: (providerID: ID, modelID: Model.ID) => void;
+    };
+}
+export interface Snapshot {
+    readonly records: ReadonlyMap<ID, Definition>;
+    readonly available: readonly Definition[];
+    readonly providers: readonly Info[];
+}
+export interface Interface extends State.Transformable<Editor> {
+    readonly get: (providerID: ID) => Effect.Effect<Info | undefined>;
+    readonly all: () => Effect.Effect<readonly Info[]>;
+    readonly available: () => Effect.Effect<readonly Info[]>;
+    /** Internal definition/access snapshot; raw model inventories never cross the HTTP API. */
+    readonly snapshot: () => Effect.Effect<Snapshot>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/Provider", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;

package/dist/types/session/execution.d.ts

@@ -24,7 +24,7 @@ export interface Interface {
      * rather than fresh work admitted during its cleanup.
      */
     readonly interrupt: (sessionID: SessionSchema.ID, options?: {
-        readonly continue?: boolean;
+        readonly resume?: boolean;
         readonly reason?: "user" | "inactivity";
         readonly awaitSettlement?: boolean;
     }) => Effect.Effect<boolean>;