oh-my-opencode-gpt-slim 0.0.3

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-headers.d.ts

@@ -0,0 +1,4 @@
+import type { PluginContext } from "./types";
+export declare function createChatHeadersHandler(args: {
+    ctx: PluginContext;
+}): (input: unknown, output: unknown) => Promise<void>;

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

@@ -0,0 +1,31 @@
+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;
+};
+export type ChatMessageHandlerOutput = {
+    message: Record<string, unknown>;
+    parts: ChatMessagePart[];
+};
+export type ChatMessageInput = {
+    sessionID: string;
+    agent?: string;
+    model?: {
+        providerID: string;
+        modelID: string;
+    };
+};
+export declare function createChatMessageHandler(args: {
+    ctx: PluginContext;
+    pluginConfig: OhMyOpenCodeConfig;
+    firstMessageVariantGate: FirstMessageVariantGate;
+    hooks: CreatedHooks;
+}): (input: ChatMessageInput, output: ChatMessageHandlerOutput) => Promise<void>;
+export {};

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

@@ -0,0 +1,27 @@
+export type ChatParamsInput = {
+    sessionID: string;
+    agent: {
+        name?: string;
+    };
+    model: {
+        providerID: string;
+        modelID: string;
+    };
+    provider: {
+        id: string;
+    };
+    message: {
+        variant?: string;
+    };
+};
+export 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>;

package/dist/plugin/event.d.ts

@@ -0,0 +1,21 @@
+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;
+};
+type EventInput = Parameters<NonNullable<NonNullable<CreatedHooks["writeExistingFileGuard"]>["event"]>>[0];
+export declare function createEventHandler(args: {
+    ctx: PluginContext;
+    pluginConfig: OhMyOpenCodeConfig;
+    firstMessageVariantGate: FirstMessageVariantGate;
+    managers: Managers;
+    hooks: CreatedHooks;
+}): (input: EventInput) => Promise<void>;
+export {};

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

@@ -0,0 +1,17 @@
+import type { HookName, OhMyOpenCodeConfig } from "../../config";
+import type { BackgroundManager } from "../../features/background-agent";
+import type { PluginContext } from "../types";
+export type ContinuationHooks = Record<string, never>;
+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,23 @@
+import type { HookName, OhMyOpenCodeConfig } from "../../config";
+import type { PluginContext } from "../types";
+import type { ModelCacheState } from "../../plugin-state";
+export declare function createCoreHooks(args: {
+    ctx: PluginContext;
+    pluginConfig: OhMyOpenCodeConfig;
+    modelCacheState: ModelCacheState;
+    isHookEnabled: (hookName: HookName) => boolean;
+    safeHookEnabled: boolean;
+}): {
+    contextInjectorMessagesTransform: ReturnType<typeof import("../../features/context-injector").createContextInjectorMessagesTransformHook>;
+    toolOutputTruncator: ReturnType<typeof import("../../hooks").createToolOutputTruncatorHook> | null;
+    directoryAgentsInjector: ReturnType<typeof import("../../hooks").createDirectoryAgentsInjectorHook> | null;
+    directoryReadmeInjector: ReturnType<typeof import("../../hooks").createDirectoryReadmeInjectorHook> | null;
+    rulesInjector: ReturnType<typeof import("../../hooks").createRulesInjectorHook> | null;
+    writeExistingFileGuard: ReturnType<typeof import("../../hooks").createWriteExistingFileGuardHook> | null;
+    hashlineReadEnhancer: ReturnType<typeof import("../../hooks").createHashlineReadEnhancerHook> | null;
+    autoUpdateChecker: ReturnType<typeof import("../../hooks").createAutoUpdateCheckerHook> | null;
+    sessionRecovery: ReturnType<typeof import("../../hooks").createSessionRecoveryHook> | null;
+    modelFallback: ReturnType<typeof import("../../hooks").createModelFallbackHook> | null;
+    editErrorRecovery: ReturnType<typeof import("../../hooks").createEditErrorRecoveryHook> | null;
+    runtimeFallback: ReturnType<typeof import("../../hooks").createRuntimeFallbackHook> | null;
+};

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

