oh-my-opencode 3.4.0 → 3.5.0

package/dist/plugin/available-categories.d.ts

@@ -0,0 +1,3 @@
+import type { AvailableCategory } from "../agents/dynamic-agent-prompt-builder";
+import type { OhMyOpenCodeConfig } from "../config";
+export declare function createAvailableCategories(pluginConfig: OhMyOpenCodeConfig): AvailableCategory[];

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

@@ -0,0 +1,30 @@
+import type { OhMyOpenCodeConfig } from "../config";
+import type { PluginContext } from "./types";
+import type { CreatedHooks } from "../create-hooks";
+type FirstMessageVariantGate = {
+    shouldOverride: (sessionID: string) => boolean;
+    markApplied: (sessionID: string) => void;
+};
+type ChatMessagePart = {
+    type: string;
+    text?: string;
+    [key: string]: unknown;
+};
+type ChatMessageHandlerOutput = {
+    message: Record<string, unknown>;
+    parts: ChatMessagePart[];
+};
+export declare function createChatMessageHandler(args: {
+    ctx: PluginContext;
+    pluginConfig: OhMyOpenCodeConfig;
+    firstMessageVariantGate: FirstMessageVariantGate;
+    hooks: CreatedHooks;
+}): (input: {
+    sessionID: string;
+    agent?: string;
+    model?: {
+        providerID: string;
+        modelID: string;
+    };
+}, output: ChatMessageHandlerOutput) => Promise<void>;
+export {};

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

@@ -0,0 +1,28 @@
+type ChatParamsInput = {
+    sessionID: string;
+    agent: {
+        name?: string;
+    };
+    model: {
+        providerID: string;
+        modelID: string;
+    };
+    provider: {
+        id: string;
+    };
+    message: {
+        variant?: string;
+    };
+};
+type ChatParamsOutput = {
+    temperature?: number;
+    topP?: number;
+    topK?: number;
+    options: Record<string, unknown>;
+};
+export declare function createChatParamsHandler(args: {
+    anthropicEffort: {
+        "chat.params"?: (input: ChatParamsInput, output: ChatParamsOutput) => Promise<void>;
+    } | null;
+}): (input: unknown, output: unknown) => Promise<void>;
+export {};

package/dist/plugin/event.d.ts

@@ -0,0 +1,25 @@
+import type { OhMyOpenCodeConfig } from "../config";
+import type { PluginContext } from "./types";
+import type { CreatedHooks } from "../create-hooks";
+import type { Managers } from "../create-managers";
+type FirstMessageVariantGate = {
+    markSessionCreated: (sessionInfo: {
+        id?: string;
+        title?: string;
+        parentID?: string;
+    } | undefined) => void;
+    clear: (sessionID: string) => void;
+};
+export declare function createEventHandler(args: {
+    ctx: PluginContext;
+    pluginConfig: OhMyOpenCodeConfig;
+    firstMessageVariantGate: FirstMessageVariantGate;
+    managers: Managers;
+    hooks: CreatedHooks;
+}): (input: {
+    event: {
+        type: string;
+        properties?: Record<string, unknown>;
+    };
+}) => Promise<void>;
+export {};

package/dist/plugin/hooks/create-continuation-hooks.d.ts

@@ -0,0 +1,27 @@
+import type { HookName, OhMyOpenCodeConfig } from "../../config";
+import type { BackgroundManager } from "../../features/background-agent";
+import type { PluginContext } from "../types";
+import { createTodoContinuationEnforcer, createBackgroundNotificationHook, createStopContinuationGuardHook, createCompactionContextInjector, createCompactionTodoPreserverHook, createAtlasHook } from "../../hooks";
+import { createUnstableAgentBabysitter } from "../unstable-agent-babysitter";
+export type ContinuationHooks = {
+    stopContinuationGuard: ReturnType<typeof createStopContinuationGuardHook> | null;
+    compactionContextInjector: ReturnType<typeof createCompactionContextInjector> | null;
+    compactionTodoPreserver: ReturnType<typeof createCompactionTodoPreserverHook> | null;
+    todoContinuationEnforcer: ReturnType<typeof createTodoContinuationEnforcer> | null;
+    unstableAgentBabysitter: ReturnType<typeof createUnstableAgentBabysitter> | null;
+    backgroundNotificationHook: ReturnType<typeof createBackgroundNotificationHook> | null;
+    atlasHook: ReturnType<typeof createAtlasHook> | null;
+};
+type SessionRecovery = {
+    setOnAbortCallback: (callback: (sessionID: string) => void) => void;
+    setOnRecoveryCompleteCallback: (callback: (sessionID: string) => void) => void;
+} | null;
+export declare function createContinuationHooks(args: {
+    ctx: PluginContext;
+    pluginConfig: OhMyOpenCodeConfig;
+    isHookEnabled: (hookName: HookName) => boolean;
+    safeHookEnabled: boolean;
+    backgroundManager: BackgroundManager;
+    sessionRecovery: SessionRecovery;
+}): ContinuationHooks;
+export {};

