oh-my-opencode-slim 2.1.1 → 2.2.0

package/dist/config/strip-orchestrator-model.d.ts

@@ -0,0 +1,9 @@
+import type { PluginConfig, Preset } from './schema';
+export declare function stripOrchestratorModel(agents: Record<string, unknown>, enabled: boolean | undefined, preset: Preset | undefined): void;
+export declare function applyOrchestratorModelConfig(input: {
+    agents: Record<string, unknown>;
+    enabled: boolean | undefined;
+    presets: PluginConfig['presets'];
+    configPreset: string | undefined;
+    runtimePreset: string | null;
+}): void;

package/dist/hooks/command-hook-utils.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Register a command hook in the OpenCode config if it doesn't already exist.
+ * Returns true if the command was registered, false if it already existed.
+ */
+export declare function registerCommandHook(opencodeConfig: Record<string, unknown>, commandName: string, template: string, description: string): boolean;

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

@@ -2,9 +2,12 @@
  * Runtime model fallback for foreground (interactive) agent sessions.
  *
  * When OpenCode fires a session.error, message.updated, or session.status
- * event containing a rate-limit signal, this manager:
+ * 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()
+ *   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.
@@ -16,6 +19,13 @@
 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.
@@ -30,17 +40,10 @@ export declare class ForegroundFallbackManager {
      * 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 readonly chains;
+    private chains;
     private readonly enabled;
     /** Consecutive 429s tolerated on the same model before swap/abort. */
     private readonly maxRetries;
-    /**
-     * When true (default), a runtime model outside the configured chain
-     * still triggers fallback on rate-limit errors. When false, out-of-chain
-     * runtime picks are respected and the error surfaces instead. Models
-     * that are members of the chain always fall back regardless.
-     */
-    private readonly runtimeOverride;
     /** sessionID → last observed model string ("providerID/modelID") */
     private readonly sessionModel;
     /** sessionID → agent name (populated from message.updated info.agent field) */
@@ -61,6 +64,13 @@ export declare class ForegroundFallbackManager {
     /** 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.
@@ -69,37 +79,39 @@ export declare class ForegroundFallbackManager {
      */
     chains: Record<string, string[]>, enabled: boolean, 
     /** Consecutive 429s tolerated on the same model before swap/abort. */
-    maxRetries?: number, coordinator?: SessionLifecycle, 
-    /**
-     * When true (default), a runtime model outside the configured chain
-     * still triggers fallback on rate-limit errors. When false, out-of-chain
-     * runtime picks are respected and the error surfaces instead. Models
-     * that are members of the chain always fall back regardless.
-     */
-    runtimeOverride?: boolean);
+    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 the session.status retry path — each retry counts toward the
+     *  Used by shouldIntervene when tried > 0 — each retry counts toward the
      *  budget and only triggers fallback after maxRetries - 1 absorptions.
-     *  Non-retry paths (session.error / message.updated) use shouldIntervene(),
-     *  which bypasses the counter on first occurrence. */
-    private checkRetryBudget;
-    /** For non-retry paths (session.error, message.updated): intervene immediately
-     *  unless the session is already in a retry window (has prior retries). */
-    private shouldIntervene;
+     *  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 configured → return [] (no fallback;
-     *    do NOT bleed into other agents' chains which would re-prompt the
-     *    session with a model belonging to a completely different agent)
+     * 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

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

@@ -2,6 +2,7 @@ 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

@@ -5,7 +5,7 @@ export { createChatHeadersHook } from './chat-headers';
 export { createDeepworkCommandHook } from './deepwork';
 export { createDelegateTaskRetryHook } from './delegate-task-retry/hook';
 export { createFilterAvailableSkillsHook } from './filter-available-skills';
-export { ForegroundFallbackManager, isRateLimitError, } from './foreground-fallback';
+export { ForegroundFallbackManager, isFailoverError, isRetryableError, } from './foreground-fallback';
 export { processImageAttachments } from './image-hook';
 export { createJsonErrorRecoveryHook } from './json-error-recovery/hook';
 export { createLoopCommandHook } from './loop-command';