oh-my-opencode-serverlocal 0.1.0

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

@@ -0,0 +1,122 @@
+/**
+ * Runtime model fallback for foreground (interactive) agent sessions.
+ *
+ * When OpenCode fires a session.error, message.updated, or session.status
+ * event containing a transient error (rate-limit, 403/Forbidden, etc.), this
+ * manager:
+ *   1. Looks up the next untried model in the agent's configured chain
+ *   2. Aborts the rate-limited prompt via client.session.abort() on the
+ *      session.status retry path; session.error and message.updated paths
+ *      re-prompt directly without abort.
+ *   3. Re-queues the last user message via client.session.promptAsync()
+ *      with the new model - promptAsync returns immediately so we never
+ *      block the event handler waiting for a full LLM response.
+ *
+ * This mirrors the same fallback loop used for delegated sessions, but operates
+ * reactively through the event system instead of wrapping prompt() in a
+ * try/catch, which is not possible for interactive (foreground) sessions.
+ */
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { SessionLifecycle } from '../session-lifecycle';
+type OpencodeClient = PluginInput['client'];
+export declare function isFailoverError(error: unknown): boolean;
+/**
+ * Checks whether an error is a transient/retryable error (rate-limit,
+ * 403/Forbidden, etc.) that should trigger model fallback.
+ */
+export declare function isRetryableError(error: unknown): boolean;
+/** @deprecated Use isRetryableError instead. */
+export declare function isRateLimitError(error: unknown): boolean;
+/**
+ * Manages runtime model fallback for foreground agent sessions.
+ *
+ * Constructed at plugin init with the ordered fallback chains for each agent
+ * (built from _modelArray entries in agents.<name>.model).
+ */
+export declare class ForegroundFallbackManager {
+    private readonly client;
+    /**
+     * Ordered fallback chains per agent.
+     * e.g. { orchestrator: ['anthropic/claude-opus-4-5', 'openai/gpt-4o'] }
+     * The first model that hasn't been tried yet is selected on each fallback.
+     */
+    private chains;
+    private readonly enabled;
+    /** Consecutive 429s tolerated on the same model before swap/abort. */
+    private readonly maxRetries;
+    /** sessionID → last observed model string ("providerID/modelID") */
+    private readonly sessionModel;
+    /** sessionID → agent name (populated from message.updated info.agent field) */
+    private readonly sessionAgent;
+    /** sessionID → set of models already attempted this session */
+    private readonly sessionTried;
+    /** Sessions with an active fallback switch in flight */
+    private readonly inProgress;
+    /** sessionID → timestamp of last trigger (for deduplication) */
+    private readonly lastTrigger;
+    /** sessionID → model in use when lastTrigger was set; dedup is bypassed
+     *  when the model has changed, allowing the cascade to continue when a
+     *  new fallback model also fails within the dedup window. */
+    private readonly lastTriggerModel;
+    /** sessionID → consecutive 429 count for the current model.
+     *  Reset on model swap or session deletion. */
+    private readonly sessionRetries;
+    /** Exposed for task-session-manager: prevents idle reconciliation
+     *  while a fallback abort/re-prompt is in flight for this session. */
+    isFallbackInProgress(sessionID: string): boolean;
+    /**
+     * Disable the fallback chain for a specific agent.
+     * After calling this, rate-limit errors for that agent surface instead of
+     * silently falling back through the chain.
+     */
+    disableChain(agentName: string): void;
+    registerSessionAgent(sessionID: string, agentName: string): void;
+    constructor(client: OpencodeClient, 
+    /**
+     * Ordered fallback chains per agent.
+     * e.g. { orchestrator: ['anthropic/claude-opus-4-5', 'openai/gpt-4o'] }
+     * The first model that hasn't been tried yet is selected on each fallback.
+     */
+    chains: Record<string, string[]>, enabled: boolean, 
+    /** Consecutive 429s tolerated on the same model before swap/abort. */
+    maxRetries?: number, coordinator?: SessionLifecycle);
+    /**
+     * Process an OpenCode plugin event.
+     * Call this from the plugin's `event` hook for every event received.
+     */
+    handleEvent(rawEvent: unknown): Promise<void>;
+    /** Increment retry counter and return true when the budget is exhausted.
+     *  Used by shouldIntervene when tried > 0 — each retry counts toward the
+     *  budget and only triggers fallback after maxRetries - 1 absorptions.
+     *  First failover retry (tried === 0) bypasses the counter via shouldIntervene. */
+    private consumeRetryBudget;
+    /** Intervene immediately on first occurrence (tried === 0), otherwise
+     *  delegate to retry budget. Used by all three event paths. */
+    private shouldTriggerFallback;
+    private isRecoveredStatus;
+    private tryFallback;
+    /**
+     * Fallback path for session.status retry events.  Aborts the retry loop
+     * before falling back because promptAsync alone is ignored while the
+     * session is in retry mode.  inProgress is set first so the
+     * task-session-manager sees isFallbackInProgress()=true during the
+     * abort idle window and does not cancel the pending task call.
+     */
+    private tryFallbackWithAbort;
+    private isDeduped;
+    private execFallback;
+    /**
+     * Determine the fallback chain to use for a session.
+     *
+     * Priority:
+     * 1. Agent name known AND has a configured chain → return it directly
+     * 2. Agent name known but NO chain → return [] (no fallback; never
+     *    bleed into other agents' chains)
+     * 3. Agent name unknown, current model known → search all chains for
+     *    the model to infer which chain to use
+     * 4. Nothing matches → flatten all chains as a last resort (only
+     *    reached when both agent name and current model are unavailable)
+     */
+    private resolveChain;
+}
+export {};

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

