oh-my-opencode 3.13.1 → 3.14.0

package/dist/plugin/chat-params.d.ts

@@ -27,5 +27,6 @@ export declare function createChatParamsHandler(args: {
     anthropicEffort: {
         "chat.params"?: (input: ChatParamsHookInput, output: ChatParamsOutput) => Promise<void>;
     } | null;
+    client?: unknown;
 }): (input: unknown, output: unknown) => Promise<void>;
 export {};

package/dist/shared/connected-providers-cache.d.ts

@@ -1,11 +1,26 @@
-interface ModelMetadata {
+export interface ModelMetadata {
     id: string;
     provider?: string;
     context?: number;
     output?: number;
     name?: string;
+    variants?: Record<string, unknown>;
+    limit?: {
+        context?: number;
+        input?: number;
+        output?: number;
+    };
+    modalities?: {
+        input?: string[];
+        output?: string[];
+    };
+    capabilities?: Record<string, unknown>;
+    reasoning?: boolean;
+    temperature?: boolean;
+    tool_call?: boolean;
+    [key: string]: unknown;
 }
-interface ProviderModelsCache {
+export interface ProviderModelsCache {
     models: Record<string, string[] | ModelMetadata[]>;
     connected: string[];
     updatedAt: string;
@@ -16,7 +31,7 @@ export declare function createConnectedProvidersCacheStore(getCacheDir?: () => s
     readProviderModelsCache: () => ProviderModelsCache | null;
     hasProviderModelsCache: () => boolean;
     writeProviderModelsCache: (data: {
-        models: Record<string, string[]>;
+        models: Record<string, string[] | ModelMetadata[]>;
         connected: string[];
     }) => void;
     updateConnectedProvidersCache: (client: {
@@ -33,8 +48,9 @@ export declare function createConnectedProvidersCacheStore(getCacheDir?: () => s
         };
     }) => Promise<void>;
 };
+export declare function findProviderModelMetadata(providerID: string, modelID: string, cache?: ProviderModelsCache | null): ModelMetadata | undefined;
 export declare const readConnectedProvidersCache: () => string[] | null, hasConnectedProvidersCache: () => boolean, readProviderModelsCache: () => ProviderModelsCache | null, hasProviderModelsCache: () => boolean, writeProviderModelsCache: (data: {
-    models: Record<string, string[]>;
+    models: Record<string, string[] | ModelMetadata[]>;
     connected: string[];
 }) => void, updateConnectedProvidersCache: (client: {
     provider?: {
@@ -49,4 +65,3 @@ export declare const readConnectedProvidersCache: () => string[] | null, hasConn
         }>;
     };
 }) => Promise<void>;
-export {};

package/dist/shared/fallback-chain-from-models.d.ts

@@ -1,3 +1,12 @@
 import type { FallbackEntry } from "./model-requirements";
+import type { FallbackModelObject } from "../config/schema/fallback-models";
 export declare function parseFallbackModelEntry(model: string, contextProviderID: string | undefined, defaultProviderID?: string): FallbackEntry | undefined;
-export declare function buildFallbackChainFromModels(fallbackModels: string | string[] | undefined, contextProviderID: string | undefined, defaultProviderID?: string): FallbackEntry[] | undefined;
+export declare function parseFallbackModelObjectEntry(obj: FallbackModelObject, contextProviderID: string | undefined, defaultProviderID?: string): FallbackEntry | undefined;
+/**
+ * Find the most specific FallbackEntry whose `provider/model` is a prefix of
+ * the resolved `provider/modelID`.  Longest match wins so that e.g.
+ * `openai/gpt-5.4-preview` picks the entry for `openai/gpt-5.4-preview` over
+ * the shorter `openai/gpt-5.4`.
+ */
+export declare function findMostSpecificFallbackEntry(providerID: string, modelID: string, chain: FallbackEntry[]): FallbackEntry | undefined;
+export declare function buildFallbackChainFromModels(fallbackModels: string | (string | FallbackModelObject)[] | undefined, contextProviderID: string | undefined, defaultProviderID?: string): FallbackEntry[] | undefined;

package/dist/shared/index.d.ts

@@ -31,10 +31,14 @@ export * from "./agent-tool-restrictions";
 export * from "./model-requirements";
 export * from "./model-resolver";
 export { normalizeModel, normalizeModelID } from "./model-normalization";
-export { normalizeFallbackModels } from "./model-resolver";
+export { normalizeFallbackModels, flattenToFallbackModelStrings } from "./model-resolver";
 export { resolveModelPipeline } from "./model-resolution-pipeline";
 export type { ModelResolutionRequest, ModelResolutionProvenance, ModelResolutionResult, } from "./model-resolution-types";
 export * from "./model-availability";
+export * from "./model-capabilities";
+export * from "./model-capabilities-cache";
+export * from "./model-capability-heuristics";
+export * from "./model-settings-compatibility";
 export * from "./fallback-model-availability";
 export * from "./connected-providers-cache";
 export * from "./context-limit-resolver";
@@ -50,6 +54,7 @@ export * from "./truncate-description";
 export * from "./opencode-storage-paths";
 export * from "./opencode-message-dir";
 export * from "./opencode-command-dirs";
+export * from "./project-discovery-dirs";
 export * from "./normalize-sdk-response";
 export * from "./session-directory-resolver";
 export * from "./prompt-tools";
@@ -57,3 +62,4 @@ export * from "./internal-initiator-marker";
 export * from "./plugin-command-discovery";
 export { SessionCategoryRegistry } from "./session-category-registry";
 export * from "./plugin-identity";
+export * from "./log-legacy-plugin-startup-warning";

package/dist/shared/known-variants.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Canonical set of recognised variant / effort tokens.
+ * Used by parseFallbackModelEntry (space-suffix detection) and
+ * flattenToFallbackModelStrings (inline-variant stripping).
+ */
+export declare const KNOWN_VARIANTS: Set<string>;

package/dist/shared/legacy-plugin-warning.d.ts

@@ -0,0 +1,6 @@
+export interface LegacyPluginCheckResult {
+    hasLegacyEntry: boolean;
+    hasCanonicalEntry: boolean;
+    legacyEntries: string[];
+}
+export declare function checkForLegacyPluginEntry(overrideConfigDir?: string): LegacyPluginCheckResult;

package/dist/shared/log-legacy-plugin-startup-warning.d.ts

@@ -0,0 +1 @@
+export declare function logLegacyPluginStartupWarning(): void;

package/dist/shared/model-capabilities-cache.d.ts

@@ -0,0 +1,20 @@
+import type { ModelCapabilitiesSnapshot } from "./model-capabilities";
+export declare const MODELS_DEV_SOURCE_URL = "https://models.dev/api.json";
+export declare function buildModelCapabilitiesSnapshotFromModelsDev(raw: unknown): ModelCapabilitiesSnapshot;
+export declare function fetchModelCapabilitiesSnapshot(args?: {
+    sourceUrl?: string;
+    fetchImpl?: typeof fetch;
+}): Promise<ModelCapabilitiesSnapshot>;
+export declare function createModelCapabilitiesCacheStore(getCacheDir?: () => string): {
+    readModelCapabilitiesCache: () => ModelCapabilitiesSnapshot | null;
+    hasModelCapabilitiesCache: () => boolean;
+    writeModelCapabilitiesCache: (snapshot: ModelCapabilitiesSnapshot) => void;
+    refreshModelCapabilitiesCache: (args?: {
+        sourceUrl?: string;
+        fetchImpl?: typeof fetch;
+    }) => Promise<ModelCapabilitiesSnapshot>;
+};
+export declare const readModelCapabilitiesCache: () => ModelCapabilitiesSnapshot | null, hasModelCapabilitiesCache: () => boolean, writeModelCapabilitiesCache: (snapshot: ModelCapabilitiesSnapshot) => void, refreshModelCapabilitiesCache: (args?: {
+    sourceUrl?: string;
+    fetchImpl?: typeof fetch;
+}) => Promise<ModelCapabilitiesSnapshot>;

package/dist/shared/model-capabilities.d.ts

@@ -0,0 +1,91 @@
+import { type ModelMetadata } from "./connected-providers-cache";
+export type ModelCapabilitiesSnapshotEntry = {
+    id: string;
+    family?: string;
+    reasoning?: boolean;
+    temperature?: boolean;
+    toolCall?: boolean;
+    modalities?: {
+        input?: string[];
+        output?: string[];
+    };
+    limit?: {
+        context?: number;
+        input?: number;
+        output?: number;
+    };
+};
+export type ModelCapabilitiesSnapshot = {
+    generatedAt: string;
+    sourceUrl: string;
+    models: Record<string, ModelCapabilitiesSnapshotEntry>;
+};
+export type ModelCapabilities = {
+    requestedModelID: string;
+    canonicalModelID: string;
+    family?: string;
+    variants?: string[];
+    reasoningEfforts?: string[];
+    reasoning?: boolean;
+    supportsThinking?: boolean;
+    supportsTemperature?: boolean;
+    supportsTopP?: boolean;
+    maxOutputTokens?: number;
+    toolCall?: boolean;
+    modalities?: {
+        input?: string[];
+        output?: string[];
+    };
+    diagnostics: ModelCapabilitiesDiagnostics;
+};
+type GetModelCapabilitiesInput = {
+    providerID: string;
+    modelID: string;
+    runtimeModel?: ModelMetadata | Record<string, unknown>;
+    runtimeSnapshot?: ModelCapabilitiesSnapshot;
+    bundledSnapshot?: ModelCapabilitiesSnapshot;
+};
+type DiagnosticSource = "none" | "runtime" | "runtime-snapshot" | "bundled-snapshot" | "override" | "heuristic" | "canonical" | "exact-alias" | "pattern-alias";
+export type ModelCapabilitiesDiagnostics = {
+    resolutionMode: "snapshot-backed" | "alias-backed" | "heuristic-backed" | "unknown";
+    canonicalization: {
+        source: "canonical" | "exact-alias" | "pattern-alias";
+        ruleID?: string;
+    };
+    snapshot: {
+        source: "runtime-snapshot" | "bundled-snapshot" | "none";
+    };
+    family: {
+        source: "snapshot" | "heuristic" | "none";
+    };
+    variants: {
+        source: Exclude<DiagnosticSource, "runtime-snapshot" | "bundled-snapshot" | "exact-alias" | "pattern-alias">;
+    };
+    reasoningEfforts: {
+        source: Exclude<DiagnosticSource, "runtime-snapshot" | "bundled-snapshot" | "canonical" | "exact-alias" | "pattern-alias" | "runtime">;
+    };
+    reasoning: {
+        source: "runtime" | "runtime-snapshot" | "bundled-snapshot" | "none";
+    };
+    supportsThinking: {
+        source: "runtime" | "override" | "heuristic" | "runtime-snapshot" | "bundled-snapshot" | "none";
+    };
+    supportsTemperature: {
+        source: "runtime" | "override" | "runtime-snapshot" | "bundled-snapshot" | "none";
+    };
+    supportsTopP: {
+        source: "runtime" | "override" | "none";
+    };
+    maxOutputTokens: {
+        source: "runtime" | "runtime-snapshot" | "bundled-snapshot" | "none";
+    };
+    toolCall: {
+        source: "runtime" | "runtime-snapshot" | "bundled-snapshot" | "none";
+    };
+    modalities: {
+        source: "runtime" | "runtime-snapshot" | "bundled-snapshot" | "none";
+    };
+};
+export declare function getBundledModelCapabilitiesSnapshot(): ModelCapabilitiesSnapshot;
+export declare function getModelCapabilities(input: GetModelCapabilitiesInput): ModelCapabilities;
+export {};

package/dist/shared/model-capability-aliases.d.ts

@@ -0,0 +1,21 @@
+export type ExactAliasRule = {
+    aliasModelID: string;
+    ruleID: string;
+    canonicalModelID: string;
+    rationale: string;
+};
+export type PatternAliasRule = {
+    ruleID: string;
+    description: string;
+    match: (normalizedModelID: string) => boolean;
+    canonicalize: (normalizedModelID: string) => string;
+};
+export type ModelIDAliasResolution = {
+    requestedModelID: string;
+    canonicalModelID: string;
+    source: "canonical" | "exact-alias" | "pattern-alias";
+    ruleID?: string;
+};
+export declare function resolveModelIDAlias(modelID: string): ModelIDAliasResolution;
+export declare function getExactModelIDAliasRules(): ReadonlyArray<ExactAliasRule>;
+export declare function getPatternModelIDAliasRules(): ReadonlyArray<PatternAliasRule>;

package/dist/shared/model-capability-guardrails.d.ts

@@ -0,0 +1,38 @@
+import type { ModelCapabilitiesSnapshot } from "./model-capabilities";
+export type ModelCapabilityGuardrailIssue = {
+    kind: "alias-target-missing-from-snapshot";
+    ruleID: string;
+    aliasModelID: string;
+    canonicalModelID: string;
+    message: string;
+} | {
+    kind: "exact-alias-collides-with-snapshot";
+    ruleID: string;
+    aliasModelID: string;
+    canonicalModelID: string;
+    message: string;
+} | {
+    kind: "pattern-alias-collides-with-snapshot";
+    ruleID: string;
+    modelID: string;
+    canonicalModelID: string;
+    message: string;
+} | {
+    kind: "built-in-model-relies-on-alias";
+    modelID: string;
+    canonicalModelID: string;
+    ruleID: string;
+    message: string;
+} | {
+    kind: "built-in-model-missing-from-snapshot";
+    modelID: string;
+    canonicalModelID: string;
+    message: string;
+};
+type CollectModelCapabilityGuardrailIssuesInput = {
+    snapshot?: ModelCapabilitiesSnapshot;
+    requirementModelIDs?: Iterable<string>;
+};
+export declare function getBuiltInRequirementModelIDs(): string[];
+export declare function collectModelCapabilityGuardrailIssues(input?: CollectModelCapabilityGuardrailIssuesInput): ModelCapabilityGuardrailIssue[];
+export {};

package/dist/shared/model-capability-heuristics.d.ts

@@ -0,0 +1,10 @@
+export type HeuristicModelFamilyDefinition = {
+    family: string;
+    includes?: string[];
+    pattern?: RegExp;
+    variants?: string[];
+    reasoningEfforts?: string[];
+    supportsThinking?: boolean;
+};
+export declare const HEURISTIC_MODEL_FAMILY_REGISTRY: ReadonlyArray<HeuristicModelFamilyDefinition>;
+export declare function detectHeuristicModelFamily(modelID: string): HeuristicModelFamilyDefinition | undefined;

package/dist/shared/model-requirements.d.ts

@@ -2,6 +2,14 @@ export type FallbackEntry = {
     providers: string[];
     model: string;
     variant?: string;
+    reasoningEffort?: string;
+    temperature?: number;
+    top_p?: number;
+    maxTokens?: number;
+    thinking?: {
+        type: "enabled" | "disabled";
+        budgetTokens?: number;
+    };
 };
 export type ModelRequirement = {
     fallbackChain: FallbackEntry[];

package/dist/shared/model-resolution-types.d.ts

@@ -1,4 +1,17 @@
 import type { FallbackEntry } from "./model-requirements";
+export interface DelegatedModelConfig {
+    providerID: string;
+    modelID: string;
+    variant?: string;
+    reasoningEffort?: string;
+    temperature?: number;
+    top_p?: number;
+    maxTokens?: number;
+    thinking?: {
+        type: "enabled" | "disabled";
+        budgetTokens?: number;
+    };
+}
 export type ModelResolutionRequest = {
     intent?: {
         uiSelectedModel?: string;

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

@@ -1,4 +1,5 @@
 import type { FallbackEntry } from "./model-requirements";
+import type { FallbackModelObject } from "../config/schema/fallback-models";
 export type ModelResolutionInput = {
     userModel?: string;
     inheritedModel?: string;
@@ -22,7 +23,13 @@ export type ExtendedModelResolutionInput = {
 export declare function resolveModel(input: ModelResolutionInput): string | undefined;
 export declare function resolveModelWithFallback(input: ExtendedModelResolutionInput): ModelResolutionResult | undefined;
 /**
- * Normalizes fallback_models config (which can be string or string[]) to string[]
- * Centralized helper to avoid duplicated normalization logic
+ * Normalizes fallback_models config to a mixed array.
+ * Accepts string, string[], or mixed arrays of strings and FallbackModelObject entries.
  */
-export declare function normalizeFallbackModels(models: string | string[] | undefined): string[] | undefined;
+export declare function normalizeFallbackModels(models: string | (string | FallbackModelObject)[] | undefined): (string | FallbackModelObject)[] | undefined;
+/**
+ * Extracts plain model strings from a mixed fallback models array.
+ * Object entries are flattened to "model" or "model(variant)" strings.
+ * Use this when consumers need string[] (e.g., resolveModelForDelegateTask).
+ */
+export declare function flattenToFallbackModelStrings(models: (string | FallbackModelObject)[] | undefined): string[] | undefined;

package/dist/shared/model-settings-compatibility.d.ts

@@ -0,0 +1,40 @@
+type CompatibilityField = "variant" | "reasoningEffort" | "temperature" | "topP" | "maxTokens" | "thinking";
+type DesiredModelSettings = {
+    variant?: string;
+    reasoningEffort?: string;
+    temperature?: number;
+    topP?: number;
+    maxTokens?: number;
+    thinking?: Record<string, unknown>;
+};
+type CompatibilityCapabilities = {
+    variants?: string[];
+    reasoningEfforts?: string[];
+    supportsTemperature?: boolean;
+    supportsTopP?: boolean;
+    maxOutputTokens?: number;
+    supportsThinking?: boolean;
+};
+export type ModelSettingsCompatibilityInput = {
+    providerID: string;
+    modelID: string;
+    desired: DesiredModelSettings;
+    capabilities?: CompatibilityCapabilities;
+};
+export type ModelSettingsCompatibilityChange = {
+    field: CompatibilityField;
+    from: string;
+    to?: string;
+    reason: "unsupported-by-model-family" | "unknown-model-family" | "unsupported-by-model-metadata" | "max-output-limit";
+};
+export type ModelSettingsCompatibilityResult = {
+    variant?: string;
+    reasoningEffort?: string;
+    temperature?: number;
+    topP?: number;
+    maxTokens?: number;
+    thinking?: Record<string, unknown>;
+    changes: ModelSettingsCompatibilityChange[];
+};
+export declare function resolveCompatibleModelSettings(input: ModelSettingsCompatibilityInput): ModelSettingsCompatibilityResult;
+export {};

package/dist/shared/plugin-identity.d.ts

@@ -1,5 +1,6 @@
-export declare const PLUGIN_NAME = "oh-my-opencode";
-export declare const LEGACY_PLUGIN_NAME = "oh-my-openagent";
-export declare const CONFIG_BASENAME = "oh-my-opencode";
+export declare const PLUGIN_NAME = "oh-my-openagent";
+export declare const LEGACY_PLUGIN_NAME = "oh-my-opencode";
+export declare const CONFIG_BASENAME = "oh-my-openagent";
+export declare const LEGACY_CONFIG_BASENAME = "oh-my-opencode";
 export declare const LOG_FILENAME = "oh-my-opencode.log";
 export declare const CACHE_DIR_NAME = "oh-my-opencode";

package/dist/shared/project-discovery-dirs.d.ts

@@ -0,0 +1,4 @@
+export declare function findProjectClaudeSkillDirs(startDirectory: string, stopDirectory?: string): string[];
+export declare function findProjectAgentsSkillDirs(startDirectory: string, stopDirectory?: string): string[];
+export declare function findProjectOpencodeSkillDirs(startDirectory: string, stopDirectory?: string): string[];
+export declare function findProjectOpencodeCommandDirs(startDirectory: string, stopDirectory?: string): string[];

package/dist/shared/session-prompt-params-helpers.d.ts

@@ -0,0 +1,12 @@
+type PromptParamModel = {
+    temperature?: number;
+    top_p?: number;
+    reasoningEffort?: string;
+    maxTokens?: number;
+    thinking?: {
+        type: "enabled" | "disabled";
+        budgetTokens?: number;
+    };
+};
+export declare function applySessionPromptParams(sessionID: string, model: PromptParamModel | undefined): void;
+export {};

package/dist/shared/session-prompt-params-state.d.ts

@@ -0,0 +1,9 @@
+export type SessionPromptParams = {
+    temperature?: number;
+    topP?: number;
+    options?: Record<string, unknown>;
+};
+export declare function setSessionPromptParams(sessionID: string, params: SessionPromptParams): void;
+export declare function getSessionPromptParams(sessionID: string): SessionPromptParams | undefined;
+export declare function clearSessionPromptParams(sessionID: string): void;
+export declare function clearAllSessionPromptParams(): void;

package/dist/tools/delegate-task/background-task.d.ts

@@ -1,8 +1,4 @@
-import type { DelegateTaskArgs, ToolContextWithMetadata } from "./types";
+import type { DelegateTaskArgs, ToolContextWithMetadata, DelegatedModelConfig } from "./types";
 import type { ExecutorContext, ParentContext } from "./executor-types";
 import type { FallbackEntry } from "../../shared/model-requirements";
-export declare function executeBackgroundTask(args: DelegateTaskArgs, ctx: ToolContextWithMetadata, executorCtx: ExecutorContext, parentContext: ParentContext, agentToUse: string, categoryModel: {
-    providerID: string;
-    modelID: string;
-    variant?: string;
-} | undefined, systemContent: string | undefined, fallbackChain?: FallbackEntry[]): Promise<string>;
+export declare function executeBackgroundTask(args: DelegateTaskArgs, ctx: ToolContextWithMetadata, executorCtx: ExecutorContext, parentContext: ParentContext, agentToUse: string, categoryModel: DelegatedModelConfig | undefined, systemContent: string | undefined, fallbackChain?: FallbackEntry[]): Promise<string>;

package/dist/tools/delegate-task/category-resolver.d.ts

@@ -2,13 +2,10 @@ import type { ModelFallbackInfo } from "../../features/task-toast-manager/types"
 import type { DelegateTaskArgs } from "./types";
 import type { ExecutorContext } from "./executor-types";
 import type { FallbackEntry } from "../../shared/model-requirements";
+import type { DelegatedModelConfig } from "./types";
 export interface CategoryResolutionResult {
     agentToUse: string;
-    categoryModel: {
-        providerID: string;
-        modelID: string;
-        variant?: string;
-    } | undefined;
+    categoryModel: DelegatedModelConfig | undefined;
     categoryPromptAppend: string | undefined;
     maxPromptTokens?: number;
     modelInfo: ModelFallbackInfo | undefined;

package/dist/tools/delegate-task/model-selection.d.ts

@@ -10,6 +10,8 @@ export declare function resolveModelForDelegateTask(input: {
 }): {
     model: string;
     variant?: string;
+    fallbackEntry?: FallbackEntry;
+    matchedFallback?: boolean;
 } | {
     skipped: true;
 } | undefined;

package/dist/tools/delegate-task/subagent-resolver.d.ts

@@ -1,13 +1,10 @@
 import type { DelegateTaskArgs } from "./types";
 import type { ExecutorContext } from "./executor-types";
+import type { DelegatedModelConfig } from "./types";
 import type { FallbackEntry } from "../../shared/model-requirements";
-export declare function resolveSubagentExecution(args: DelegateTaskArgs, executorCtx: ExecutorContext, parentAgent: string | undefined, categoryExamples: string, inheritedModel?: string): Promise<{
+export declare function resolveSubagentExecution(args: DelegateTaskArgs, executorCtx: ExecutorContext, parentAgent: string | undefined, categoryExamples: string): Promise<{
     agentToUse: string;
-    categoryModel: {
-        providerID: string;
-        modelID: string;
-        variant?: string;
-    } | undefined;
+    categoryModel: DelegatedModelConfig | undefined;
     fallbackChain?: FallbackEntry[];
     error?: string;
 }>;

package/dist/tools/delegate-task/sync-prompt-sender.d.ts

@@ -1,4 +1,4 @@
-import type { DelegateTaskArgs, OpencodeClient } from "./types";
+import type { DelegateTaskArgs, OpencodeClient, DelegatedModelConfig } from "./types";
 import { promptSyncWithModelSuggestionRetry, promptWithModelSuggestionRetry } from "../../shared/model-suggestion-retry";
 type SendSyncPromptDeps = {
     promptWithModelSuggestionRetry: typeof promptWithModelSuggestionRetry;
@@ -9,11 +9,7 @@ export declare function sendSyncPrompt(client: OpencodeClient, input: {
     agentToUse: string;
     args: DelegateTaskArgs;
     systemContent: string | undefined;
-    categoryModel: {
-        providerID: string;
-        modelID: string;
-        variant?: string;
-    } | undefined;
+    categoryModel: DelegatedModelConfig | undefined;
     toastManager: {
         removeTask: (id: string) => void;
     } | null | undefined;

package/dist/tools/delegate-task/sync-session-poller.d.ts

@@ -9,4 +9,5 @@ export declare function pollSyncSession(ctx: ToolContextWithMetadata, client: Op
     } | null | undefined;
     taskId: string | undefined;
     anchorMessageCount?: number;
+    maxAssistantTurns?: number;
 }, timeoutMs?: number): Promise<string | null>;

package/dist/tools/delegate-task/sync-task.d.ts

@@ -1,9 +1,5 @@
 import type { ModelFallbackInfo } from "../../features/task-toast-manager/types";
-import type { DelegateTaskArgs, ToolContextWithMetadata } from "./types";
+import type { DelegateTaskArgs, ToolContextWithMetadata, DelegatedModelConfig } from "./types";
 import type { ExecutorContext, ParentContext } from "./executor-types";
 import { type SyncTaskDeps } from "./sync-task-deps";
-export declare function executeSyncTask(args: DelegateTaskArgs, ctx: ToolContextWithMetadata, executorCtx: ExecutorContext, parentContext: ParentContext, agentToUse: string, categoryModel: {
-    providerID: string;
-    modelID: string;
-    variant?: string;
-} | undefined, systemContent: string | undefined, modelInfo?: ModelFallbackInfo, fallbackChain?: import("../../shared/model-requirements").FallbackEntry[], deps?: SyncTaskDeps): Promise<string>;
+export declare function executeSyncTask(args: DelegateTaskArgs, ctx: ToolContextWithMetadata, executorCtx: ExecutorContext, parentContext: ParentContext, agentToUse: string, categoryModel: DelegatedModelConfig | undefined, systemContent: string | undefined, modelInfo?: ModelFallbackInfo, fallbackChain?: import("../../shared/model-requirements").FallbackEntry[], deps?: SyncTaskDeps): Promise<string>;

package/dist/tools/delegate-task/types.d.ts

@@ -65,6 +65,8 @@ export interface DelegateTaskToolOptions {
     onSyncSessionCreated?: (event: SyncSessionCreatedEvent) => Promise<void>;
     syncPollTimeoutMs?: number;
 }
+import type { DelegatedModelConfig } from "../../shared/model-resolution-types";
+export type { DelegatedModelConfig };
 export interface BuildSystemContentInput {
     skillContent?: string;
     skillContents?: string[];
@@ -72,11 +74,7 @@ export interface BuildSystemContentInput {
     agentsContext?: string;
     planAgentPrepend?: string;
     maxPromptTokens?: number;
-    model?: {
-        providerID: string;
-        modelID: string;
-        variant?: string;
-    };
+    model?: DelegatedModelConfig;
     agentName?: string;
     availableCategories?: AvailableCategory[];
     availableSkills?: AvailableSkill[];

package/dist/tools/delegate-task/unstable-agent-task.d.ts

@@ -1,7 +1,3 @@
-import type { DelegateTaskArgs, ToolContextWithMetadata } from "./types";
+import type { DelegateTaskArgs, ToolContextWithMetadata, DelegatedModelConfig } from "./types";
 import type { ExecutorContext, ParentContext } from "./executor-types";
-export declare function executeUnstableAgentTask(args: DelegateTaskArgs, ctx: ToolContextWithMetadata, executorCtx: ExecutorContext, parentContext: ParentContext, agentToUse: string, categoryModel: {
-    providerID: string;
-    modelID: string;
-    variant?: string;
-} | undefined, systemContent: string | undefined, actualModel: string | undefined): Promise<string>;
+export declare function executeUnstableAgentTask(args: DelegateTaskArgs, ctx: ToolContextWithMetadata, executorCtx: ExecutorContext, parentContext: ParentContext, agentToUse: string, categoryModel: DelegatedModelConfig | undefined, systemContent: string | undefined, actualModel: string | undefined): Promise<string>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode",
-  "version": "3.13.1",
+  "version": "3.14.0",
   "description": "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -25,10 +25,12 @@
     "build:all": "bun run build && bun run build:binaries",
     "build:binaries": "bun run script/build-binaries.ts",
     "build:schema": "bun run script/build-schema.ts",
+    "build:model-capabilities": "bun run script/build-model-capabilities.ts",
     "clean": "rm -rf dist",
     "prepare": "bun run build",
     "postinstall": "node postinstall.mjs",
     "prepublishOnly": "bun run clean && bun run build",
+    "test:model-capabilities": "bun test src/shared/model-capability-aliases.test.ts src/shared/model-capability-guardrails.test.ts src/shared/model-capabilities.test.ts src/cli/doctor/checks/model-resolution.test.ts --bail",
     "typecheck": "tsc --noEmit",
     "test": "bun test"
   },
@@ -76,17 +78,17 @@
     "typescript": "^5.7.3"
   },
   "optionalDependencies": {
-    "oh-my-opencode-darwin-arm64": "3.13.1",
-    "oh-my-opencode-darwin-x64": "3.13.1",
-    "oh-my-opencode-darwin-x64-baseline": "3.13.1",
-    "oh-my-opencode-linux-arm64": "3.13.1",
-    "oh-my-opencode-linux-arm64-musl": "3.13.1",
-    "oh-my-opencode-linux-x64": "3.13.1",
-    "oh-my-opencode-linux-x64-baseline": "3.13.1",
-    "oh-my-opencode-linux-x64-musl": "3.13.1",
-    "oh-my-opencode-linux-x64-musl-baseline": "3.13.1",
-    "oh-my-opencode-windows-x64": "3.13.1",
-    "oh-my-opencode-windows-x64-baseline": "3.13.1"
+    "oh-my-opencode-darwin-arm64": "3.14.0",
+    "oh-my-opencode-darwin-x64": "3.14.0",
+    "oh-my-opencode-darwin-x64-baseline": "3.14.0",
+    "oh-my-opencode-linux-arm64": "3.14.0",
+    "oh-my-opencode-linux-arm64-musl": "3.14.0",
+    "oh-my-opencode-linux-x64": "3.14.0",
+    "oh-my-opencode-linux-x64-baseline": "3.14.0",
+    "oh-my-opencode-linux-x64-musl": "3.14.0",
+    "oh-my-opencode-linux-x64-musl-baseline": "3.14.0",
+    "oh-my-opencode-windows-x64": "3.14.0",
+    "oh-my-opencode-windows-x64-baseline": "3.14.0"
   },
   "overrides": {
     "@opencode-ai/sdk": "^1.2.24"