@heidi-dang/oh-my-opencode 3.10.0

package/dist/hooks/ralph-loop/storage.d.ts

@@ -0,0 +1,6 @@
+import type { RalphLoopState } from "./types";
+export declare function getStateFilePath(directory: string, customPath?: string): string;
+export declare function readState(directory: string, customPath?: string): RalphLoopState | null;
+export declare function writeState(directory: string, state: RalphLoopState, customPath?: string): boolean;
+export declare function clearState(directory: string, customPath?: string): boolean;
+export declare function incrementIteration(directory: string, customPath?: string): RalphLoopState | null;

package/dist/hooks/ralph-loop/types.d.ts

@@ -0,0 +1,19 @@
+import type { RalphLoopConfig } from "../../config";
+export interface RalphLoopState {
+    active: boolean;
+    iteration: number;
+    max_iterations: number;
+    message_count_at_start?: number;
+    completion_promise: string;
+    started_at: string;
+    prompt: string;
+    session_id?: string;
+    ultrawork?: boolean;
+    strategy?: "reset" | "continue";
+}
+export interface RalphLoopOptions {
+    config?: RalphLoopConfig;
+    getTranscriptPath?: (sessionId: string) => string;
+    apiTimeout?: number;
+    checkSessionExists?: (sessionId: string) => Promise<boolean>;
+}

package/dist/hooks/ralph-loop/with-timeout.d.ts

@@ -0,0 +1 @@
+export declare function withTimeout<TData>(promise: Promise<TData>, timeoutMs: number): Promise<TData>;

package/dist/hooks/read-image-resizer/hook.d.ts

@@ -0,0 +1,12 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export declare function createReadImageResizerHook(_ctx: PluginInput): {
+    "tool.execute.after": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        title: string;
+        output: string;
+        metadata: unknown;
+    }) => Promise<void>;
+};

package/dist/hooks/read-image-resizer/image-dimensions.d.ts

@@ -0,0 +1,2 @@
+import type { ImageDimensions } from "./types";
+export declare function parseImageDimensions(base64DataUrl: string, mimeType: string): ImageDimensions | null;

package/dist/hooks/read-image-resizer/image-resizer.d.ts

@@ -0,0 +1,3 @@
+import type { ImageDimensions, ResizeResult } from "./types";
+export declare function calculateTargetDimensions(width: number, height: number, maxLongEdge?: number): ImageDimensions | null;
+export declare function resizeImage(base64DataUrl: string, mimeType: string, target: ImageDimensions): Promise<ResizeResult | null>;

package/dist/hooks/read-image-resizer/index.d.ts

@@ -0,0 +1 @@
+export { createReadImageResizerHook } from "./hook";

package/dist/hooks/read-image-resizer/types.d.ts

@@ -0,0 +1,14 @@
+export interface ImageDimensions {
+    width: number;
+    height: number;
+}
+export interface ImageAttachment {
+    mime: string;
+    url: string;
+    filename?: string;
+}
+export interface ResizeResult {
+    resizedDataUrl: string;
+    original: ImageDimensions;
+    resized: ImageDimensions;
+}

package/dist/hooks/rules-injector/cache.d.ts

@@ -0,0 +1,8 @@
+export type SessionInjectedRulesCache = {
+    contentHashes: Set<string>;
+    realPaths: Set<string>;
+};
+export declare function createSessionCacheStore(): {
+    getSessionCache: (sessionID: string) => SessionInjectedRulesCache;
+    clearSessionCache: (sessionID: string) => void;
+};

package/dist/hooks/rules-injector/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const RULES_INJECTOR_STORAGE: string;
+export declare const PROJECT_MARKERS: string[];
+export declare const PROJECT_RULE_SUBDIRS: [string, string][];
+export declare const PROJECT_RULE_FILES: string[];
+export declare const GITHUB_INSTRUCTIONS_PATTERN: RegExp;
+export declare const USER_RULE_DIR = ".claude/rules";
+export declare const RULE_EXTENSIONS: string[];

package/dist/hooks/rules-injector/finder.d.ts