@@ -0,0 +1,8 @@
+import { type MessageWithParts } from './types';
+export declare function processImageAttachments(args: {
+    messages: MessageWithParts[];
+    workDir: string;
+    imageRouting: 'auto' | 'direct';
+    disabledAgents: Set<string>;
+    log: (msg: string) => void;
+}): void;

package/dist/hooks/index.d.ts

@@ -0,0 +1,16 @@
+export { createApplyPatchHook } from './apply-patch';
+export type { AutoUpdateCheckerOptions } from './auto-update-checker';
+export { createAutoUpdateCheckerHook } from './auto-update-checker';
+export { createChatHeadersHook } from './chat-headers';
+export { createDeepworkCommandHook } from './deepwork';
+export { createDelegateTaskRetryHook } from './delegate-task-retry/hook';
+export { createFilterAvailableSkillsHook } from './filter-available-skills';
+export { ForegroundFallbackManager, isFailoverError, isRetryableError, } from './foreground-fallback';
+export { processImageAttachments } from './image-hook';
+export { createJsonErrorRecoveryHook } from './json-error-recovery/hook';
+export { createLoopCommandHook } from './loop-command';
+export { createPhaseReminderHook } from './phase-reminder';
+export { createPostFileToolNudgeHook } from './post-file-tool-nudge';
+export { createReflectCommandHook } from './reflect';
+export { SessionLifecycle } from './session-lifecycle';
+export { createTaskSessionManagerHook } from './task-session-manager';

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

@@ -0,0 +1,18 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+export declare const JSON_ERROR_TOOL_EXCLUDE_LIST: readonly ["bash", "read", "glob", "webfetch", "gh_grep_searchgithub", "websearch_web_search_exa"];
+export declare const JSON_ERROR_PATTERNS: readonly [RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp];
+export declare const JSON_ERROR_REMINDER = "\n[JSON PARSE ERROR - IMMEDIATE ACTION REQUIRED]\n\nYou sent invalid JSON arguments. The system could not parse your tool call.\nSTOP and do this NOW:\n\n1. LOOK at the error message above to see what was expected vs what you sent.\n2. CORRECT your JSON syntax (missing braces, unescaped quotes, trailing commas, etc).\n3. RETRY the tool call with valid JSON.\n\nDO NOT repeat the exact same invalid call.\n";
+interface ToolExecuteAfterInput {
+    tool: string;
+    sessionID: string;
+    callID: string;
+}
+interface ToolExecuteAfterOutput {
+    title: string;
+    output: unknown;
+    metadata: unknown;
+}
+export declare function createJsonErrorRecoveryHook(_ctx: PluginInput): {
+    'tool.execute.after': (input: ToolExecuteAfterInput, output: ToolExecuteAfterOutput) => Promise<void>;
+};
+export {};