@@ -0,0 +1,18 @@
+import type { OhMyOpenCodeConfig, HookName } from "../../config";
+import type { ModelCacheState } from "../../plugin-state";
+import type { PluginContext } from "../types";
+import { createAutoUpdateCheckerHook, createEditErrorRecoveryHook, createModelFallbackHook, createRuntimeFallbackHook, createSessionRecoveryHook } from "../../hooks";
+export type SessionHooks = {
+    autoUpdateChecker: ReturnType<typeof createAutoUpdateCheckerHook> | null;
+    sessionRecovery: ReturnType<typeof createSessionRecoveryHook> | null;
+    modelFallback: ReturnType<typeof createModelFallbackHook> | null;
+    editErrorRecovery: ReturnType<typeof createEditErrorRecoveryHook> | null;
+    runtimeFallback: ReturnType<typeof createRuntimeFallbackHook> | null;
+};
+export declare function createSessionHooks(args: {
+    ctx: PluginContext;
+    pluginConfig: OhMyOpenCodeConfig;
+    modelCacheState: ModelCacheState;
+    isHookEnabled: (hookName: HookName) => boolean;
+    safeHookEnabled: boolean;
+}): SessionHooks;

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

@@ -0,0 +1,13 @@
+import type { AvailableSkill } from "../../agents/dynamic-agent-prompt-builder";
+import type { HookName, OhMyOpenCodeConfig } from "../../config";
+import type { LoadedSkill } from "../../features/opencode-skill-loader/types";
+import type { PluginContext } from "../types";
+export type SkillHooks = Record<string, never>;
+export declare function createSkillHooks(_args: {
+    ctx: PluginContext;
+    pluginConfig: OhMyOpenCodeConfig;
+    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 { ModelCacheState } from "../../plugin-state";
+import type { PluginContext } from "../types";
+import { createToolOutputTruncatorHook, createDirectoryAgentsInjectorHook, createDirectoryReadmeInjectorHook, createRulesInjectorHook, createWriteExistingFileGuardHook, createHashlineReadEnhancerHook } from "../../hooks";
+export type ToolGuardHooks = {
+    toolOutputTruncator: ReturnType<typeof createToolOutputTruncatorHook> | null;
+    directoryAgentsInjector: ReturnType<typeof createDirectoryAgentsInjectorHook> | null;
+    directoryReadmeInjector: ReturnType<typeof createDirectoryReadmeInjectorHook> | null;
+    rulesInjector: ReturnType<typeof createRulesInjectorHook> | null;
+    writeExistingFileGuard: ReturnType<typeof createWriteExistingFileGuardHook> | null;
+    hashlineReadEnhancer: ReturnType<typeof createHashlineReadEnhancerHook> | null;
+};
+export declare function createToolGuardHooks(args: {
+    ctx: PluginContext;
+    pluginConfig: OhMyOpenCodeConfig;
+    modelCacheState: ModelCacheState;
+    isHookEnabled: (hookName: HookName) => boolean;
+    safeHookEnabled: boolean;
+}): ToolGuardHooks;

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

@@ -0,0 +1,12 @@
+import type { OhMyOpenCodeConfig } from "../../config";
+import type { PluginContext } from "../types";
+import { createContextInjectorMessagesTransformHook } from "../../features/context-injector";
+export type TransformHooks = {
+    contextInjectorMessagesTransform: ReturnType<typeof createContextInjectorMessagesTransformHook>;
+};
+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-agent-resolver.d.ts

@@ -0,0 +1,19 @@
+interface SessionMessage {
+    info?: {
+        agent?: string;
+        role?: string;
+    };
+}
+type SessionClient = {
+    session: {
+        messages: (opts: {
+            path: {
+                id: string;
+            };
+        }) => Promise<{
+            data?: SessionMessage[];
+        }>;
+    };
+};
+export declare function resolveSessionAgent(client: SessionClient, sessionId: string): Promise<string | undefined>;
+export {};

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/system-transform.d.ts

@@ -0,0 +1,10 @@
+export declare function createSystemTransformHandler(): (input: {
+    sessionID?: string;
+    model: {
+        id: string;
+        providerID: string;
+        [key: string]: unknown;
+    };
+}, output: {
+    system: string[];
+}) => Promise<void>;

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

@@ -0,0 +1,14 @@
+import type { CreatedHooks } from "../create-hooks";
+import type { PluginContext } from "./types";
+export declare function createToolExecuteAfterHandler(args: {
+    ctx: PluginContext;
+    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,18 @@
+import type { Plugin, ToolDefinition } from "@opencode-ai/plugin";
+export type PluginContext = Parameters<Plugin>[0];
+export type PluginInstance = Awaited<ReturnType<Plugin>>;
+type ChatHeadersHook = PluginInstance extends {
+    "chat.headers"?: infer T;
+} ? T : (input: unknown, output: unknown) => Promise<void>;
+export type PluginInterface = Omit<PluginInstance, "experimental.session.compacting" | "chat.headers"> & {
+    "chat.headers"?: ChatHeadersHook;
+};
+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;
+};
+export {};

package/dist/plugin/ultrawork-db-model-override.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Schedules a deferred SQLite update to change the message model in the DB
+ * WITHOUT triggering a Bus event. Uses microtask retry loop to wait for
+ * Session.updateMessage() to save the message first, then overwrites the model.
+ *
+ * Falls back to setTimeout(fn, 0) after 10 microtask attempts.
+ */
+export declare function scheduleDeferredModelOverride(messageId: string, targetModel: {
+    providerID: string;
+    modelID: string;
+}, variant?: string): void;

package/dist/plugin/ultrawork-model-override.d.ts

@@ -0,0 +1,37 @@
+import type { OhMyOpenCodeConfig } from "../config";
+export declare function detectUltrawork(text: string): boolean;
+export type UltraworkOverrideResult = {
+    providerID?: string;
+    modelID?: string;
+    variant?: string;
+};
+/**
+ * Resolves the ultrawork model override config for the given agent and prompt text.
+ * Returns null if no override should be applied.
+ */
+export declare function resolveUltraworkOverride(pluginConfig: OhMyOpenCodeConfig, inputAgentName: string | undefined, output: {
+    message: Record<string, unknown>;
+    parts: Array<{
+        type: string;
+        text?: string;
+        [key: string]: unknown;
+    }>;
+}, sessionID?: string): UltraworkOverrideResult | null;
+/**
+ * Applies ultrawork model override using a deferred DB update strategy.
+ *
+ * Instead of directly mutating output.message.model (which would cause the TUI
+ * bottom bar to show the override model), this schedules a queueMicrotask that
+ * updates the message model directly in SQLite AFTER Session.updateMessage()
+ * saves the original model, but BEFORE loop() reads it for the API call.
+ *
+ * Result: API call uses opus, TUI bottom bar stays on sonnet.
+ */
+export declare function applyUltraworkModelOverrideOnMessage(pluginConfig: OhMyOpenCodeConfig, inputAgentName: string | undefined, output: {
+    message: Record<string, unknown>;
+    parts: Array<{
+        type: string;
+        text?: string;
+        [key: string]: unknown;
+    }>;
+}, tui: unknown, sessionID?: string): void;

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

@@ -0,0 +1,8 @@
+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;
+}): null;

package/dist/plugin-config.d.ts

@@ -0,0 +1,5 @@
+import { type OhMyOpenCodeConfig } from "./config";
+export declare function parseConfigPartially(rawConfig: Record<string, unknown>): OhMyOpenCodeConfig | null;
+export declare function loadConfigFromPath(configPath: string, _ctx: unknown): OhMyOpenCodeConfig | null;
+export declare function mergeConfigs(base: OhMyOpenCodeConfig, override: OhMyOpenCodeConfig): OhMyOpenCodeConfig;
+export declare function loadPluginConfig(directory: string, ctx: unknown): OhMyOpenCodeConfig;

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-key-remapper.d.ts

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

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

@@ -0,0 +1,12 @@
+import type { OhMyOpenCodeConfig } from "../config";
+import type { ModelCacheState } from "../plugin-state";
+export { resolveCategoryConfig } from "./category-config-resolver";
+export interface ConfigHandlerDeps {
+    ctx: {
+        directory: string;
+        client?: any;
+    };
+    pluginConfig: OhMyOpenCodeConfig;
+    modelCacheState: ModelCacheState;
+}
+export declare function createConfigHandler(deps: ConfigHandlerDeps): (config: Record<string, unknown>) => Promise<void>;

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

@@ -0,0 +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/plan-model-inheritance.d.ts

@@ -0,0 +1 @@
+export declare function buildPlanDemoteConfig(prometheusConfig: Record<string, unknown> | undefined, planOverride: Record<string, unknown> | undefined): Record<string, unknown>;

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/plugin-state.d.ts

@@ -0,0 +1,5 @@
+export interface ModelCacheState {
+    modelContextLimitsCache: Map<string, number>;
+    anthropicContext1MEnabled: boolean;
+}
+export declare function createModelCacheState(): ModelCacheState;

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

@@ -0,0 +1,17 @@
+/**
+ * Agent config keys to display names mapping.
+ * Config keys are lowercase (e.g., "sisyphus", "atlas").
+ * Display names include suffixes for UI/logs (e.g., "Sisyphus (Ultraworker)").
+ */
+export declare const AGENT_DISPLAY_NAMES: Record<string, string>;
+/**
+ * Get display name for an agent config key.
+ * Uses case-insensitive lookup for backward compatibility.
+ * Returns original key if not found.
+ */
+export declare function getAgentDisplayName(configKey: string): string;
+/**
+ * Resolve an agent name (display name or config key) to its lowercase config key.
+ * "Atlas (Plan Executor)" → "atlas", "atlas" → "atlas", "unknown" → "unknown"
+ */
+export declare function getAgentConfigKey(agentName: string): string;

package/dist/shared/agent-tool-restrictions.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Agent tool restrictions for session.prompt calls.
+ * OpenCode SDK's session.prompt `tools` parameter expects boolean values.
+ * true = tool allowed, false = tool denied.
+ */
+export declare function getAgentToolRestrictions(agentName: string): Record<string, boolean>;
+export declare function hasAgentToolRestrictions(agentName: string): boolean;

package/dist/shared/agent-variant.d.ts

@@ -0,0 +1,9 @@
+import type { OhMyOpenCodeConfig } from "../config";
+export declare function resolveAgentVariant(config: OhMyOpenCodeConfig, agentName?: string): string | undefined;
+export declare function resolveVariantForModel(config: OhMyOpenCodeConfig, agentName: string, currentModel: {
+    providerID: string;
+    modelID: string;
+}): string | undefined;
+export declare function applyAgentVariant(config: OhMyOpenCodeConfig, agentName: string | undefined, message: {
+    variant?: string;
+}): void;

package/dist/shared/binary-downloader.d.ts

@@ -0,0 +1,10 @@
+export declare function getCachedBinaryPath(cacheDir: string, binaryName: string): string | null;
+export declare function ensureCacheDir(cacheDir: string): void;
+export declare function downloadArchive(downloadUrl: string, archivePath: string): Promise<void>;
+export declare function extractTarGz(archivePath: string, destDir: string, options?: {
+    args?: string[];
+    cwd?: string;
+}): Promise<void>;
+export declare function extractZipArchive(archivePath: string, destDir: string): Promise<void>;
+export declare function cleanupArchive(archivePath: string): void;
+export declare function ensureExecutable(binaryPath: string): void;

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

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