@@ -0,0 +1,3 @@
+export { findProjectRoot } from "./project-root-finder";
+export { calculateDistance } from "./rule-distance";
+export { findRuleFiles } from "./rule-file-finder";

package/dist/hooks/rules-injector/hook.d.ts

@@ -0,0 +1,28 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+interface ToolExecuteInput {
+    tool: string;
+    sessionID: string;
+    callID: string;
+}
+interface ToolExecuteOutput {
+    title: string;
+    output: string;
+    metadata: unknown;
+}
+interface ToolExecuteBeforeOutput {
+    args: unknown;
+}
+interface EventInput {
+    event: {
+        type: string;
+        properties?: unknown;
+    };
+}
+export declare function createRulesInjectorHook(ctx: PluginInput, modelCacheState?: {
+    anthropicContext1MEnabled: boolean;
+}): {
+    "tool.execute.before": (input: ToolExecuteInput, output: ToolExecuteBeforeOutput) => Promise<void>;
+    "tool.execute.after": (input: ToolExecuteInput, output: ToolExecuteOutput) => Promise<void>;
+    event: ({ event }: EventInput) => Promise<void>;
+};
+export {};

package/dist/hooks/rules-injector/index.d.ts

@@ -0,0 +1,2 @@
+export { createRulesInjectorHook } from "./hook";
+export { calculateDistance, findProjectRoot, findRuleFiles } from "./finder";

package/dist/hooks/rules-injector/injector.d.ts

@@ -0,0 +1,20 @@
+import type { SessionInjectedRulesCache } from "./cache";
+type ToolExecuteOutput = {
+    title: string;
+    output: string;
+    metadata: unknown;
+};
+type DynamicTruncator = {
+    truncate: (sessionID: string, content: string) => Promise<{
+        result: string;
+        truncated: boolean;
+    }>;
+};
+export declare function createRuleInjectionProcessor(deps: {
+    workspaceDirectory: string;
+    truncator: DynamicTruncator;
+    getSessionCache: (sessionID: string) => SessionInjectedRulesCache;
+}): {
+    processFilePathForInjection: (filePath: string, sessionID: string, output: ToolExecuteOutput) => Promise<void>;
+};
+export {};

package/dist/hooks/rules-injector/matcher.d.ts

@@ -0,0 +1,21 @@
+import type { RuleMetadata } from "./types";
+export interface MatchResult {
+    applies: boolean;
+    reason?: string;
+}
+/**
+ * Check if a rule should apply to the current file based on metadata
+ */
+export declare function shouldApplyRule(metadata: RuleMetadata, currentFilePath: string, projectRoot: string | null): MatchResult;
+/**
+ * Check if realPath already exists in cache (symlink deduplication)
+ */
+export declare function isDuplicateByRealPath(realPath: string, cache: Set<string>): boolean;
+/**
+ * Create SHA-256 hash of content, truncated to 16 chars
+ */
+export declare function createContentHash(content: string): string;
+/**
+ * Check if content hash already exists in cache
+ */
+export declare function isDuplicateByContentHash(hash: string, cache: Set<string>): boolean;

package/dist/hooks/rules-injector/output-path.d.ts

@@ -0,0 +1,5 @@
+export interface ToolExecuteOutputShape {
+    title: string;
+    metadata: unknown;
+}
+export declare function getRuleInjectionFilePath(output: ToolExecuteOutputShape): string | null;

package/dist/hooks/rules-injector/parser.d.ts

@@ -0,0 +1,18 @@
+import type { RuleMetadata } from "./types";
+export interface RuleFrontmatterResult {
+    metadata: RuleMetadata;
+    body: string;
+}
+/**
+ * Parse YAML frontmatter from rule file content
+ * Supports:
+ * - Single string: globs: "**\/*.py"
+ * - Inline array: globs: ["**\/*.py", "src/**\/*.ts"]
+ * - Multi-line array:
+ *   globs:
+ *     - "**\/*.py"
+ *     - "src/**\/*.ts"
+ * - Comma-separated: globs: "**\/*.py, src/**\/*.ts"
+ * - Claude Code 'paths' field (alias for globs)
+ */
+export declare function parseRuleFrontmatter(content: string): RuleFrontmatterResult;