package/dist/hooks/loop-command/index.d.ts

@@ -0,0 +1,13 @@
+export declare function createLoopCommandHook(): {
+    registerCommand: (config: Record<string, unknown>) => void;
+    handleCommandExecuteBefore: (input: {
+        command: string;
+        sessionID: string;
+        arguments: string;
+    }, output: {
+        parts: Array<{
+            type: string;
+            text?: string;
+        }>;
+    }) => Promise<void>;
+};

package/dist/hooks/phase-reminder/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Phase reminder to append after each latest user message.
+ *
+ * Keeping this at the tail preserves immediate workflow guidance without
+ * mutating the cached system prompt or prepending request-local content ahead
+ * of the user's actual turn.
+ */
+import { PHASE_REMINDER } from '../../config/constants';
+import { type MessagePart } from '../types';
+export { PHASE_REMINDER };
+export declare const PHASE_REMINDER_METADATA_KEY = "oh-my-opencode-slim.phaseReminder";
+export declare function hasPhaseReminder(part: MessagePart): boolean;
+interface PhaseReminderOptions {
+    shouldInject?: (sessionID: string) => boolean;
+}
+/**
+ * Creates the experimental.chat.messages.transform hook for phase reminder injection.
+ * This hook runs right before sending to API, so it doesn't affect UI display.
+ * Only injects for the orchestrator agent.
+ */
+export declare function createPhaseReminderHook(options?: PhaseReminderOptions): {
+    'experimental.chat.messages.transform': (_input: Record<string, never>, output: {
+        messages?: unknown;
+    }) => Promise<void>;
+};

package/dist/hooks/post-file-tool-nudge/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Post-tool nudge - queues a delegation reminder after file reads/writes.
+ * Catches the "inspect/edit files → implement myself" anti-pattern.
+ *
+ * The reminder is ephemeral: recorded on tool execution, injected via
+ * messages.transform, and consumed once. File tool output stays clean.
+ */
+import type { SessionLifecycle } from '../session-lifecycle';
+interface PostFileToolNudgeOptions {
+    shouldInject?: (sessionID: string) => boolean;
+    coordinator?: SessionLifecycle;
+}
+export declare function createPostFileToolNudgeHook(options?: PostFileToolNudgeOptions): {
+    'tool.execute.after': (input: {
+        tool: string;
+        sessionID?: string;
+        callID?: string;
+    }, _output: unknown) => Promise<void>;
+    'experimental.chat.messages.transform': (_input: Record<string, never>, output: {
+        messages?: unknown;
+    }) => Promise<void>;
+};
+export {};

package/dist/hooks/reflect/index.d.ts

@@ -0,0 +1,13 @@
+export declare function createReflectCommandHook(): {
+    registerCommand: (config: Record<string, unknown>) => void;
+    handleCommandExecuteBefore: (input: {
+        command: string;
+        sessionID: string;
+        arguments: string;
+    }, output: {
+        parts: Array<{
+            type: string;
+            text?: string;
+        }>;
+    }) => Promise<void>;
+};

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

@@ -0,0 +1,10 @@
+export declare class SessionLifecycle {
+    #private;
+    constructor(log: (msg: string, meta?: Record<string, unknown>) => void);
+    onSessionDeleted(callback: (sessionId: string) => void): void;
+    dispatchSessionDeleted(sessionId: string): void;
+    markPending(sessionId: string): void;
+    /** Atomic — only one caller gets true per markPending call. */
+    consumePending(sessionId: string): boolean;
+    clearSession(sessionId: string): void;
+}

package/dist/hooks/task-session-manager/index.d.ts

