oh-my-opencode-gpt-slim 0.0.3

package/dist/hooks/edit-error-recovery/hook.d.ts

@@ -0,0 +1,31 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+/**
+ * Known Edit tool error patterns that indicate the AI made a mistake
+ */
+export declare const EDIT_ERROR_PATTERNS: readonly ["oldString and newString must be different", "oldString not found", "oldString found multiple times"];
+/**
+ * System reminder injected when Edit tool fails due to AI mistake
+ * Short, direct, and commanding - forces immediate corrective action
+ */
+export declare const EDIT_ERROR_REMINDER = "\n[EDIT ERROR - IMMEDIATE ACTION REQUIRED]\n\nYou made an Edit mistake. STOP and do this NOW:\n\n1. READ the file immediately to see its ACTUAL current state\n2. VERIFY what the content really looks like (your assumption was wrong)\n3. APOLOGIZE briefly to the user for the error\n4. CONTINUE with corrected action based on the real file content\n\nDO NOT attempt another edit until you've read and verified the file state.\n";
+/**
+ * Detects Edit tool errors caused by AI mistakes and injects a recovery reminder
+ *
+ * This hook catches common Edit tool failures:
+ * - oldString and newString must be different (trying to "edit" to same content)
+ * - oldString not found (wrong assumption about file content)
+ * - oldString found multiple times (ambiguous match, need more context)
+ *
+ * @see https://github.com/sst/opencode/issues/4718
+ */
+export declare function createEditErrorRecoveryHook(_ctx: PluginInput): {
+    "tool.execute.after": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        title: string;
+        output: string;
+        metadata: unknown;
+    }) => Promise<void>;
+};

package/dist/hooks/edit-error-recovery/index.d.ts

@@ -0,0 +1 @@
+export { createEditErrorRecoveryHook, EDIT_ERROR_PATTERNS, EDIT_ERROR_REMINDER, } from "./hook";

package/dist/hooks/hashline-edit-diff-enhancer/hook.d.ts

@@ -0,0 +1,28 @@
+interface HashlineEditDiffEnhancerConfig {
+    hashline_edit?: {
+        enabled: boolean;
+    };
+}
+type BeforeInput = {
+    tool: string;
+    sessionID: string;
+    callID: string;
+};
+type BeforeOutput = {
+    args: Record<string, unknown>;
+};
+type AfterInput = {
+    tool: string;
+    sessionID: string;
+    callID: string;
+};
+type AfterOutput = {
+    title: string;
+    output: string;
+    metadata: Record<string, unknown>;
+};
+export declare function createHashlineEditDiffEnhancerHook(config: HashlineEditDiffEnhancerConfig): {
+    "tool.execute.before": (input: BeforeInput, output: BeforeOutput) => Promise<void>;
+    "tool.execute.after": (input: AfterInput, output: AfterOutput) => Promise<void>;
+};
+export {};

package/dist/hooks/hashline-edit-diff-enhancer/index.d.ts

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

package/dist/hooks/hashline-read-enhancer/hook.d.ts

@@ -0,0 +1,18 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+interface HashlineReadEnhancerConfig {
+    hashline_edit?: {
+        enabled: boolean;
+    };
+}
+export declare function createHashlineReadEnhancerHook(_ctx: PluginInput, config: HashlineReadEnhancerConfig): {
+    "tool.execute.after": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        title: string;
+        output: string;
+        metadata: unknown;
+    }) => Promise<void>;
+};
+export {};

package/dist/hooks/hashline-read-enhancer/index.d.ts

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

package/dist/hooks/index.d.ts

@@ -0,0 +1,12 @@
+export { createAutoUpdateCheckerHook } from "./auto-update-checker";
+export { createEditErrorRecoveryHook } from "./edit-error-recovery";
+export { createModelFallbackHook, setPendingModelFallback, clearPendingModelFallback, type ModelFallbackState } from "./model-fallback/hook";
+export { createRuntimeFallbackHook, type RuntimeFallbackHook, type RuntimeFallbackOptions } from "./runtime-fallback";
+export { createSessionRecoveryHook, type SessionRecoveryHook, type SessionRecoveryOptions } from "./session-recovery";
+export { createDirectoryAgentsInjectorHook } from "./directory-agents-injector";
+export { createDirectoryReadmeInjectorHook } from "./directory-readme-injector";
+export { createRulesInjectorHook } from "./rules-injector";
+export { createHashlineReadEnhancerHook } from "./hashline-read-enhancer";
+export { createHashlineEditDiffEnhancerHook } from "./hashline-edit-diff-enhancer";
+export { createToolOutputTruncatorHook } from "./tool-output-truncator";
+export { createWriteExistingFileGuardHook } from "./write-existing-file-guard";

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