package/dist/plugin/hooks/create-core-hooks.d.ts

@@ -0,0 +1,41 @@
+import type { HookName, OhMyOpenCodeConfig } from "../../config";
+import type { PluginContext } from "../types";
+export declare function createCoreHooks(args: {
+    ctx: PluginContext;
+    pluginConfig: OhMyOpenCodeConfig;
+    isHookEnabled: (hookName: HookName) => boolean;
+    safeHookEnabled: boolean;
+}): {
+    claudeCodeHooks: ReturnType<typeof import("../../hooks").createClaudeCodeHooksHook>;
+    keywordDetector: ReturnType<typeof import("../../hooks").createKeywordDetectorHook> | null;
+    contextInjectorMessagesTransform: ReturnType<typeof import("../../features/context-injector").createContextInjectorMessagesTransformHook>;
+    thinkingBlockValidator: ReturnType<typeof import("../../hooks").createThinkingBlockValidatorHook> | null;
+    commentChecker: ReturnType<typeof import("../../hooks").createCommentCheckerHooks> | null;
+    toolOutputTruncator: ReturnType<typeof import("../../hooks").createToolOutputTruncatorHook> | null;
+    directoryAgentsInjector: ReturnType<typeof import("../../hooks").createDirectoryAgentsInjectorHook> | null;
+    directoryReadmeInjector: ReturnType<typeof import("../../hooks").createDirectoryReadmeInjectorHook> | null;
+    emptyTaskResponseDetector: ReturnType<typeof import("../../hooks").createEmptyTaskResponseDetectorHook> | null;
+    rulesInjector: ReturnType<typeof import("../../hooks").createRulesInjectorHook> | null;
+    tasksTodowriteDisabler: ReturnType<typeof import("../../hooks").createTasksTodowriteDisablerHook> | null;
+    writeExistingFileGuard: ReturnType<typeof import("../../hooks").createWriteExistingFileGuardHook> | null;
+    contextWindowMonitor: ReturnType<typeof import("../../hooks").createContextWindowMonitorHook> | null;
+    preemptiveCompaction: ReturnType<typeof import("../../hooks").createPreemptiveCompactionHook> | null;
+    sessionRecovery: ReturnType<typeof import("../../hooks").createSessionRecoveryHook> | null;
+    sessionNotification: ReturnType<typeof import("../../hooks").createSessionNotification> | null;
+    thinkMode: ReturnType<typeof import("../../hooks").createThinkModeHook> | null;
+    anthropicContextWindowLimitRecovery: ReturnType<typeof import("../../hooks").createAnthropicContextWindowLimitRecoveryHook> | null;
+    autoUpdateChecker: ReturnType<typeof import("../../hooks").createAutoUpdateCheckerHook> | null;
+    agentUsageReminder: ReturnType<typeof import("../../hooks").createAgentUsageReminderHook> | null;
+    nonInteractiveEnv: ReturnType<typeof import("../../hooks").createNonInteractiveEnvHook> | null;
+    interactiveBashSession: ReturnType<typeof import("../../hooks").createInteractiveBashSessionHook> | null;
+    ralphLoop: ReturnType<typeof import("../../hooks").createRalphLoopHook> | null;
+    editErrorRecovery: ReturnType<typeof import("../../hooks").createEditErrorRecoveryHook> | null;
+    delegateTaskRetry: ReturnType<typeof import("../../hooks").createDelegateTaskRetryHook> | null;
+    startWork: ReturnType<typeof import("../../hooks").createStartWorkHook> | null;
+    prometheusMdOnly: ReturnType<typeof import("../../hooks").createPrometheusMdOnlyHook> | null;
+    sisyphusJuniorNotepad: ReturnType<typeof import("../../hooks").createSisyphusJuniorNotepadHook> | null;
+    questionLabelTruncator: ReturnType<typeof import("../../hooks").createQuestionLabelTruncatorHook>;
+    subagentQuestionBlocker: ReturnType<typeof import("../../hooks").createSubagentQuestionBlockerHook>;
+    taskResumeInfo: ReturnType<typeof import("../../hooks").createTaskResumeInfoHook>;
+    anthropicEffort: ReturnType<typeof import("../../hooks/anthropic-effort").createAnthropicEffortHook> | null;
+};