package/dist/hooks/rules-injector/project-root-finder.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Find project root by walking up from startPath.
+ * Checks for PROJECT_MARKERS (.git, pyproject.toml, package.json, etc.)
+ *
+ * @param startPath - Starting path to search from (file or directory)
+ * @returns Project root path or null if not found
+ */
+export declare function findProjectRoot(startPath: string): string | null;

package/dist/hooks/rules-injector/rule-distance.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Calculate directory distance between a rule file and current file.
+ * Distance is based on common ancestor within project root.
+ *
+ * @param rulePath - Path to the rule file
+ * @param currentFile - Path to the current file being edited
+ * @param projectRoot - Project root for relative path calculation
+ * @returns Distance (0 = same directory, higher = further)
+ */
+export declare function calculateDistance(rulePath: string, currentFile: string, projectRoot: string | null): number;

package/dist/hooks/rules-injector/rule-file-finder.d.ts

@@ -0,0 +1,15 @@
+import type { RuleFileCandidate } from "./types";
+/**
+ * Find all rule files for a given context.
+ * Searches from currentFile upward to projectRoot for rule directories,
+ * then user-level directory (~/.claude/rules).
+ *
+ * IMPORTANT: This searches EVERY directory from file to project root.
+ * Not just the project root itself.
+ *
+ * @param projectRoot - Project root path (or null if outside any project)
+ * @param homeDir - User home directory
+ * @param currentFile - Current file being edited (for distance calculation)
+ * @returns Array of rule file candidates sorted by distance
+ */
+export declare function findRuleFiles(projectRoot: string | null, homeDir: string, currentFile: string): RuleFileCandidate[];

package/dist/hooks/rules-injector/rule-file-scanner.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Recursively find all rule files (*.md, *.mdc) in a directory
+ *
+ * @param dir - Directory to search
+ * @param results - Array to accumulate results
+ */
+export declare function findRuleFilesRecursive(dir: string, results: string[]): void;
+/**
+ * Resolve symlinks safely with fallback to original path
+ *
+ * @param filePath - Path to resolve
+ * @returns Real path or original path if resolution fails
+ */
+export declare function safeRealpathSync(filePath: string): string;

package/dist/hooks/rules-injector/storage.d.ts

@@ -0,0 +1,9 @@
+export declare function loadInjectedRules(sessionID: string): {
+    contentHashes: Set<string>;
+    realPaths: Set<string>;
+};
+export declare function saveInjectedRules(sessionID: string, data: {
+    contentHashes: Set<string>;
+    realPaths: Set<string>;
+}): void;
+export declare function clearInjectedRules(sessionID: string): void;

package/dist/hooks/rules-injector/types.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Rule file metadata (Claude Code style frontmatter)
+ * Supports both Claude Code format (globs, paths) and GitHub Copilot format (applyTo)
+ * @see https://docs.anthropic.com/en/docs/claude-code/settings#rule-files
+ * @see https://docs.github.com/en/copilot/customizing-copilot/adding-repository-custom-instructions-for-github-copilot
+ */
+export interface RuleMetadata {
+    description?: string;
+    globs?: string | string[];
+    alwaysApply?: boolean;
+}
+/**
+ * Rule information with path context and content
+ */
+export interface RuleInfo {
+    /** Absolute path to the rule file */
+    path: string;
+    /** Path relative to project root */
+    relativePath: string;
+    /** Directory distance from target file (0 = same dir) */
+    distance: number;
+    /** Rule file content (without frontmatter) */
+    content: string;
+    /** SHA-256 hash of content for deduplication */
+    contentHash: string;
+    /** Parsed frontmatter metadata */
+    metadata: RuleMetadata;
+    /** Why this rule matched (e.g., "alwaysApply", "glob: *.ts", "path match") */
+    matchReason: string;
+    /** Real path after symlink resolution (for duplicate detection) */
+    realPath: string;
+}
+/**
+ * Rule file candidate with discovery context
+ */
+export interface RuleFileCandidate {
+    path: string;
+    realPath: string;
+    isGlobal: boolean;
+    distance: number;
+    /** Single-file rules (e.g., .github/copilot-instructions.md) always apply without frontmatter */
+    isSingleFile?: boolean;
+}
+/**
+ * Session storage for injected rules tracking
+ */
+export interface InjectedRulesData {
+    sessionID: string;
+    /** Content hashes of already injected rules */
+    injectedHashes: string[];
+    /** Real paths of already injected rules (for symlink deduplication) */
+    injectedRealPaths: string[];
+    updatedAt: number;
+}