@@ -0,0 +1,60 @@
+import type { FallbackEntry } from "../../shared/model-requirements";
+import type { ChatMessageInput, ChatMessageHandlerOutput } from "../../plugin/chat-message";
+type FallbackToast = (input: {
+    title: string;
+    message: string;
+    variant?: "info" | "success" | "warning" | "error";
+    duration?: number;
+}) => void | Promise<void>;
+type FallbackCallback = (input: {
+    sessionID: string;
+    providerID: string;
+    modelID: string;
+    variant?: string;
+}) => void | Promise<void>;
+export type ModelFallbackState = {
+    providerID: string;
+    modelID: string;
+    fallbackChain: FallbackEntry[];
+    attemptCount: number;
+    pending: boolean;
+};
+export declare function setSessionFallbackChain(sessionID: string, fallbackChain: FallbackEntry[] | undefined): void;
+export declare function clearSessionFallbackChain(sessionID: string): void;
+/**
+ * Sets a pending model fallback for a session.
+ * Called when a model error is detected in session.error handler.
+ */
+export declare function setPendingModelFallback(sessionID: string, agentName: string, currentProviderID: string, currentModelID: string): boolean;
+/**
+ * Gets the next fallback model for a session.
+ * Increments attemptCount each time called.
+ */
+export declare function getNextFallback(sessionID: string): {
+    providerID: string;
+    modelID: string;
+    variant?: string;
+} | null;
+/**
+ * Clears the pending fallback for a session.
+ * Called after fallback is successfully applied.
+ */
+export declare function clearPendingModelFallback(sessionID: string): void;
+/**
+ * Checks if there's a pending fallback for a session.
+ */
+export declare function hasPendingModelFallback(sessionID: string): boolean;
+/**
+ * Gets the current fallback state for a session (for debugging).
+ */
+export declare function getFallbackState(sessionID: string): ModelFallbackState | undefined;
+/**
+ * Creates a chat.message hook that applies model fallbacks when pending.
+ */
+export declare function createModelFallbackHook(args?: {
+    toast?: FallbackToast;
+    onApplied?: FallbackCallback;
+}): {
+    "chat.message": (input: ChatMessageInput, output: ChatMessageHandlerOutput) => Promise<void>;
+};
+export {};

package/dist/hooks/ralph-loop/command-arguments.d.ts

@@ -0,0 +1,7 @@
+export interface RalphLoopArguments {
+    prompt: string;
+    completionPromise: string;
+    maxIterations: number;
+    strategy: "reset" | "continue";
+}
+export declare function parseRalphLoopArguments(rawInput: string): RalphLoopArguments;

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

@@ -0,0 +1,3 @@
+export declare const ULTRAWORK_VERIFICATION_PROMISE = "ULTRAWORK_VERIFIED";
+export declare const DEFAULT_RALPH_COMPLETION_PROMISE = "DONE";
+export declare const DEFAULT_RALPH_MAX_ITERATIONS = 100;

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

@@ -0,0 +1,18 @@
+export interface RalphLoopState {
+    active: boolean;
+    iteration: number;
+    completion_promise: string;
+    initial_completion_promise: string;
+    started_at: string;
+    prompt: string;
+    session_id?: string;
+    ultrawork?: boolean;
+    strategy?: "reset" | "continue";
+    max_iterations?: number;
+    verification_pending?: boolean;
+    verification_attempt_id?: string;
+    verification_session_id?: string;
+}
+export declare function readState(directory: string): RalphLoopState | null;
+export declare function writeState(directory: string, state: RalphLoopState): void;
+export declare function clearState(directory: string): void;

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-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;