oh-my-opencode-slim 0.8.6 → 0.9.1

package/dist/mcp/index.d.ts

@@ -1,6 +1,8 @@
+import type { WebsearchConfig } from '../config';
 import type { McpConfig } from './types';
 export type { LocalMcpConfig, McpConfig, RemoteMcpConfig } from './types';
 /**
- * Creates MCP configurations, excluding disabled ones
+ * Creates MCP configurations, excluding disabled ones.
+ * Accepts an optional websearchConfig to override the default Exa provider.
  */
-export declare function createBuiltinMcps(disabledMcps?: readonly string[]): Record<string, McpConfig>;
+export declare function createBuiltinMcps(disabledMcps?: readonly string[], websearchConfig?: WebsearchConfig): Record<string, McpConfig>;

package/dist/mcp/websearch.d.ts

@@ -1,6 +1,9 @@
+import type { WebsearchConfig } from '../config';
 import type { RemoteMcpConfig } from './types';
 /**
- * Exa AI web search - real-time web search
- * @see https://exa.ai
+ * Creates a websearch MCP config based on the provided configuration.
+ * Supports Exa (default) and Tavily providers.
+ * @see https://exa.ai  @see https://tavily.com
  */
+export declare function createWebsearchConfig(config?: WebsearchConfig): RemoteMcpConfig;
 export declare const websearch: RemoteMcpConfig;

package/dist/multiplexer/factory.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Multiplexer factory - creates the appropriate multiplexer instance
+ */
+import type { MultiplexerConfig } from '../config/schema';
+import type { Multiplexer } from './types';
+/**
+ * Create or retrieve a multiplexer instance based on config
+ */
+export declare function getMultiplexer(config: MultiplexerConfig): Multiplexer | null;
+/**
+ * Clear the multiplexer cache (useful for testing)
+ */
+export declare function clearMultiplexerCache(): void;
+/**
+ * Get the effective multiplexer type for auto mode
+ * Returns the actual type that would be used (tmux/zellij/none)
+ */
+export declare function getAutoMultiplexerType(): 'tmux' | 'zellij' | 'none';
+/**
+ * Start background availability check for a multiplexer
+ */
+export declare function startAvailabilityCheck(config: MultiplexerConfig): void;

package/dist/multiplexer/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Multiplexer module exports
+ */
+export { clearMultiplexerCache, getMultiplexer, startAvailabilityCheck, } from './factory';
+export { TmuxMultiplexer } from './tmux';
+export type { Multiplexer, PaneResult } from './types';
+export { isServerRunning } from './types';
+export { ZellijMultiplexer } from './zellij';

package/dist/multiplexer/tmux/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Tmux multiplexer implementation
+ */
+import type { MultiplexerLayout } from '../../config/schema';
+import type { Multiplexer, PaneResult } from '../types';
+export declare class TmuxMultiplexer implements Multiplexer {
+    readonly type: "tmux";
+    private binaryPath;
+    private hasChecked;
+    private storedLayout;
+    private storedMainPaneSize;
+    constructor(layout?: MultiplexerLayout, mainPaneSize?: number);
+    isAvailable(): Promise<boolean>;
+    isInsideSession(): boolean;
+    spawnPane(sessionId: string, description: string, serverUrl: string): Promise<PaneResult>;
+    closePane(paneId: string): Promise<boolean>;
+    applyLayout(layout: MultiplexerLayout, mainPaneSize: number): Promise<void>;
+    private getBinary;
+    private findBinary;
+}