package/dist/hooks/runtime-fallback/agent-resolver.d.ts

@@ -0,0 +1,5 @@
+export declare const AGENT_NAMES: string[];
+export declare const agentPattern: RegExp;
+export declare function detectAgentFromSession(sessionID: string): string | undefined;
+export declare function normalizeAgentName(agent: string | undefined): string | undefined;
+export declare function resolveAgentForSession(sessionID: string, eventAgent?: string): string | undefined;

package/dist/hooks/runtime-fallback/auto-retry.d.ts

@@ -0,0 +1,10 @@
+import type { HookDeps } from "./types";
+export declare function createAutoRetryHelpers(deps: HookDeps): {
+    abortSessionRequest: (sessionID: string, source: string) => Promise<void>;
+    clearSessionFallbackTimeout: (sessionID: string) => void;
+    scheduleSessionFallbackTimeout: (sessionID: string, resolvedAgent?: string) => void;
+    autoRetryWithFallback: (sessionID: string, newModel: string, resolvedAgent: string | undefined, source: string) => Promise<void>;
+    resolveAgentForSessionFromContext: (sessionID: string, eventAgent?: string) => Promise<string | undefined>;
+    cleanupStaleSessions: () => void;
+};
+export type AutoRetryHelpers = ReturnType<typeof createAutoRetryHelpers>;

package/dist/hooks/runtime-fallback/chat-message-handler.d.ts

@@ -0,0 +1,20 @@
+import type { HookDeps } from "./types";
+export declare function createChatMessageHandler(deps: HookDeps): (input: {
+    sessionID: string;
+    agent?: string;
+    model?: {
+        providerID: string;
+        modelID: string;
+    };
+}, output: {
+    message: {
+        model?: {
+            providerID: string;
+            modelID: string;
+        };
+    };
+    parts?: Array<{
+        type: string;
+        text?: string;
+    }>;
+}) => Promise<void>;

package/dist/hooks/runtime-fallback/constants.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Runtime Fallback Hook - Constants
+ *
+ * Default values and configuration constants for the runtime fallback feature.
+ */
+import type { RuntimeFallbackConfig } from "../../config";
+/**
+ * Default configuration values for runtime fallback
+ */
+export declare const DEFAULT_CONFIG: Required<RuntimeFallbackConfig>;
+/**
+ * Error patterns that indicate rate limiting or temporary failures
+ * These are checked in addition to HTTP status codes
+ */
+export declare const RETRYABLE_ERROR_PATTERNS: RegExp[];
+/**
+ * Hook name for identification and logging
+ */
+export declare const HOOK_NAME = "runtime-fallback";

package/dist/hooks/runtime-fallback/error-classifier.d.ts

@@ -0,0 +1,17 @@
+export declare function getErrorMessage(error: unknown): string;
+export declare function extractStatusCode(error: unknown, retryOnErrors?: number[]): number | undefined;
+export declare function extractErrorName(error: unknown): string | undefined;
+export declare function classifyErrorType(error: unknown): string | undefined;
+export interface AutoRetrySignal {
+    signal: string;
+}
+export declare const AUTO_RETRY_PATTERNS: Array<(combined: string) => boolean>;
+export declare function extractAutoRetrySignal(info: Record<string, unknown> | undefined): AutoRetrySignal | undefined;
+export declare function containsErrorContent(parts: Array<{
+    type?: string;
+    text?: string;
+}> | undefined): {
+    hasError: boolean;
+    errorMessage?: string;
+};
+export declare function isRetryableError(error: unknown, retryOnErrors: number[]): boolean;