package/dist/plugin/hooks/create-session-hooks.d.ts

@@ -0,0 +1,32 @@
+import type { OhMyOpenCodeConfig, HookName } from "../../config";
+import type { PluginContext } from "../types";
+import { createContextWindowMonitorHook, createSessionRecoveryHook, createSessionNotification, createThinkModeHook, createAnthropicContextWindowLimitRecoveryHook, createAutoUpdateCheckerHook, createAgentUsageReminderHook, createNonInteractiveEnvHook, createInteractiveBashSessionHook, createRalphLoopHook, createEditErrorRecoveryHook, createDelegateTaskRetryHook, createTaskResumeInfoHook, createStartWorkHook, createPrometheusMdOnlyHook, createSisyphusJuniorNotepadHook, createQuestionLabelTruncatorHook, createSubagentQuestionBlockerHook, createPreemptiveCompactionHook } from "../../hooks";
+import { createAnthropicEffortHook } from "../../hooks/anthropic-effort";
+export type SessionHooks = {
+    contextWindowMonitor: ReturnType<typeof createContextWindowMonitorHook> | null;
+    preemptiveCompaction: ReturnType<typeof createPreemptiveCompactionHook> | null;
+    sessionRecovery: ReturnType<typeof createSessionRecoveryHook> | null;
+    sessionNotification: ReturnType<typeof createSessionNotification> | null;
+    thinkMode: ReturnType<typeof createThinkModeHook> | null;
+    anthropicContextWindowLimitRecovery: ReturnType<typeof createAnthropicContextWindowLimitRecoveryHook> | null;
+    autoUpdateChecker: ReturnType<typeof createAutoUpdateCheckerHook> | null;
+    agentUsageReminder: ReturnType<typeof createAgentUsageReminderHook> | null;
+    nonInteractiveEnv: ReturnType<typeof createNonInteractiveEnvHook> | null;
+    interactiveBashSession: ReturnType<typeof createInteractiveBashSessionHook> | null;
+    ralphLoop: ReturnType<typeof createRalphLoopHook> | null;
+    editErrorRecovery: ReturnType<typeof createEditErrorRecoveryHook> | null;
+    delegateTaskRetry: ReturnType<typeof createDelegateTaskRetryHook> | null;
+    startWork: ReturnType<typeof createStartWorkHook> | null;
+    prometheusMdOnly: ReturnType<typeof createPrometheusMdOnlyHook> | null;
+    sisyphusJuniorNotepad: ReturnType<typeof createSisyphusJuniorNotepadHook> | null;
+    questionLabelTruncator: ReturnType<typeof createQuestionLabelTruncatorHook>;
+    subagentQuestionBlocker: ReturnType<typeof createSubagentQuestionBlockerHook>;
+    taskResumeInfo: ReturnType<typeof createTaskResumeInfoHook>;
+    anthropicEffort: ReturnType<typeof createAnthropicEffortHook> | null;
+};
+export declare function createSessionHooks(args: {
+    ctx: PluginContext;
+    pluginConfig: OhMyOpenCodeConfig;
+    isHookEnabled: (hookName: HookName) => boolean;
+    safeHookEnabled: boolean;
+}): SessionHooks;

package/dist/plugin/hooks/create-skill-hooks.d.ts

@@ -0,0 +1,16 @@
+import type { AvailableSkill } from "../../agents/dynamic-agent-prompt-builder";
+import type { HookName } from "../../config";
+import type { LoadedSkill } from "../../features/opencode-skill-loader/types";
+import type { PluginContext } from "../types";
+import { createAutoSlashCommandHook, createCategorySkillReminderHook } from "../../hooks";
+export type SkillHooks = {
+    categorySkillReminder: ReturnType<typeof createCategorySkillReminderHook> | null;
+    autoSlashCommand: ReturnType<typeof createAutoSlashCommandHook> | null;
+};
+export declare function createSkillHooks(args: {
+    ctx: PluginContext;
+    isHookEnabled: (hookName: HookName) => boolean;
+    safeHookEnabled: boolean;
+    mergedSkills: LoadedSkill[];
+    availableSkills: AvailableSkill[];
+}): SkillHooks;

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