package/dist/multiplexer/types.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Multiplexer abstraction layer
+ *
+ * Provides a unified interface for terminal multiplexers (tmux, zellij, etc.)
+ * to spawn and manage panes for background task visualization.
+ */
+import type { MultiplexerConfig, MultiplexerLayout } from '../config/schema';
+export interface PaneResult {
+    success: boolean;
+    paneId?: string;
+}
+/**
+ * Core multiplexer interface
+ * Implementations: TmuxMultiplexer, ZellijMultiplexer
+ */
+export interface Multiplexer {
+    readonly type: 'tmux' | 'zellij';
+    /**
+     * Check if the multiplexer binary is available on the system
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * Check if currently running inside a multiplexer session
+     */
+    isInsideSession(): boolean;
+    /**
+     * Spawn a new pane running the given command
+     * @param sessionId - The OpenCode session ID to attach to
+     * @param description - Human-readable description for the pane
+     * @param serverUrl - The OpenCode server URL to attach to
+     * @returns PaneResult with pane ID for later cleanup
+     */
+    spawnPane(sessionId: string, description: string, serverUrl: string): Promise<PaneResult>;
+    /**
+     * Close a pane by its ID
+     * @param paneId - The pane ID returned by spawnPane
+     * @returns true if successfully closed
+     */
+    closePane(paneId: string): Promise<boolean>;
+    /**
+     * Apply layout to rebalance panes
+     * @param layout - The layout type to apply
+     * @param mainPaneSize - Percentage for main pane (for main-* layouts)
+     */
+    applyLayout(layout: MultiplexerLayout, mainPaneSize: number): Promise<void>;
+}
+/**
+ * Factory function type for creating multiplexer instances
+ */
+export type MultiplexerFactory = (config: MultiplexerConfig) => Multiplexer;
+/**
+ * Server health check utility (shared across implementations)
+ */
+export declare function isServerRunning(serverUrl: string, timeoutMs?: number, maxAttempts?: number): Promise<boolean>;

package/dist/multiplexer/zellij/index.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Zellij multiplexer implementation
+ *
+ * Creates a dedicated "opencode-agents" tab for all sub-agent panes.
+ * - First sub-agent uses the default pane from new-tab
+ * - Subsequent sub-agents create new panes
+ * - User stays in their original tab
+ */
+import type { MultiplexerLayout } from '../../config/schema';
+import type { Multiplexer, PaneResult } from '../types';
+export declare class ZellijMultiplexer implements Multiplexer {
+    readonly type: "zellij";
+    private binaryPath;
+    private hasChecked;
+    private storedLayout;
+    private storedMainPaneSize;
+    private agentTabId;
+    private firstPaneId;
+    private firstPaneUsed;
+    constructor(layout?: MultiplexerLayout, mainPaneSize?: number);
+    isAvailable(): Promise<boolean>;
+    isInsideSession(): boolean;
+    spawnPane(sessionId: string, description: string, serverUrl: string): Promise<PaneResult>;
+    private createPaneInAgentTab;
+    private runInPane;
+    private ensureAgentTab;
+    private getFirstPaneInTab;
+    private findTabByName;
+    private findTabByNameText;
+    private getCurrentTabId;
+    private listPanes;
+    closePane(paneId: string): Promise<boolean>;
+    applyLayout(_layout: MultiplexerLayout, _mainPaneSize: number): Promise<void>;
+    private getBinary;
+    private findBinary;
+}

package/dist/tools/background.d.ts

@@ -1,13 +1,13 @@
 import { type PluginInput, type ToolDefinition } from '@opencode-ai/plugin';
 import type { BackgroundTaskManager } from '../background';
 import type { PluginConfig } from '../config';
-import type { TmuxConfig } from '../config/schema';
+import type { MultiplexerConfig } from '../config/schema';
 /**
  * Creates background task management tools for the plugin.
  * @param _ctx - Plugin input context
  * @param manager - Background task manager for launching and tracking tasks
- * @param _tmuxConfig - Optional tmux configuration for session management
+ * @param _multiplexerConfig - Optional multiplexer configuration for session management
  * @param _pluginConfig - Optional plugin configuration for agent variants
  * @returns Object containing background_task, background_output, and background_cancel tools
  */
-export declare function createBackgroundTools(_ctx: PluginInput, manager: BackgroundTaskManager, _tmuxConfig?: TmuxConfig, _pluginConfig?: PluginConfig): Record<string, ToolDefinition>;
+export declare function createBackgroundTools(_ctx: PluginInput, manager: BackgroundTaskManager, _multiplexerConfig?: MultiplexerConfig, _pluginConfig?: PluginConfig): Record<string, ToolDefinition>;

package/dist/tools/lsp/client.d.ts

@@ -1,4 +1,34 @@
 import type { Diagnostic, ResolvedServer } from './types';