@@ -0,0 +1,58 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+import { type BackgroundJobStore } from '../../utils';
+import type { SessionLifecycle } from '../session-lifecycle';
+export declare const BACKGROUND_JOB_BOARD_METADATA_KEY = "oh-my-opencode-slim.backgroundJobBoard";
+export declare function createTaskSessionManagerHook(_ctx: PluginInput, options: {
+    maxSessionsPerAgent: number;
+    readContextMinLines?: number;
+    readContextMaxFiles?: number;
+    backgroundJobBoard?: BackgroundJobStore;
+    shouldManageSession: (sessionID: string) => boolean;
+    /** Register a session as orchestrator when the transform hook detects
+     *  an orchestrator message but the session isn't in the agent map yet. */
+    registerSessionAsOrchestrator?: (sessionID: string) => void;
+    /** Optional guard: when provided, idle events for a session that is
+     *  currently undergoing a foreground-fallback abort/re-prompt cycle
+     *  will NOT trigger idle reconciliation. prevents marking a still-
+     *  active child job as completed when the session was aborted for
+     *  model fallback rather than natural completion. */
+    isFallbackInProgress?: (sessionID: string) => boolean;
+    coordinator?: SessionLifecycle;
+}): {
+    'tool.execute.before': (input: {
+        tool: string;
+        sessionID?: string;
+        callID?: string;
+    }, output: {
+        args?: unknown;
+    }) => Promise<void>;
+    'tool.execute.after': (input: {
+        tool: string;
+        sessionID?: string;
+        callID?: string;
+    }, output: {
+        output: unknown;
+        metadata?: unknown;
+    }) => Promise<void>;
+    'experimental.chat.messages.transform': (_input: Record<string, never>, output: {
+        messages?: unknown;
+    }) => Promise<void>;
+    event: (input: {
+        event: {
+            type: string;
+            properties?: {
+                info?: {
+                    id?: string;
+                    parentID?: string;
+                };
+                sessionID?: string;
+                status?: {
+                    type?: string;
+                };
+                error?: {
+                    name?: string;
+                };
+            };
+        };
+    }) => Promise<void>;
+};

package/dist/hooks/task-session-manager/pending-call-tracker.d.ts

@@ -0,0 +1,13 @@
+export interface PendingTaskCall {
+    callId: string;
+    parentSessionId: string;
+    agentType: string;
+    label: string;
+    resumedTaskId?: string;
+}
+export declare function createPendingCallTracker(): {
+    add(call: PendingTaskCall): void;
+    take(callId?: string, parentSessionId?: string): PendingTaskCall | undefined;
+    clearSession(sessionId: string): void;
+    pendingCallId(sessionID?: string, callID?: string): string;
+};

package/dist/hooks/task-session-manager/task-context-tracker.d.ts

@@ -0,0 +1,14 @@
+import type { ContextFile } from '../../utils';
+export declare function createTaskContextTracker(): {
+    pendingManagedTaskIds: Set<string>;
+    addContext(taskId: string, files: ContextFile[]): void;
+    prune(backgroundJobBoard: {
+        taskIDs(): Set<string>;
+    }): void;
+    clearSession(sessionId: string): void;
+    contextFilesForPrompt(taskId: string): ContextFile[];
+};
+export declare function extractReadFiles(root: string, output: {
+    output: unknown;
+    metadata?: unknown;
+}): ContextFile[];

package/dist/hooks/types.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Shared message type shapes for the OpenCode plugin API's `messages` array.
+ *
+ * These types describe the structure of chat messages passed through
+ * `experimental.chat.messages.transform` and related hooks. All fields
+ * are unioned across the files that previously defined them privately -
+ * optional extras are harmless under structural typing.
+ */
+export type MessageInfo = {
+    role: string;
+    agent?: string;
+    sessionID?: string;
+    id?: string;
+};
+export type MessagePart = {
+    type: string;
+    text?: string;
+    [key: string]: unknown;
+};
+export type MessageWithParts = {
+    info: MessageInfo;
+    parts: MessagePart[];
+};
+export declare function isMessageWithParts(message: unknown): message is MessageWithParts;
+export declare function isUserMessageWithParts(message: unknown): message is MessageWithParts;
+export declare function findLatestUserMessage(messages: unknown[]): MessageWithParts | undefined;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin } from '@opencode-ai/plugin';
+declare const OhMyOpenCodeLite: Plugin;
+export default OhMyOpenCodeLite;
+export type { AgentName, AgentOverrideConfig, McpName, MultiplexerConfig, MultiplexerLayout, MultiplexerType, PluginConfig, TmuxConfig, TmuxLayout, } from './config';
+export type { RemoteMcpConfig } from './mcp';