oh-my-opencode 4.2.3 → 4.3.0

package/dist/plugin/hooks/create-tool-guard-hooks.d.ts

@@ -1,7 +1,7 @@
 import type { HookName, OhMyOpenCodeConfig } from "../../config";
 import type { ModelCacheState } from "../../plugin-state";
 import type { PluginContext } from "../types";
-import { createCommentCheckerHooks, createToolOutputTruncatorHook, createDirectoryAgentsInjectorHook, createDirectoryReadmeInjectorHook, createEmptyTaskResponseDetectorHook, createRulesInjectorHook, createTasksTodowriteDisablerHook, createWriteExistingFileGuardHook, createBashFileReadGuardHook, createHashlineReadEnhancerHook, createReadImageResizerHook, createJsonErrorRecoveryHook, createTodoDescriptionOverrideHook, createWebFetchRedirectGuardHook, createTeamToolGating, createFsyncSkipWarningHook } from "../../hooks";
+import { createCommentCheckerHooks, createToolOutputTruncatorHook, createDirectoryAgentsInjectorHook, createDirectoryReadmeInjectorHook, createEmptyTaskResponseDetectorHook, createRulesInjectorHook, createTasksTodowriteDisablerHook, createWriteExistingFileGuardHook, createBashFileReadGuardHook, createHashlineReadEnhancerHook, createReadImageResizerHook, createJsonErrorRecoveryHook, createTodoDescriptionOverrideHook, createWebFetchRedirectGuardHook, createTeamToolGating, createFsyncSkipWarningHook, createNotepadWriteGuardHook, createPlanFormatValidatorHook } from "../../hooks";
 export type ToolGuardHooks = {
     commentChecker: ReturnType<typeof createCommentCheckerHooks> | null;
     toolOutputTruncator: ReturnType<typeof createToolOutputTruncatorHook> | null;
@@ -19,6 +19,8 @@ export type ToolGuardHooks = {
     webfetchRedirectGuard: ReturnType<typeof createWebFetchRedirectGuardHook> | null;
     fsyncSkipWarning: ReturnType<typeof createFsyncSkipWarningHook> | null;
     teamToolGating: ReturnType<typeof createTeamToolGating> | null;
+    notepadWriteGuard: ReturnType<typeof createNotepadWriteGuardHook> | null;
+    planFormatValidator: ReturnType<typeof createPlanFormatValidatorHook> | null;
 };
 export declare function createToolGuardHooks(args: {
     ctx: PluginContext;

package/dist/plugin/system-transform.d.ts

@@ -1,4 +1,5 @@
-export declare function createSystemTransformHandler(): (input: {
+import type { DefaultModeConfig } from "../config/schema/default-mode";
+export declare function createSystemTransformHandler(defaultMode?: DefaultModeConfig, getUltraworkMessage?: (agentName?: string, modelID?: string) => string): (input: {
     sessionID?: string;
     model: {
         id: string;

package/dist/plugin/tool-definition.d.ts

@@ -0,0 +1,9 @@
+import type { CreatedHooks } from "../create-hooks";
+export declare function createToolDefinitionHandler(args: {
+    hooks: CreatedHooks;
+}): (input: {
+    toolID: string;
+}, output: {
+    description: string;
+    parameters: unknown;
+}) => Promise<void>;

package/dist/plugin-handlers/agent-key-remapper.d.ts

@@ -1 +1,5 @@
-export declare function remapAgentKeysToDisplayNames(agents: Record<string, unknown>): Record<string, unknown>;
+type AgentOverridesMap = Record<string, {
+    displayName?: string;
+} | undefined>;
+export declare function remapAgentKeysToDisplayNames(agents: Record<string, unknown>, overrides?: AgentOverridesMap): Record<string, unknown>;
+export {};

package/dist/plugin-handlers/hook-config-handler.d.ts

@@ -0,0 +1,7 @@
+import type { PluginComponents } from "./plugin-components-loader";
+export declare function applyHookConfig(params: {
+    pluginComponents: PluginComponents;
+    ctx: {
+        directory: string;
+    };
+}): void;

package/dist/plugin-handlers/index.d.ts

@@ -3,6 +3,7 @@ export * from "./provider-config-handler";
 export * from "./agent-config-handler";
 export * from "./tool-config-handler";
 export * from "./mcp-config-handler";
+export * from "./hook-config-handler";
 export * from "./command-config-handler";
 export * from "./plugin-components-loader";
 export * from "./category-config-resolver";

package/dist/plugin-handlers/plugin-components-loader.d.ts

@@ -1,12 +1,11 @@
 import type { OhMyOpenCodeConfig } from "../config";
+import type { PluginHooksConfig } from "../hooks/claude-code-hooks/types";
 export type PluginComponents = {
     commands: Record<string, unknown>;
     skills: Record<string, unknown>;
     agents: Record<string, unknown>;
     mcpServers: Record<string, unknown>;
-    hooksConfigs: Array<{
-        hooks?: Record<string, unknown>;
-    }>;
+    hooksConfigs: PluginHooksConfig[];
     plugins: Array<{
         name: string;
         version: string;

package/dist/shared/agent-display-names.d.ts

@@ -16,8 +16,14 @@ export declare function stripAgentListSortPrefix(agentName: string): string;
  * Get display name for an agent config key.
  * Uses case-insensitive lookup for backward compatibility.
  * Returns original key if not found.
+ *
+ * @param overrides - Optional per-agent overrides map. If the agent has a `displayName`
+ *   field set, it takes precedence over the hardcoded AGENT_DISPLAY_NAMES entry.
+ *   This enables i18n: `agents.sisyphus.displayName = "总指挥"` in oh-my-openagent.json.
  */
-export declare function getAgentDisplayName(configKey: string): string;
+export declare function getAgentDisplayName(configKey: string, overrides?: Record<string, {
+    displayName?: string;
+} | undefined>): string;
 /**
  * Thin alias for `getAgentDisplayName` preserved for external imports.
  *
@@ -27,7 +33,9 @@ export declare function getAgentDisplayName(configKey: string): string;
  * display name verbatim. Kept exported because downstream modules still
  * import this symbol; do not collapse the call sites without coordinating.
  */
-export declare function getAgentListDisplayName(configKey: string): string;
+export declare function getAgentListDisplayName(configKey: string, overrides?: Record<string, {
+    displayName?: string;
+} | undefined>): string;
 /**
  * Resolve an agent name (display name or config key) to its lowercase config key.
  * "Atlas - Plan Executor" -> "atlas", "Atlas (Plan Executor)" -> "atlas", "atlas" -> "atlas"

package/dist/shared/command-executor/execute-hook-command.d.ts

@@ -8,5 +8,7 @@ export interface ExecuteHookOptions {
     zshPath?: string;
     /** Timeout in milliseconds. Process is killed after this. Default: 30000 */
     timeoutMs?: number;
+    /** When provided, scrub process.env to only include these vars plus HOME/PATH/etc. Used for plugin-sourced hooks. */
+    allowedEnvVars?: string[];
 }
 export declare function executeHookCommand(command: string, stdin: string, cwd: string, options?: ExecuteHookOptions): Promise<CommandResult>;

package/dist/shared/contains-path.d.ts

@@ -1,2 +1 @@
-export declare function containsPath(rootPath: string, candidatePath: string): boolean;
-export declare function isWithinProject(candidatePath: string, projectRoot: string): boolean;
+export { containsPath, isWithinProject } from "@oh-my-opencode/utils";

package/dist/shared/context-limit-resolver.d.ts

@@ -1,5 +1,2 @@
-export type ContextLimitModelCacheState = {
-    anthropicContext1MEnabled: boolean;
-    modelContextLimitsCache?: Map<string, number>;
-};
-export declare function resolveActualContextLimit(providerID: string, modelID: string, modelCacheState?: ContextLimitModelCacheState): number | null;
+export type { ContextLimitModelCacheState } from "@oh-my-opencode/model-core";
+export { resolveActualContextLimit } from "@oh-my-opencode/model-core";

package/dist/shared/deep-merge.d.ts

@@ -1,13 +1 @@
-export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
-/**
- * Deep merges two objects, with override values taking precedence.
- * - Objects are recursively merged
- * - Arrays are replaced (not concatenated)
- * - undefined values in override do not overwrite base values
- *
- * @example
- * deepMerge({ a: 1, b: { c: 2, d: 3 } }, { b: { c: 10 }, e: 5 })
- * // => { a: 1, b: { c: 10, d: 3 }, e: 5 }
- */
-export declare function deepMerge<T extends Record<string, unknown>>(base: T, override: Partial<T>, depth?: number): T;
-export declare function deepMerge<T extends Record<string, unknown>>(base: T | undefined, override: T | undefined, depth?: number): T | undefined;
+export { deepMerge, isPlainObject } from "@oh-my-opencode/utils";

package/dist/shared/disabled-providers.d.ts

@@ -0,0 +1,14 @@
+import type { OhMyOpenCodeConfig } from "../config";
+import type { FallbackModelObject } from "../config/schema/fallback-models";
+export declare function getModelProvider(model: string): string | undefined;
+export declare function isProviderDisabled(model: string | undefined, disabled: readonly string[]): boolean;
+export declare function filterDisabledProviderModels<T extends string | FallbackModelObject>(models: readonly T[], disabled: readonly string[]): T[];
+/**
+ * Filters `disabled_providers`-listed entries out of every agent/category
+ * fallback chain and substitutes any primary `model` referencing a disabled
+ * provider with the first allowed entry from the same chain.
+ *
+ * Returns the same config reference (mutated in place). Safe to call when
+ * `disabled_providers` is unset or empty - it becomes a no-op.
+ */
+export declare function applyDisabledProviders(config: OhMyOpenCodeConfig): OhMyOpenCodeConfig;

package/dist/shared/extract-semver.d.ts

@@ -1 +1 @@
-export declare function extractSemverFromOutput(output: string): string | null;
+export { extractSemverFromOutput } from "@oh-my-opencode/utils";

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

@@ -1,12 +1 @@
-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 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;
+export { parseFallbackModelEntry, parseFallbackModelObjectEntry, findMostSpecificFallbackEntry, buildFallbackChainFromModels, } from "@oh-my-opencode/model-core";

package/dist/shared/file-utils.d.ts

@@ -1,7 +1 @@
-export declare function isMarkdownFile(entry: {
-    name: string;
-    isFile: () => boolean;
-}): boolean;
-export declare function isSymbolicLink(filePath: string): boolean;
-export declare function resolveSymlink(filePath: string): string;
-export declare function resolveSymlinkAsync(filePath: string): Promise<string>;
+export { isMarkdownFile, isSymbolicLink, resolveSymlink, resolveSymlinkAsync } from "@oh-my-opencode/utils";

package/dist/shared/frontmatter.d.ts

@@ -1,7 +1 @@
-export interface FrontmatterResult<T = Record<string, unknown>> {
-    data: T;
-    body: string;
-    hadFrontmatter: boolean;
-    parseError: boolean;
-}
-export declare function parseFrontmatter<T = Record<string, unknown>>(content: string): FrontmatterResult<T>;
+export { parseFrontmatter, type FrontmatterResult } from "@oh-my-opencode/utils";

package/dist/shared/i18n.d.ts

@@ -0,0 +1,9 @@
+import { type SupportedLocale, type TranslationKey } from "../locales";
+export declare function initI18n(opts?: {
+    locale?: string;
+    fallback?: string;
+}): void;
+export declare function getLocale(): SupportedLocale;
+export declare function setLocale(lang: string): void;
+export declare function t(key: TranslationKey, params?: Record<string, string | number>): string;
+export declare function t(key: string, params?: Record<string, string | number>): string;

package/dist/shared/index.d.ts

@@ -40,7 +40,6 @@ export type { ModelResolutionRequest, ModelResolutionProvenance, ModelResolution
 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";

package/dist/shared/jsonc-parser.d.ts

@@ -1,23 +1 @@
-export interface JsoncParseResult<T> {
-    data: T | null;
-    errors: Array<{
-        message: string;
-        offset: number;
-        length: number;
-    }>;
-}
-type DetectPluginConfigResult = {
-    format: "json" | "jsonc" | "none";
-    path: string;
-    legacyPath?: string;
-};
-export declare function parseJsonc<T = unknown>(content: string): T;
-export declare function parseJsoncSafe<T = unknown>(content: string): JsoncParseResult<T>;
-export declare function readJsoncFile<T = unknown>(filePath: string): T | null;
-export declare function detectConfigFile(basePath: string): {
-    format: "json" | "jsonc" | "none";
-    path: string;
-};
-export declare function clearPluginConfigFileDetectionCache(): void;
-export declare function detectPluginConfigFile(dir: string): DetectPluginConfigResult;
-export {};
+export { clearPluginConfigFileDetectionCache, detectConfigFile, detectPluginConfigFile, parseJsonc, parseJsoncSafe, readJsoncFile, type DetectPluginConfigFileOptions, type JsoncParseResult, } from "@oh-my-opencode/utils";

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

@@ -1,11 +1,24 @@
-export declare function fuzzyMatchModel(target: string, available: Set<string>, providers?: string[]): string | null;
 /**
- * Check if a target model is available (fuzzy match by model name, no provider filtering)
+ * Fuzzy match a target model name against available models
+ *
+ * @param target - The model name or substring to search for (e.g., "gpt-5.4", "claude-opus")
+ * @param available - Set of available model names in format "provider/model-name"
+ * @param providers - Optional array of provider names to filter by (e.g., ["openai", "anthropic"])
+ * @returns The matched model name or null if no match found
+ *
+ * Matching priority:
+ * 1. Exact match (if exists)
+ * 2. Shorter model name (more specific)
  *
- * @param targetModel - Model name to check (e.g., "gpt-5.3-codex")
- * @param availableModels - Set of available models in "provider/model" format
- * @returns true if model is available, false otherwise
+ * Matching is case-insensitive substring match.
+ * If providers array is given, only models starting with "provider/" are considered.
+ *
+ * @example
+ * const available = new Set(["openai/gpt-5.4", "openai/gpt-5.3-codex", "anthropic/claude-opus-4-7"])
+ * fuzzyMatchModel("gpt-5.4", available) // → "openai/gpt-5.4"
+ * fuzzyMatchModel("claude", available, ["openai"]) // → null (provider filter excludes anthropic)
  */
+export declare function fuzzyMatchModel(target: string, available: Set<string>, providers?: string[]): string | null;
 export declare function isModelAvailable(targetModel: string, availableModels: Set<string>): boolean;
 export declare function getConnectedProviders(client: any): Promise<string[]>;
 export declare function fetchAvailableModels(client?: any, options?: {

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

@@ -1,3 +1,6 @@
-export { getBundledModelCapabilitiesSnapshot } from "./bundled-snapshot";
-export { getModelCapabilities } from "./get-model-capabilities";
-export type { GetModelCapabilitiesInput, ModelCapabilities, ModelCapabilitiesDiagnostics, ModelCapabilitiesSnapshot, ModelCapabilitiesSnapshotEntry, } from "./types";
+import type { GetModelCapabilitiesInput, ModelCapabilities } from "@oh-my-opencode/model-core";
+export declare function getBundledModelCapabilitiesSnapshotForRuntime(): import("@oh-my-opencode/model-core").ModelCapabilitiesSnapshot;
+export declare function getBundledModelCapabilitiesSnapshotForShared(): ReturnType<typeof getBundledModelCapabilitiesSnapshotForRuntime>;
+export { getBundledModelCapabilitiesSnapshotForShared as getBundledModelCapabilitiesSnapshot };
+export declare function getModelCapabilities(input: GetModelCapabilitiesInput): ModelCapabilities;
+export type { GetModelCapabilitiesInput, ModelCapabilities, ModelCapabilitiesDiagnostics, ModelCapabilitiesSnapshot, ModelCapabilitiesSnapshotEntry, } from "@oh-my-opencode/model-core";

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

@@ -1,20 +1,16 @@
+import { MODELS_DEV_SOURCE_URL, buildModelCapabilitiesSnapshotFromModelsDev, fetchModelCapabilitiesSnapshot } from "@oh-my-opencode/model-core";
 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 { MODELS_DEV_SOURCE_URL, buildModelCapabilitiesSnapshotFromModelsDev, fetchModelCapabilitiesSnapshot, };
 export declare function createModelCapabilitiesCacheStore(getCacheDir?: () => string): {
     readModelCapabilitiesCache: () => ModelCapabilitiesSnapshot | null;
     hasModelCapabilitiesCache: () => boolean;
     writeModelCapabilitiesCache: (snapshot: ModelCapabilitiesSnapshot) => void;
     refreshModelCapabilitiesCache: (args?: {
         sourceUrl?: string;
-        fetchImpl?: typeof fetch;
+        fetchImpl?: (input: string) => Promise<Response>;
     }) => Promise<ModelCapabilitiesSnapshot>;
 };
 export declare const readModelCapabilitiesCache: () => ModelCapabilitiesSnapshot | null, hasModelCapabilitiesCache: () => boolean, writeModelCapabilitiesCache: (snapshot: ModelCapabilitiesSnapshot) => void, refreshModelCapabilitiesCache: (args?: {
     sourceUrl?: string;
-    fetchImpl?: typeof fetch;
+    fetchImpl?: (input: string) => Promise<Response>;
 }) => Promise<ModelCapabilitiesSnapshot>;

package/dist/shared/model-error-classifier.d.ts

@@ -1,34 +1,5 @@
-import type { FallbackEntry } from "./model-requirements";
-export interface ErrorInfo {
-    name?: string;
-    message?: string;
-    /** HTTP status code from the provider response (e.g., 429 for rate limit) */
-    statusCode?: number;
-}
-/**
- * Determines if an error is a retryable model error.
- * Returns true if it's a known retryable type OR matches retryable message patterns.
- */
-export declare function isRetryableModelError(error: ErrorInfo): boolean;
-/**
- * Determines if an error should trigger a fallback retry.
- * Returns true for errors that halt execution.
- */
-export declare function shouldRetryError(error: ErrorInfo): boolean;
-/**
- * Gets the next fallback model from the chain based on attempt count.
- * Returns undefined if all fallbacks have been exhausted.
- */
-export declare function getNextFallback(fallbackChain: FallbackEntry[], attemptCount: number): FallbackEntry | undefined;
-/**
- * Checks if there are more fallbacks available after the current attempt.
- */
-export declare function hasMoreFallbacks(fallbackChain: FallbackEntry[], attemptCount: number): boolean;
-/**
- * Selects the best provider for a fallback entry.
- * Priority:
- * 1) First connected provider in the entry's provider preference order
- * 2) Preferred provider when connected (and entry providers are unavailable)
- * 3) First provider listed in the fallback entry
- */
+import { getNextFallback, hasMoreFallbacks, isRetryableModelError, selectFallbackProviderWithCache, shouldRetryError } from "@oh-my-opencode/model-core";
+import type { ErrorInfo } from "@oh-my-opencode/model-core";
+export type { ErrorInfo };
+export { isRetryableModelError, shouldRetryError, getNextFallback, hasMoreFallbacks, selectFallbackProviderWithCache, };
 export declare function selectFallbackProvider(providers: string[], preferredProviderID?: string): string;

package/dist/shared/model-format-normalizer.d.ts

@@ -1,7 +1 @@
-export declare function normalizeModelFormat(model: string | {
-    providerID: string;
-    modelID: string;
-}): {
-    providerID: string;
-    modelID: string;
-} | undefined;
+export { normalizeModelFormat } from "@oh-my-opencode/model-core";

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

@@ -1,2 +1 @@
-export declare function normalizeModel(model?: string): string | undefined;
-export declare function normalizeModelID(modelID: string): string;
+export { normalizeModel, normalizeModelID } from "@oh-my-opencode/model-core";

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

@@ -1,22 +1,2 @@
-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[];
-    variant?: string;
-    requiresModel?: string;
-    requiresAnyModel?: boolean;
-    requiresProvider?: string[];
-};
-export declare const AGENT_MODEL_REQUIREMENTS: Record<string, ModelRequirement>;
-export declare const CATEGORY_MODEL_REQUIREMENTS: Record<string, ModelRequirement>;
+export type { FallbackEntry, ModelRequirement } from "@oh-my-opencode/model-core";
+export { AGENT_MODEL_REQUIREMENTS, CATEGORY_MODEL_REQUIREMENTS, } from "@oh-my-opencode/model-core";

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

@@ -1,30 +1,5 @@
-import { log as writeLog } from "./logger";
-import type { FallbackEntry } from "./model-requirements";
-type LogImplementation = typeof writeLog;
-export declare function _setModelResolutionLogImplementationForTesting(logImplementation: LogImplementation | undefined): void;
-export type ModelResolutionRequest = {
-    intent?: {
-        uiSelectedModel?: string;
-        userModel?: string;
-        userFallbackModels?: string[];
-        categoryDefaultModel?: string;
-    };
-    constraints: {
-        availableModels: Set<string>;
-        connectedProviders?: string[] | null;
-    };
-    policy?: {
-        fallbackChain?: FallbackEntry[];
-        systemDefaultModel?: string;
-    };
-};
-export type ModelResolutionProvenance = "override" | "category-default" | "provider-fallback" | "system-default";
-export type ModelResolutionResult = {
-    model: string;
-    provenance: ModelResolutionProvenance;
-    variant?: string;
-    attempted?: string[];
-    reason?: string;
-};
-export declare function resolveModelPipeline(request: ModelResolutionRequest): ModelResolutionResult | undefined;
-export {};
+import { _setModelResolutionLogImplementationForTesting } from "@oh-my-opencode/model-core";
+import type { PipelineModelResolutionRequest, PipelineModelResolutionResult } from "@oh-my-opencode/model-core";
+export { _setModelResolutionLogImplementationForTesting };
+export declare function resolveModelPipeline(request: PipelineModelResolutionRequest): PipelineModelResolutionResult | undefined;
+export type { PipelineModelResolutionRequest as ModelResolutionRequest, PipelineModelResolutionProvenance as ModelResolutionProvenance, PipelineModelResolutionResult as ModelResolutionResult, } from "@oh-my-opencode/model-core";

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

@@ -1,36 +1 @@
-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;
-        userModel?: string;
-        categoryDefaultModel?: string;
-    };
-    constraints: {
-        availableModels: Set<string>;
-    };
-    policy?: {
-        fallbackChain?: FallbackEntry[];
-        systemDefaultModel?: string;
-    };
-};
-export type ModelResolutionProvenance = "override" | "category-default" | "provider-fallback" | "system-default";
-export type ModelResolutionResult = {
-    model: string;
-    provenance: ModelResolutionProvenance;
-    variant?: string;
-    attempted?: string[];
-    reason?: string;
-};
+export type { DelegatedModelConfig, ModelResolutionRequest, ModelResolutionProvenance, ModelResolutionResult, } from "@oh-my-opencode/model-core";

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

@@ -1,35 +1,8 @@
-import type { FallbackEntry } from "./model-requirements";
-import type { FallbackModelObject } from "../config/schema/fallback-models";
-export type ModelResolutionInput = {
-    userModel?: string;
-    inheritedModel?: string;
-    systemDefault?: string;
-};
-export type ModelSource = "override" | "category-default" | "provider-fallback" | "system-default";
-export type ModelResolutionResult = {
-    model: string;
-    source: ModelSource;
-    variant?: string;
-};
-export type ExtendedModelResolutionInput = {
-    uiSelectedModel?: string;
-    userModel?: string;
-    userFallbackModels?: string[];
-    categoryDefaultModel?: string;
-    fallbackChain?: FallbackEntry[];
-    availableModels: Set<string>;
-    systemDefaultModel?: string;
-};
-export declare function resolveModel(input: ModelResolutionInput): string | undefined;
-export declare function resolveModelWithFallback(input: ExtendedModelResolutionInput): ModelResolutionResult | undefined;
-/**
- * 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 | 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;
+import { resolveModel, resolveModelWithFallback as resolveModelWithFallbackFromCore, normalizeFallbackModels, flattenToFallbackModelStrings } from "@oh-my-opencode/model-core";
+import type { ModelResolutionInput, ExtendedModelResolutionInput } from "@oh-my-opencode/model-core";
+export { resolveModel, normalizeFallbackModels, flattenToFallbackModelStrings };
+type CoreModelResolutionResult = ReturnType<typeof resolveModelWithFallbackFromCore>;
+export type ModelResolutionResult = Exclude<CoreModelResolutionResult, undefined>;
+export type ModelSource = ModelResolutionResult["source"];
+export declare function resolveModelWithFallback(input: ExtendedModelResolutionInput): CoreModelResolutionResult;
+export type { ModelResolutionInput, ExtendedModelResolutionInput, };

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

@@ -1,3 +1 @@
-type CommandSource = "claude-code" | "opencode";
-export declare function sanitizeModelField(model: unknown, source?: CommandSource): string | undefined;
-export {};
+export { sanitizeModelField } from "@oh-my-opencode/model-core";

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

@@ -1,40 +1,2 @@
-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 {};
+export type { ModelSettingsCompatibilityInput, ModelSettingsCompatibilityChange, ModelSettingsCompatibilityResult, } from "@oh-my-opencode/model-core";
+export { resolveCompatibleModelSettings } from "@oh-my-opencode/model-core";

package/dist/shared/model-string-parser.d.ts

@@ -1,9 +1 @@
-export declare function parseVariantFromModelID(rawModelID: string): {
-    modelID: string;
-    variant?: string;
-};
-export declare function parseModelString(model: string): {
-    providerID: string;
-    modelID: string;
-    variant?: string;
-} | undefined;
+export { parseVariantFromModelID, parseModelString } from "@oh-my-opencode/model-core";

package/dist/shared/model-suggestion-retry.d.ts

@@ -1,12 +1,9 @@
 import type { createOpencodeClient } from "@opencode-ai/sdk";
+import { parseModelSuggestion as parseModelSuggestionFromCore } from "@oh-my-opencode/model-core";
 import { type PromptRetryOptions } from "./prompt-timeout-context";
 type Client = ReturnType<typeof createOpencodeClient>;
-export interface ModelSuggestionInfo {
-    providerID: string;
-    modelID: string;
-    suggestion: string;
-}
-export declare function parseModelSuggestion(error: unknown): ModelSuggestionInfo | null;
+export type { ModelSuggestionInfo } from "@oh-my-opencode/model-core";
+export { parseModelSuggestionFromCore as parseModelSuggestion };
 interface PromptBody {
     model?: {
         providerID: string;
@@ -24,4 +21,3 @@ interface PromptArgs {
 }
 export declare function promptWithModelSuggestionRetry(client: Client, args: PromptArgs, options?: PromptRetryOptions): Promise<void>;
 export declare function promptSyncWithModelSuggestionRetry(client: Client, args: PromptArgs, options?: PromptRetryOptions): Promise<void>;
-export {};

package/dist/shared/opencode-config-dir.d.ts

@@ -3,6 +3,7 @@ export type { OpenCodeBinaryType, OpenCodeConfigDirOptions, OpenCodeConfigPaths,
 export declare const TAURI_APP_IDENTIFIER = "ai.opencode.desktop";
 export declare const TAURI_APP_IDENTIFIER_DEV = "ai.opencode.desktop.dev";
 export declare function isDevBuild(version: string | null | undefined): boolean;
+export declare function getOpenCodeConfigDirs(options: OpenCodeConfigDirOptions): string[];
 export declare function getOpenCodeConfigDir(options: OpenCodeConfigDirOptions): string;
 export declare function getOpenCodeConfigPaths(options: OpenCodeConfigDirOptions): OpenCodeConfigPaths;
 export declare function detectExistingConfigDir(binary: OpenCodeBinaryType, version?: string | null): string | null;

package/dist/shared/port-utils.d.ts

@@ -1,9 +1 @@
-declare const DEFAULT_SERVER_PORT = 4096;
-export declare function isPortAvailable(port: number, hostname?: string): Promise<boolean>;
-export declare function findAvailablePort(startPort?: number, hostname?: string): Promise<number>;
-export interface AutoPortResult {
-    port: number;
-    wasAutoSelected: boolean;
-}
-export declare function getAvailableServerPort(preferredPort?: number, hostname?: string): Promise<AutoPortResult>;
-export { DEFAULT_SERVER_PORT };
+export { DEFAULT_SERVER_PORT, findAvailablePort, getAvailableServerPort, isPortAvailable, type AutoPortResult, } from "@oh-my-opencode/utils";