+export declare const LSP_TIMEOUTS: {
+    start: number;
+    request: number;
+    openFileDelay: number;
+    initializeDelay: number;
+    diagnosticSettleDelay: number;
+};
+interface DiagnosticProviderCapabilities {
+    identifier?: string;
+    interFileDependencies?: boolean;
+    workspaceDiagnostics?: boolean;
+}
+export declare function getDiagnosticsCapabilitySummary({ diagnosticProvider, publishDiagnosticsObserved, workspaceConfigurationRequested, }: {
+    diagnosticProvider?: DiagnosticProviderCapabilities | null;
+    publishDiagnosticsObserved?: boolean;
+    workspaceConfigurationRequested?: boolean;
+}): {
+    availableModes: string[];
+    preferredMode: 'push' | 'pull';
+    inferredTransport: 'push' | 'pull' | 'hybrid';
+    pull: boolean;
+    pushObserved: boolean;
+    pullResultTracking: boolean;
+    workspaceDiagnostics: boolean;
+    interFileDependencies: boolean;
+    workspaceConfiguration: boolean;
+};
+export declare function getWorkspaceConfiguration(items: Array<{
+    section?: string;
+} | undefined>): Array<unknown>;
 declare class LSPServerManager {
     private static instance;
     private clients;
@@ -25,11 +55,19 @@ export declare class LSPClient {
     private stderrBuffer;
     private processExited;
     private diagnosticsStore;
+    private diagnosticResultIds;
+    private documents;
+    private diagnosticProvider;
+    private publishDiagnosticsObserved;
+    private supportsPullDiagnostics;
+    private workspaceConfigurationRequested;
     constructor(root: string, server: ResolvedServer);
     start(): Promise<void>;
     private startStderrReading;
     initialize(): Promise<void>;
+    private waitForPublishedDiagnostics;
     openFile(filePath: string): Promise<void>;
+    private ensureDocumentSynced;
     definition(filePath: string, line: number, character: number): Promise<unknown>;
     references(filePath: string, line: number, character: number, includeDeclaration?: boolean): Promise<unknown>;
     diagnostics(filePath: string): Promise<{

package/dist/tools/lsp/config.d.ts

@@ -1,4 +1,5 @@
 import type { ServerLookupResult } from './types';
-export declare function findServerForExtension(ext: string): ServerLookupResult;
+export declare function findServerForExtension(ext: string, filePath?: string): ServerLookupResult;
 export declare function getLanguageId(ext: string): string;
+export declare function resolveServerCommand(command: string[], cwd?: string): string[] | null;
 export declare function isServerInstalled(command: string[]): boolean;

package/dist/tools/lsp/types.d.ts

@@ -33,3 +33,13 @@ export type ServerLookupResult = {
     installHint: string;
 };
 export type { Position, Range, Location, LocationLink, Diagnostic, TextDocumentIdentifier, VersionedTextDocumentIdentifier, TextEdit, TextDocumentEdit, CreateFile, RenameFile, DeleteFile, WorkspaceEdit, SymbolInfo, DocumentSymbol, };
+export interface DocumentDiagnosticReportFull {
+    kind: 'full';
+    items: Diagnostic[];
+    resultId?: string;
+}
+export interface DocumentDiagnosticReportUnchanged {
+    kind: 'unchanged';
+    resultId?: string;
+}
+export type DocumentDiagnosticReport = DocumentDiagnosticReportFull | DocumentDiagnosticReportUnchanged;

package/dist/utils/index.d.ts

@@ -4,5 +4,4 @@ export * from './internal-initiator';
 export { log } from './logger';
 export * from './polling';
 export * from './session';
-export * from './tmux';
 export { extractZip } from './zip-extractor';

package/dist/utils/session.d.ts

@@ -44,6 +44,15 @@ export declare function parseModelReference(model: string): {
  * @throws Error if timeout is exceeded
  */
 export declare function promptWithTimeout(client: OpencodeClient, args: Parameters<OpencodeClient['session']['prompt']>[0], timeoutMs: number): Promise<void>;
+/**
+ * Result of extracting session content.
+ * `empty` is true when the assistant produced zero text content —
+ * the provider returned an empty response (e.g. rate-limited silently).
+ */
+export interface SessionExtractionResult {
+    text: string;
+    empty: boolean;
+}
 /**
  * Extract the result text from a session.
  * Collects all assistant messages and concatenates their text parts.
@@ -51,9 +60,9 @@ export declare function promptWithTimeout(client: OpencodeClient, args: Paramete
  * @param sessionId - Session ID to extract from
  * @param options - Optional: `includeReasoning` (default true) controls whether
  *                  reasoning/chain-of-thought parts are included.
- * @returns Concatenated text from all assistant messages
+ * @returns Object with extracted text and an `empty` flag for zero-content detection
  */
 export declare function extractSessionResult(client: OpencodeClient, sessionId: string, options?: {
     includeReasoning?: boolean;
-}): Promise<string>;
+}): Promise<SessionExtractionResult>;
 export {};

package/oh-my-opencode-slim.schema.json

@@ -331,6 +331,38 @@
         "type": "string"
       }
     },