@@ -0,0 +1,19 @@
+import type { HookName, OhMyOpenCodeConfig } from "../../config";
+import type { PluginContext } from "../types";
+import { createCommentCheckerHooks, createToolOutputTruncatorHook, createDirectoryAgentsInjectorHook, createDirectoryReadmeInjectorHook, createEmptyTaskResponseDetectorHook, createRulesInjectorHook, createTasksTodowriteDisablerHook, createWriteExistingFileGuardHook } from "../../hooks";
+export type ToolGuardHooks = {
+    commentChecker: ReturnType<typeof createCommentCheckerHooks> | null;
+    toolOutputTruncator: ReturnType<typeof createToolOutputTruncatorHook> | null;
+    directoryAgentsInjector: ReturnType<typeof createDirectoryAgentsInjectorHook> | null;
+    directoryReadmeInjector: ReturnType<typeof createDirectoryReadmeInjectorHook> | null;
+    emptyTaskResponseDetector: ReturnType<typeof createEmptyTaskResponseDetectorHook> | null;
+    rulesInjector: ReturnType<typeof createRulesInjectorHook> | null;
+    tasksTodowriteDisabler: ReturnType<typeof createTasksTodowriteDisablerHook> | null;
+    writeExistingFileGuard: ReturnType<typeof createWriteExistingFileGuardHook> | null;
+};
+export declare function createToolGuardHooks(args: {
+    ctx: PluginContext;
+    pluginConfig: OhMyOpenCodeConfig;
+    isHookEnabled: (hookName: HookName) => boolean;
+    safeHookEnabled: boolean;
+}): ToolGuardHooks;

package/dist/plugin/hooks/create-transform-hooks.d.ts

@@ -0,0 +1,16 @@
+import type { OhMyOpenCodeConfig } from "../../config";
+import type { PluginContext } from "../types";
+import { createClaudeCodeHooksHook, createKeywordDetectorHook, createThinkingBlockValidatorHook } from "../../hooks";
+import { createContextInjectorMessagesTransformHook } from "../../features/context-injector";
+export type TransformHooks = {
+    claudeCodeHooks: ReturnType<typeof createClaudeCodeHooksHook>;
+    keywordDetector: ReturnType<typeof createKeywordDetectorHook> | null;
+    contextInjectorMessagesTransform: ReturnType<typeof createContextInjectorMessagesTransformHook>;
+    thinkingBlockValidator: ReturnType<typeof createThinkingBlockValidatorHook> | null;
+};
+export declare function createTransformHooks(args: {
+    ctx: PluginContext;
+    pluginConfig: OhMyOpenCodeConfig;
+    isHookEnabled: (hookName: string) => boolean;
+    safeHookEnabled?: boolean;
+}): TransformHooks;

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

@@ -0,0 +1,13 @@
+import type { Message, Part } from "@opencode-ai/sdk";
+import type { CreatedHooks } from "../create-hooks";
+type MessageWithParts = {
+    info: Message;
+    parts: Part[];
+};
+type MessagesTransformOutput = {
+    messages: MessageWithParts[];
+};
+export declare function createMessagesTransformHandler(args: {
+    hooks: CreatedHooks;
+}): (input: Record<string, never>, output: MessagesTransformOutput) => Promise<void>;
+export {};

package/dist/plugin/recent-synthetic-idles.d.ts

@@ -0,0 +1,6 @@
+export declare function pruneRecentSyntheticIdles(args: {
+    recentSyntheticIdles: Map<string, number>;
+    recentRealIdles: Map<string, number>;
+    now: number;
+    dedupWindowMs: number;
+}): void;

package/dist/plugin/session-status-normalizer.d.ts

@@ -0,0 +1,8 @@
+type EventInput = {
+    event: {
+        type: string;
+        properties?: Record<string, unknown>;
+    };
+};
+export declare function normalizeSessionStatusToIdle(input: EventInput): EventInput | null;
+export {};

package/dist/plugin/skill-context.d.ts