package/dist/hooks/runtime-fallback/event-handler.d.ts

@@ -0,0 +1,8 @@
+import type { HookDeps } from "./types";
+import type { AutoRetryHelpers } from "./auto-retry";
+export declare function createEventHandler(deps: HookDeps, helpers: AutoRetryHelpers): ({ event }: {
+    event: {
+        type: string;
+        properties?: unknown;
+    };
+}) => Promise<void>;

package/dist/hooks/runtime-fallback/fallback-models.d.ts

@@ -0,0 +1,2 @@
+import type { OhMyOpenCodeConfig } from "../../config";
+export declare function getFallbackModelsForSession(sessionID: string, agent: string | undefined, pluginConfig: OhMyOpenCodeConfig | undefined): string[];

package/dist/hooks/runtime-fallback/fallback-state.d.ts

@@ -0,0 +1,6 @@
+import type { FallbackState, FallbackResult } from "./types";
+import type { RuntimeFallbackConfig } from "../../config";
+export declare function createFallbackState(originalModel: string): FallbackState;
+export declare function isModelInCooldown(model: string, state: FallbackState, cooldownSeconds: number): boolean;
+export declare function findNextAvailableFallback(state: FallbackState, fallbackModels: string[], cooldownSeconds: number): string | undefined;
+export declare function prepareFallback(sessionID: string, state: FallbackState, fallbackModels: string[], config: Required<RuntimeFallbackConfig>): FallbackResult;

package/dist/hooks/runtime-fallback/hook.d.ts

@@ -0,0 +1,3 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { RuntimeFallbackHook, RuntimeFallbackOptions } from "./types";
+export declare function createRuntimeFallbackHook(ctx: PluginInput, options?: RuntimeFallbackOptions): RuntimeFallbackHook;

package/dist/hooks/runtime-fallback/index.d.ts

@@ -0,0 +1,2 @@
+export { createRuntimeFallbackHook } from "./hook";
+export type { RuntimeFallbackHook, RuntimeFallbackOptions } from "./types";

package/dist/hooks/runtime-fallback/message-update-handler.d.ts

@@ -0,0 +1,5 @@
+import type { HookDeps } from "./types";
+import type { AutoRetryHelpers } from "./auto-retry";
+import { extractAutoRetrySignal } from "./error-classifier";
+export declare function hasVisibleAssistantResponse(extractAutoRetrySignalFn: typeof extractAutoRetrySignal): (ctx: HookDeps["ctx"], sessionID: string, _info: Record<string, unknown> | undefined) => Promise<boolean>;
+export declare function createMessageUpdateHandler(deps: HookDeps, helpers: AutoRetryHelpers): (props: Record<string, unknown> | undefined) => Promise<void>;

package/dist/hooks/runtime-fallback/types.d.ts