+    "multiplexer": {
+      "type": "object",
+      "properties": {
+        "type": {
+          "default": "none",
+          "type": "string",
+          "enum": [
+            "auto",
+            "tmux",
+            "zellij",
+            "none"
+          ]
+        },
+        "layout": {
+          "default": "main-vertical",
+          "type": "string",
+          "enum": [
+            "main-horizontal",
+            "main-vertical",
+            "tiled",
+            "even-horizontal",
+            "even-vertical"
+          ]
+        },
+        "main_pane_size": {
+          "default": 60,
+          "type": "number",
+          "minimum": 20,
+          "maximum": 80
+        }
+      }
+    },
     "tmux": {
       "type": "object",
       "properties": {
@@ -357,6 +389,19 @@
         }
       }
     },
+    "websearch": {
+      "type": "object",
+      "properties": {
+        "provider": {
+          "default": "exa",
+          "type": "string",
+          "enum": [
+            "exa",
+            "tavily"
+          ]
+        }
+      }
+    },
     "background": {
       "type": "object",
       "properties": {
@@ -439,6 +484,11 @@
               "type": "string"
             }
           }
+        },
+        "retry_on_empty": {
+          "default": true,
+          "description": "When true (default), empty provider responses are treated as failures, triggering fallback/retry. Set to false to treat them as successes.",
+          "type": "boolean"
         }
       }
     },
@@ -505,6 +555,22 @@
             "type": "string",
             "pattern": "^[^/\\s]+\\/[^\\s]+$"
           }
+        },
+        "councillor_execution_mode": {
+          "default": "parallel",
+          "description": "Execution mode for councillors. \"serial\" runs them one at a time (required for single-model systems). \"parallel\" runs them concurrently (default, faster for multi-model systems).",
+          "type": "string",
+          "enum": [
+            "parallel",
+            "serial"
+          ]
+        },
+        "councillor_retries": {
+          "default": 3,
+          "description": "Number of retry attempts for councillors and master that return empty responses (e.g. due to provider rate limiting). Default: 3 retries.",
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 5
         }
       },
       "required": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode-slim",
-  "version": "0.8.6",
+  "version": "0.9.1",
   "description": "Lightweight agent orchestration plugin for OpenCode - a slimmed-down fork of oh-my-opencode",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -37,6 +37,9 @@
   ],
   "scripts": {
     "build": "bun build src/index.ts --outdir dist --target bun --format esm && bun build src/cli/index.ts --outdir dist/cli --target bun --format esm && tsc --emitDeclarationOnly && bun run generate-schema",
+    "contributors:add": "all-contributors add",
+    "contributors:check": "all-contributors check",
+    "contributors:generate": "all-contributors generate",
     "generate-schema": "bun run scripts/generate-schema.ts",
     "typecheck": "tsc --noEmit",
     "test": "bun test",
@@ -63,6 +66,7 @@
   "devDependencies": {
     "@biomejs/biome": "2.4.2",
     "@types/which": "^3.0.4",
+    "all-contributors-cli": "^6.26.1",
     "bun-types": "1.3.9",
     "typescript": "^5.9.3"
   },