@@ -0,0 +1,14 @@
+import type { AvailableSkill } from "../agents/dynamic-agent-prompt-builder";
+import type { OhMyOpenCodeConfig } from "../config";
+import type { BrowserAutomationProvider } from "../config/schema/browser-automation";
+import type { LoadedSkill } from "../features/opencode-skill-loader/types";
+export type SkillContext = {
+    mergedSkills: LoadedSkill[];
+    availableSkills: AvailableSkill[];
+    browserProvider: BrowserAutomationProvider;
+    disabledSkills: Set<string>;
+};
+export declare function createSkillContext(args: {
+    directory: string;
+    pluginConfig: OhMyOpenCodeConfig;
+}): Promise<SkillContext>;

package/dist/plugin/tool-execute-after.d.ts

@@ -0,0 +1,12 @@
+import type { CreatedHooks } from "../create-hooks";
+export declare function createToolExecuteAfterHandler(args: {
+    hooks: CreatedHooks;
+}): (input: {
+    tool: string;
+    sessionID: string;
+    callID: string;
+}, output: {
+    title: string;
+    output: string;
+    metadata: Record<string, unknown>;
+} | undefined) => Promise<void>;

package/dist/plugin/tool-execute-before.d.ts

@@ -0,0 +1,12 @@
+import type { PluginContext } from "./types";
+import type { CreatedHooks } from "../create-hooks";
+export declare function createToolExecuteBeforeHandler(args: {
+    ctx: PluginContext;
+    hooks: CreatedHooks;
+}): (input: {
+    tool: string;
+    sessionID: string;
+    callID: string;
+}, output: {
+    args: Record<string, unknown>;
+}) => Promise<void>;

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

@@ -0,0 +1,16 @@
+import type { AvailableCategory } from "../agents/dynamic-agent-prompt-builder";
+import type { OhMyOpenCodeConfig } from "../config";
+import type { PluginContext, ToolsRecord } from "./types";
+import type { Managers } from "../create-managers";
+import type { SkillContext } from "./skill-context";
+export type ToolRegistryResult = {
+    filteredTools: ToolsRecord;
+    taskSystemEnabled: boolean;
+};
+export declare function createToolRegistry(args: {
+    ctx: PluginContext;
+    pluginConfig: OhMyOpenCodeConfig;
+    managers: Pick<Managers, "backgroundManager" | "tmuxSessionManager" | "skillMcpManager">;
+    skillContext: SkillContext;
+    availableCategories: AvailableCategory[];
+}): ToolRegistryResult;

package/dist/plugin/types.d.ts

@@ -0,0 +1,12 @@
+import type { Plugin, ToolDefinition } from "@opencode-ai/plugin";
+export type PluginContext = Parameters<Plugin>[0];
+export type PluginInstance = Awaited<ReturnType<Plugin>>;
+export type PluginInterface = Omit<PluginInstance, "experimental.session.compacting">;
+export type ToolsRecord = Record<string, ToolDefinition>;
+export type TmuxConfig = {
+    enabled: boolean;
+    layout: "main-horizontal" | "main-vertical" | "tiled" | "even-horizontal" | "even-vertical";
+    main_pane_size: number;
+    main_pane_min_width: number;
+    agent_pane_min_width: number;
+};

package/dist/plugin/unstable-agent-babysitter.d.ts