@@ -0,0 +1,59 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { RuntimeFallbackConfig, OhMyOpenCodeConfig } from "../../config";
+export interface FallbackState {
+    originalModel: string;
+    currentModel: string;
+    fallbackIndex: number;
+    failedModels: Map<string, number>;
+    attemptCount: number;
+    pendingFallbackModel?: string;
+}
+export interface FallbackResult {
+    success: boolean;
+    newModel?: string;
+    error?: string;
+    maxAttemptsReached?: boolean;
+}
+export interface RuntimeFallbackOptions {
+    config?: RuntimeFallbackConfig;
+    pluginConfig?: OhMyOpenCodeConfig;
+    session_timeout_ms?: number;
+}
+export interface RuntimeFallbackHook {
+    event: (input: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => Promise<void>;
+    "chat.message"?: (input: {
+        sessionID: string;
+        agent?: string;
+        model?: {
+            providerID: string;
+            modelID: string;
+        };
+    }, output: {
+        message: {
+            model?: {
+                providerID: string;
+                modelID: string;
+            };
+        };
+        parts?: Array<{
+            type: string;
+            text?: string;
+        }>;
+    }) => Promise<void>;
+}
+export interface HookDeps {
+    ctx: PluginInput;
+    config: Required<RuntimeFallbackConfig>;
+    options: RuntimeFallbackOptions | undefined;
+    pluginConfig: OhMyOpenCodeConfig | undefined;
+    sessionStates: Map<string, FallbackState>;
+    sessionLastAccess: Map<string, number>;
+    sessionRetryInFlight: Set<string>;
+    sessionAwaitingFallbackResult: Set<string>;
+    sessionFallbackTimeouts: Map<string, ReturnType<typeof setTimeout>>;
+}

package/dist/hooks/session-notification-formatting.d.ts

@@ -0,0 +1,3 @@
+export declare function escapeAppleScriptText(input: string): string;
+export declare function escapePowerShellSingleQuotedText(input: string): string;
+export declare function buildWindowsToastScript(title: string, message: string): string;

package/dist/hooks/session-notification-scheduler.d.ts

@@ -0,0 +1,24 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { Platform } from "./session-notification-sender";
+type SessionNotificationConfig = {
+    title: string;
+    message: string;
+    playSound: boolean;
+    soundPath: string;
+    idleConfirmationDelay: number;
+    skipIfIncompleteTodos: boolean;
+    maxTrackedSessions: number;
+};
+export declare function createIdleNotificationScheduler(options: {
+    ctx: PluginInput;
+    platform: Platform;
+    config: SessionNotificationConfig;
+    hasIncompleteTodos: (ctx: PluginInput, sessionID: string) => Promise<boolean>;
+    send: (ctx: PluginInput, platform: Platform, title: string, message: string) => Promise<void>;
+    playSound: (ctx: PluginInput, platform: Platform, soundPath: string) => Promise<void>;
+}): {
+    markSessionActivity: (sessionID: string) => void;
+    scheduleIdleNotification: (sessionID: string) => void;
+    deleteSession: (sessionID: string) => void;
+};
+export {};

package/dist/hooks/session-notification-sender.d.ts

@@ -0,0 +1,6 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export type Platform = "darwin" | "linux" | "win32" | "unsupported";
+export declare function detectPlatform(): Platform;
+export declare function getDefaultSoundPath(platform: Platform): string;
+export declare function sendSessionNotification(ctx: PluginInput, platform: Platform, title: string, message: string): Promise<void>;
+export declare function playSessionNotificationSound(ctx: PluginInput, platform: Platform, soundPath: string): Promise<void>;

package/dist/hooks/session-notification-utils.d.ts

@@ -0,0 +1,10 @@
+type Platform = "darwin" | "linux" | "win32" | "unsupported";
+export declare const getNotifySendPath: () => Promise<string | null>;
+export declare const getOsascriptPath: () => Promise<string | null>;
+export declare const getPowershellPath: () => Promise<string | null>;
+export declare const getAfplayPath: () => Promise<string | null>;
+export declare const getPaplayPath: () => Promise<string | null>;
+export declare const getAplayPath: () => Promise<string | null>;
+export declare const getTerminalNotifierPath: () => Promise<string | null>;
+export declare function startBackgroundCheck(platform: Platform): void;
+export {};

package/dist/hooks/session-notification.d.ts

@@ -0,0 +1,23 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+interface SessionNotificationConfig {
+    title?: string;
+    message?: string;
+    questionMessage?: string;
+    permissionMessage?: string;
+    playSound?: boolean;
+    soundPath?: string;
+    /** Delay in ms before sending notification to confirm session is still idle (default: 1500) */
+    idleConfirmationDelay?: number;
+    /** Skip notification if there are incomplete todos (default: true) */
+    skipIfIncompleteTodos?: boolean;
+    /** Maximum number of sessions to track before cleanup (default: 100) */
+    maxTrackedSessions?: number;
+    enforceMainSessionFilter?: boolean;
+}
+export declare function createSessionNotification(ctx: PluginInput, config?: SessionNotificationConfig): ({ event }: {
+    event: {
+        type: string;
+        properties?: unknown;
+    };
+}) => Promise<void>;
+export {};

package/dist/hooks/session-recovery/constants.d.ts

@@ -0,0 +1,4 @@
+export { OPENCODE_STORAGE, MESSAGE_STORAGE, PART_STORAGE } from "../../shared";
+export declare const THINKING_TYPES: Set<string>;
+export declare const META_TYPES: Set<string>;
+export declare const CONTENT_TYPES: Set<string>;

package/dist/hooks/session-recovery/detect-error-type.d.ts

@@ -0,0 +1,4 @@
+export type RecoveryErrorType = "tool_result_missing" | "thinking_block_order" | "thinking_disabled_violation" | "assistant_prefill_unsupported" | "unavailable_tool" | null;
+export declare function extractMessageIndex(error: unknown): number | null;
+export declare function extractUnavailableToolName(error: unknown): string | null;
+export declare function detectErrorType(error: unknown): RecoveryErrorType;

package/dist/hooks/session-recovery/hook.d.ts

@@ -0,0 +1,20 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { ExperimentalConfig } from "../../config";
+interface MessageInfo {
+    id?: string;
+    role?: string;
+    sessionID?: string;
+    parentID?: string;
+    error?: unknown;
+}
+export interface SessionRecoveryOptions {
+    experimental?: ExperimentalConfig;
+}
+export interface SessionRecoveryHook {
+    handleSessionRecovery: (info: MessageInfo) => Promise<boolean>;
+    isRecoverableError: (error: unknown) => boolean;
+    setOnAbortCallback: (callback: (sessionID: string) => void) => void;
+    setOnRecoveryCompleteCallback: (callback: (sessionID: string) => void) => void;
+}
+export declare function createSessionRecoveryHook(ctx: PluginInput, options?: SessionRecoveryOptions): SessionRecoveryHook;
+export {};

package/dist/hooks/session-recovery/index.d.ts

@@ -0,0 +1,5 @@
+export { createSessionRecoveryHook } from "./hook";
+export type { SessionRecoveryHook, SessionRecoveryOptions } from "./hook";
+export { detectErrorType } from "./detect-error-type";
+export type { RecoveryErrorType } from "./detect-error-type";
+export type { MessageData, ResumeConfig } from "./types";

package/dist/hooks/session-recovery/recover-empty-content-message-sdk.d.ts

@@ -0,0 +1,13 @@
+import type { createOpencodeClient } from "@opencode-ai/sdk";
+import type { MessageData } from "./types";
+type Client = ReturnType<typeof createOpencodeClient>;
+type ReplaceEmptyTextPartsAsync = (client: Client, sessionID: string, messageID: string, replacementText: string) => Promise<boolean>;
+type InjectTextPartAsync = (client: Client, sessionID: string, messageID: string, text: string) => Promise<boolean>;
+type FindMessagesWithEmptyTextPartsFromSDK = (client: Client, sessionID: string) => Promise<string[]>;
+export declare function recoverEmptyContentMessageFromSDK(client: Client, sessionID: string, failedAssistantMsg: MessageData, error: unknown, dependencies: {
+    placeholderText: string;
+    replaceEmptyTextPartsAsync: ReplaceEmptyTextPartsAsync;
+    injectTextPartAsync: InjectTextPartAsync;
+    findMessagesWithEmptyTextPartsFromSDK: FindMessagesWithEmptyTextPartsFromSDK;
+}): Promise<boolean>;
+export {};

package/dist/hooks/session-recovery/recover-thinking-block-order.d.ts

@@ -0,0 +1,5 @@
+import type { createOpencodeClient } from "@opencode-ai/sdk";
+import type { MessageData } from "./types";
+type Client = ReturnType<typeof createOpencodeClient>;
+export declare function recoverThinkingBlockOrder(client: Client, sessionID: string, _failedAssistantMsg: MessageData, _directory: string, error: unknown): Promise<boolean>;
+export {};