@@ -0,0 +1,15 @@
+import type { OhMyOpenCodeConfig } from "../config";
+import type { PluginContext } from "./types";
+import type { BackgroundManager } from "../features/background-agent";
+export declare function createUnstableAgentBabysitter(args: {
+    ctx: PluginContext;
+    backgroundManager: BackgroundManager;
+    pluginConfig: OhMyOpenCodeConfig;
+}): {
+    event: ({ event }: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => Promise<void>;
+};

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

@@ -0,0 +1,11 @@
+import type { OhMyOpenCodeConfig } from "../config";
+import type { PluginComponents } from "./plugin-components-loader";
+export declare function applyAgentConfig(params: {
+    config: Record<string, unknown>;
+    pluginConfig: OhMyOpenCodeConfig;
+    ctx: {
+        directory: string;
+        client?: any;
+    };
+    pluginComponents: PluginComponents;
+}): Promise<Record<string, unknown>>;

package/dist/plugin-handlers/agent-priority-order.d.ts

@@ -0,0 +1 @@
+export declare function reorderAgentsByPriority(agents: Record<string, unknown>): Record<string, unknown>;

package/dist/plugin-handlers/category-config-resolver.d.ts

@@ -0,0 +1,2 @@
+import type { CategoryConfig } from "../config/schema";
+export declare function resolveCategoryConfig(categoryName: string, userCategories?: Record<string, CategoryConfig>): CategoryConfig | undefined;

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

@@ -0,0 +1,7 @@
+import type { OhMyOpenCodeConfig } from "../config";
+import type { PluginComponents } from "./plugin-components-loader";
+export declare function applyCommandConfig(params: {
+    config: Record<string, unknown>;
+    pluginConfig: OhMyOpenCodeConfig;
+    pluginComponents: PluginComponents;
+}): Promise<void>;

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

@@ -1,6 +1,6 @@
 import type { OhMyOpenCodeConfig } from "../config";
 import type { ModelCacheState } from "../plugin-state";
-import type { CategoryConfig } from "../config/schema";
+export { resolveCategoryConfig } from "./category-config-resolver";
 export interface ConfigHandlerDeps {
     ctx: {
         directory: string;
@@ -9,5 +9,4 @@ export interface ConfigHandlerDeps {
     pluginConfig: OhMyOpenCodeConfig;
     modelCacheState: ModelCacheState;
 }
-export declare function resolveCategoryConfig(categoryName: string, userCategories?: Record<string, CategoryConfig>): CategoryConfig | undefined;
 export declare function createConfigHandler(deps: ConfigHandlerDeps): (config: Record<string, unknown>) => Promise<void>;

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

@@ -1 +1,10 @@
 export { createConfigHandler, type ConfigHandlerDeps } from "./config-handler";
+export * from "./provider-config-handler";
+export * from "./agent-config-handler";
+export * from "./tool-config-handler";
+export * from "./mcp-config-handler";
+export * from "./command-config-handler";
+export * from "./plugin-components-loader";
+export * from "./category-config-resolver";
+export * from "./prometheus-agent-config-builder";
+export * from "./agent-priority-order";

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

@@ -0,0 +1,7 @@
+import type { OhMyOpenCodeConfig } from "../config";
+import type { PluginComponents } from "./plugin-components-loader";
+export declare function applyMcpConfig(params: {
+    config: Record<string, unknown>;
+    pluginConfig: OhMyOpenCodeConfig;
+    pluginComponents: PluginComponents;
+}): Promise<void>;

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

@@ -0,0 +1,22 @@
+import type { OhMyOpenCodeConfig } from "../config";
+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>;
+    }>;
+    plugins: Array<{
+        name: string;
+        version: string;
+    }>;
+    errors: Array<{
+        pluginKey: string;
+        installPath: string;
+        error: string;
+    }>;
+};
+export declare function loadPluginComponents(params: {
+    pluginConfig: OhMyOpenCodeConfig;
+}): Promise<PluginComponents>;

package/dist/plugin-handlers/prometheus-agent-config-builder.d.ts

@@ -0,0 +1,23 @@
+import type { CategoryConfig } from "../config/schema";
+type PrometheusOverride = Record<string, unknown> & {
+    category?: string;
+    model?: string;
+    variant?: string;
+    reasoningEffort?: string;
+    textVerbosity?: string;
+    thinking?: {
+        type: string;
+        budgetTokens?: number;
+    };
+    temperature?: number;
+    top_p?: number;
+    maxTokens?: number;
+    prompt_append?: string;
+};
+export declare function buildPrometheusAgentConfig(params: {
+    configAgentPlan: Record<string, unknown> | undefined;
+    pluginPrometheusOverride: PrometheusOverride | undefined;
+    userCategories: Record<string, CategoryConfig> | undefined;
+    currentModel: string | undefined;
+}): Promise<Record<string, unknown>>;
+export {};

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

@@ -0,0 +1,5 @@
+import type { ModelCacheState } from "../plugin-state";
+export declare function applyProviderConfig(params: {
+    config: Record<string, unknown>;
+    modelCacheState: ModelCacheState;
+}): void;

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

@@ -0,0 +1,6 @@
+import type { OhMyOpenCodeConfig } from "../config";
+export declare function applyToolConfig(params: {
+    config: Record<string, unknown>;
+    pluginConfig: OhMyOpenCodeConfig;
+    agentResult: Record<string, unknown>;
+}): void;

package/dist/plugin-interface.d.ts

@@ -0,0 +1,21 @@
+import type { PluginContext, PluginInterface, ToolsRecord } from "./plugin/types";
+import type { OhMyOpenCodeConfig } from "./config";
+import type { CreatedHooks } from "./create-hooks";
+import type { Managers } from "./create-managers";
+export declare function createPluginInterface(args: {
+    ctx: PluginContext;
+    pluginConfig: OhMyOpenCodeConfig;
+    firstMessageVariantGate: {
+        shouldOverride: (sessionID: string) => boolean;
+        markApplied: (sessionID: string) => void;
+        markSessionCreated: (sessionInfo: {
+            id?: string;
+            title?: string;
+            parentID?: string;
+        } | undefined) => void;
+        clear: (sessionID: string) => void;
+    };
+    managers: Managers;
+    hooks: CreatedHooks;
+    tools: ToolsRecord;
+}): PluginInterface;

package/dist/shared/available-models-fetcher.d.ts

@@ -0,0 +1,4 @@
+export declare function getConnectedProviders(client: unknown): Promise<string[]>;
+export declare function fetchAvailableModels(client?: unknown, options?: {
+    connectedProviders?: string[] | null;
+}): Promise<Set<string>>;

package/dist/shared/command-executor/embedded-commands.d.ts

@@ -0,0 +1,7 @@
+export interface CommandMatch {
+    fullMatch: string;
+    command: string;
+    start: number;
+    end: number;
+}
+export declare function findEmbeddedCommands(text: string): CommandMatch[];

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

@@ -0,0 +1 @@
+export declare function executeCommand(command: string): Promise<string>;

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

@@ -0,0 +1,10 @@
+export interface CommandResult {
+    exitCode: number;
+    stdout?: string;
+    stderr?: string;
+}
+export interface ExecuteHookOptions {
+    forceZsh?: boolean;
+    zshPath?: string;
+}
+export declare function executeHookCommand(command: string, stdin: string, cwd: string, options?: ExecuteHookOptions): Promise<CommandResult>;

package/dist/shared/command-executor/home-directory.d.ts

@@ -0,0 +1 @@
+export declare function getHomeDirectory(): string;

package/dist/shared/command-executor/resolve-commands-in-text.d.ts

@@ -0,0 +1 @@
+export declare function resolveCommandsInText(text: string, depth?: number, maxDepth?: number): Promise<string>;

package/dist/shared/command-executor/shell-path.d.ts

@@ -0,0 +1,2 @@
+export declare function findZshPath(customZshPath?: string): string | null;
+export declare function findBashPath(): string | null;

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

@@ -1,21 +1,4 @@
-export interface CommandResult {
-    exitCode: number;
-    stdout?: string;
-    stderr?: string;
-}
-export interface ExecuteHookOptions {
-    forceZsh?: boolean;
-    zshPath?: string;
-}
-/**
- * Execute a hook command with stdin input
- */
-export declare function executeHookCommand(command: string, stdin: string, cwd: string, options?: ExecuteHookOptions): Promise<CommandResult>;
-/**
- * Execute a simple command and return output
- */
-export declare function executeCommand(command: string): Promise<string>;
-/**
- * Resolve embedded commands in text recursively
- */
-export declare function resolveCommandsInText(text: string, depth?: number, maxDepth?: number): Promise<string>;
+export { executeHookCommand } from "./command-executor/execute-hook-command";
+export type { CommandResult, ExecuteHookOptions } from "./command-executor/execute-hook-command";
+export { executeCommand } from "./command-executor/execute-command";
+export { resolveCommandsInText } from "./command-executor/resolve-commands-in-text";

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

@@ -44,16 +44,12 @@ export declare function updateConnectedProvidersCache(client: {
         list?: () => Promise<{
             data?: {
                 connected?: string[];
+                all?: Array<{
+                    id: string;
+                    models?: Record<string, unknown>;
+                }>;
             };
         }>;
     };
-    model?: {
-        list?: () => Promise<{
-            data?: Array<{
-                id: string;
-                provider: string;
-            }>;
-        }>;
-    };
 }): Promise<void>;
 export {};

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

@@ -0,0 +1,5 @@
+export declare function isAnyFallbackModelAvailable(fallbackChain: Array<{
+    providers: string[];
+    model: string;
+}>, availableModels: Set<string>): boolean;
+export declare function isAnyProviderConnected(providers: string[], availableModels: Set<string>): boolean;