@hiai-gg/hiai-opencode 0.2.0 → 0.2.2

package/dist/mcp/rate-limiter.d.ts

@@ -0,0 +1,68 @@
+/**
+ * MCP Rate Limiter with Circuit Breaker
+ *
+ * Provides per-MCP rate limiting with configurable:
+ * - maxRequestsPerMinute
+ * - maxTokensPerDay (approximated via request counting)
+ *
+ * Circuit breaker trips after 5 consecutive failures, resets after 60 seconds.
+ */
+export interface RateLimiterConfig {
+    maxRequestsPerMinute: number;
+    maxTokensPerDay?: number;
+    circuitBreakerThreshold?: number;
+    circuitBreakerResetMs?: number;
+}
+export declare class McpRateLimiter {
+    private requestLog;
+    private circuitBreaker;
+    private readonly config;
+    constructor(config: RateLimiterConfig);
+    /**
+     * Check if a request to the given MCP is allowed under rate limits.
+     * Returns an object with allowed flag and reset time if not allowed.
+     */
+    canMakeRequest(mcpName: string): {
+        allowed: boolean;
+        resetAt?: number;
+        retryAfterMs?: number;
+    };
+    /**
+     * Record a successful request to update rate tracking.
+     */
+    recordSuccess(mcpName: string): void;
+    /**
+     * Record a failed request. After 5 consecutive failures, the circuit breaker trips.
+     */
+    recordFailure(mcpName: string): void;
+    /**
+     * Get current rate limit status for an MCP.
+     */
+    getStatus(mcpName: string): {
+        requestsLastMinute: number;
+        limitPerMinute: number;
+        circuitBreakerOpen: boolean;
+        consecutiveFailures: number;
+    };
+    /**
+     * Build a clear quota exhaustion error message.
+     */
+    buildQuotaExhaustedError(mcpName: string, limitType: "rate" | "circuit_breaker"): string;
+    /**
+     * Reset all rate limit state for an MCP.
+     */
+    reset(mcpName: string): void;
+    /**
+     * Reset all rate limiters globally.
+     */
+    resetAll(): void;
+    private getCircuitBreakerState;
+}
+export declare const defaultRateLimiters: {
+    stitch: McpRateLimiter;
+    context7: McpRateLimiter;
+    grep_app: McpRateLimiter;
+    "sequential-thinking": McpRateLimiter;
+    mempalace: McpRateLimiter;
+};
+export declare function createMcpRateLimiter(_mcpName: string, config?: Partial<RateLimiterConfig>): McpRateLimiter;

package/dist/plugin/chat-message.d.ts

@@ -22,6 +22,14 @@ export type ChatMessageInput = {
         modelID: string;
     };
 };
+type RawLoopCommand = {
+    command: "ralph-loop" | "ulw-loop";
+    args: string;
+} | {
+    command: "cancel-ralph";
+    args: "";
+};
+export declare function parseRawLoopSlashCommand(promptText: string): RawLoopCommand | null;
 export declare function createChatMessageHandler(args: {
     ctx: PluginContext;
     pluginConfig: HiaiOpenCodeConfig;

package/dist/plugin/command-execute-before.d.ts

@@ -12,7 +12,7 @@ type CommandExecuteBeforeOutput = {
     }>;
     message?: Record<string, unknown>;
 };
-declare const NATIVE_LOOP_TRIGGERED_FLAG = "__omoNativeLoopTriggered";
+declare const NATIVE_LOOP_TRIGGERED_FLAG = "__hiaiNativeLoopTriggered";
 export declare function createCommandExecuteBeforeHandler(args: {
     hooks: CreatedHooks;
 }): (input: CommandExecuteBeforeInput, output: CommandExecuteBeforeOutput) => Promise<void>;

package/dist/plugin/event-handlers/message-updated.d.ts

@@ -0,0 +1,2 @@
+import type { EventInput, EventHandlerDeps } from "./types";
+export declare function handleMessageUpdated(input: EventInput, deps: EventHandlerDeps): Promise<void>;

package/dist/plugin/event-handlers/session-error.d.ts

@@ -0,0 +1,2 @@
+import type { EventInput, EventHandlerDeps } from "./types";
+export declare function handleSessionError(input: EventInput, deps: EventHandlerDeps): Promise<void>;

package/dist/plugin/event-handlers/session-status.d.ts

@@ -0,0 +1,2 @@
+import type { EventInput, EventHandlerDeps } from "./types";
+export declare function handleSessionStatus(input: EventInput, deps: EventHandlerDeps): Promise<void>;

package/dist/plugin/event-handlers/types.d.ts

@@ -0,0 +1,62 @@
+import type { HiaiOpenCodeConfig } from "../../config";
+import type { CreatedHooks } from "../../create-hooks";
+import type { Managers } from "../../create-managers";
+export type EventInput = Parameters<NonNullable<NonNullable<CreatedHooks["writeExistingFileGuard"]>["event"]>>[0];
+export type PluginContextTyped = {
+    directory: string;
+    client: {
+        session: {
+            abort: (input: {
+                path: {
+                    id: string;
+                };
+            }) => Promise<unknown>;
+            promptAsync?: (input: {
+                path: {
+                    id: string;
+                };
+                body: {
+                    parts: Array<{
+                        type: "text";
+                        text: string;
+                    }>;
+                };
+                query: {
+                    directory: string;
+                };
+            }) => Promise<unknown>;
+            prompt: (input: {
+                path: {
+                    id: string;
+                };
+                body: {
+                    parts: Array<{
+                        type: "text";
+                        text: string;
+                    }>;
+                };
+                query: {
+                    directory: string;
+                };
+            }) => Promise<unknown>;
+            summarize: (...args: unknown[]) => Promise<unknown>;
+        };
+    };
+};
+export type EventHandlerDeps = {
+    pluginContext: PluginContextTyped;
+    pluginConfig: HiaiOpenCodeConfig;
+    hooks: CreatedHooks;
+    managers: Managers;
+    isRuntimeFallbackEnabled: boolean;
+    isModelFallbackEnabled: boolean;
+    lastKnownModelBySession: Map<string, {
+        providerID: string;
+        modelID: string;
+    }>;
+    lastHandledModelErrorMessageID: Map<string, string>;
+    lastHandledRetryStatusKey: Map<string, string>;
+    resolveFallbackProviderID: (sessionID: string, providerHint?: string) => string;
+    shouldAutoRetrySession: (sessionID: string) => boolean;
+    autoContinueAfterFallback: (sessionID: string, source: string) => Promise<void>;
+};

package/dist/plugin/event-handlers/utils.d.ts

@@ -0,0 +1,11 @@
+import type { HiaiOpenCodeConfig } from "../../config";
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function normalizeFallbackModelID(modelID: string): string;
+export declare function extractErrorName(error: unknown): string | undefined;
+export declare function extractErrorMessage(error: unknown): string;
+export declare function extractProviderModelFromErrorMessage(message: string): {
+    providerID?: string;
+    modelID?: string;
+};
+export declare function applyUserConfiguredFallbackChain(sessionID: string, agentName: string, currentProviderID: string, pluginConfig: HiaiOpenCodeConfig): void;
+export declare function isCompactionAgent(agent: string): boolean;

package/dist/plugin/event.d.ts

@@ -2,6 +2,7 @@ import type { HiaiOpenCodeConfig } from "../config";
 import type { PluginContext } from "./types";
 import type { CreatedHooks } from "../create-hooks";
 import type { Managers } from "../create-managers";
+import type { EventInput } from "./event-handlers/types";
 type FirstMessageVariantGate = {
     markSessionCreated: (sessionInfo: {
         id?: string;
@@ -10,7 +11,6 @@ type FirstMessageVariantGate = {
     } | undefined) => void;
     clear: (sessionID: string) => void;
 };
-type EventInput = Parameters<NonNullable<NonNullable<CreatedHooks["writeExistingFileGuard"]>["event"]>>[0];
 export declare function createEventHandler(args: {
     ctx: PluginContext;
     pluginConfig: HiaiOpenCodeConfig;

package/dist/shared/data-path.d.ts

@@ -22,7 +22,7 @@ export declare function getCacheDir(): string;
  * Returns the hiai-opencode cache directory.
  * All platforms: ~/.cache/hiai-opencode
  */
-export declare function getOmoOpenCodeCacheDir(): string;
+export declare function getHiaiOpenCodeCacheDir(): string;
 /**
  * Returns the OpenCode cache directory (for reading OpenCode's cache).
  * All platforms: ~/.cache/opencode

package/dist/shared/errors.d.ts

@@ -0,0 +1,70 @@
+export declare const ErrorCodes: {
+    readonly AGENT_NOT_FOUND: "HIAI_AGENT_NOT_FOUND";
+    readonly AGENT_COMMUNICATION_FAILED: "HIAI_AGENT_COMMUNICATION_FAILED";
+    readonly AGENT_TIMEOUT: "HIAI_AGENT_TIMEOUT";
+    readonly CONFIG_INVALID: "HIAI_CONFIG_INVALID";
+    readonly CONFIG_MISSING_REQUIRED: "HIAI_CONFIG_MISSING_REQUIRED";
+    readonly CONFIG_LOAD_FAILED: "HIAI_CONFIG_LOAD_FAILED";
+    readonly HOOK_BLOCKED: "HIAI_HOOK_BLOCKED";
+    readonly HOOK_EXECUTION_FAILED: "HIAI_HOOK_EXECUTION_FAILED";
+    readonly MCP_CONNECTION_FAILED: "HIAI_MCP_CONNECTION_FAILED";
+    readonly MCP_SERVER_NOT_FOUND: "HIAI_MCP_SERVER_NOT_FOUND";
+    readonly MCP_INVALID_RESPONSE: "HIAI_MCP_INVALID_RESPONSE";
+    readonly TASK_NOT_FOUND: "HIAI_TASK_NOT_FOUND";
+    readonly TASK_SESSION_MISSING: "HIAI_TASK_SESSION_MISSING";
+    readonly TASK_PROMPT_FAILED: "HIAI_TASK_PROMPT_FAILED";
+    readonly TASK_DELEGATION_FAILED: "HIAI_TASK_DELEGATION_FAILED";
+    readonly IO_FILE_NOT_FOUND: "HIAI_IO_FILE_NOT_FOUND";
+    readonly IO_PERMISSION_DENIED: "HIAI_IO_PERMISSION_DENIED";
+    readonly IO_ARCHIVE_INVALID: "HIAI_IO_ARCHIVE_INVALID";
+    readonly VALIDATION_FAILED: "HIAI_VALIDATION_FAILED";
+    readonly VALIDATION_ARGUMENT_MISSING: "HIAI_VALIDATION_ARGUMENT_MISSING";
+};
+export type ErrorCode = (typeof ErrorCodes)[keyof typeof ErrorCodes] | string;
+export declare class HiaiOpenCodeError extends Error {
+    readonly code: string;
+    readonly category: string;
+    constructor(message: string, code: string, category: string);
+    toString(): string;
+}
+export declare class AgentError extends HiaiOpenCodeError {
+    constructor(message: string, code?: string);
+    static notFound(agentName: string): AgentError;
+    static timeout(agentName: string, timeoutMs?: number): AgentError;
+    static communicationFailed(agentName: string, cause: unknown): AgentError;
+}
+export declare class ConfigError extends HiaiOpenCodeError {
+    constructor(message: string, code?: string);
+    static missingRequired(field: string): ConfigError;
+    static invalid(message: string): ConfigError;
+    static loadFailed(path: string, cause: unknown): ConfigError;
+}
+export declare class HookError extends HiaiOpenCodeError {
+    constructor(message: string, code?: string);
+    static blocked(reason: string): HookError;
+    static executionFailed(hookName: string, cause: unknown): HookError;
+}
+export declare class McpError extends HiaiOpenCodeError {
+    constructor(message: string, code?: string);
+    static connectionFailed(serverName: string, cause: unknown): McpError;
+    static serverNotFound(serverName: string): McpError;
+    static invalidResponse(serverName: string, details: string): McpError;
+}
+export declare class TaskError extends HiaiOpenCodeError {
+    constructor(message: string, code?: string);
+    static notFound(taskId: string): TaskError;
+    static sessionMissing(taskId: string): TaskError;
+    static promptFailed(agentName: string, cause: unknown): TaskError;
+    static delegationFailed(details: string): TaskError;
+}
+export declare class ValidationError extends HiaiOpenCodeError {
+    constructor(message: string, code?: string);
+    static missingArg(argumentName: string): ValidationError;
+    static failed(details: string): ValidationError;
+}
+export declare class IoError extends HiaiOpenCodeError {
+    constructor(message: string, code?: string);
+    static fileNotFound(path: string): IoError;
+    static permissionDenied(path: string): IoError;
+    static archiveInvalid(details: string): IoError;
+}

package/dist/shared/extract-session-id.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Extract sessionID from event properties.
+ *
+ * Handles two common OpenCode event shapes:
+ * - `props.sessionID` (direct field)
+ * - `props.info.id` (nested in info object)
+ */
+export declare function extractSessionID(props: unknown): string | undefined;

package/dist/shared/git-worktree/get-git-state-summary.d.ts

@@ -0,0 +1,14 @@
+export interface GitStateSummary {
+    branch: string;
+    hasUncommittedChanges: boolean;
+    uncommittedCount: number;
+    stagedCount: number;
+    unstagedCount: number;
+    untrackedCount: number;
+    cleanWorkingTree: boolean;
+}
+/**
+ * Gathers a lightweight summary of current git state for Manager to use
+ * before making delegation decisions. Does NOT run git diff (expensive).
+ */
+export declare function getGitStateSummary(directory: string): GitStateSummary | null;

package/dist/shared/index.d.ts

@@ -1,73 +1,72 @@
-export * from "./frontmatter";
-export * from "./command-executor";
-export * from "./contains-path";
-export * from "./file-reference-resolver";
-export * from "./model-sanitizer";
-export * from "./logger";
-export * from "./snake-case";
-export * from "./tool-name";
-export * from "./pattern-matcher";
-export * from "./hook-disabled";
-export * from "./deep-merge";
-export * from "./file-utils";
-export * from "./dynamic-truncator";
-export * from "./data-path";
-export * from "./learn-system";
-export * from "./config-errors";
-export * from "./claude-config-dir";
-export * from "./agents-config-dir";
-export * from "./jsonc-parser";
-export * from "./migration";
-export * from "./opencode-config-dir";
-export * from "./resolve-agent-definition-paths";
+export { parseFrontmatter, type FrontmatterResult } from "./frontmatter";
+export { executeHookCommand, executeCommand, resolveCommandsInText, type CommandResult, type ExecuteHookOptions } from "./command-executor";
+export { containsPath, isWithinProject } from "./contains-path";
+export { resolveFileReferencesInText } from "./file-reference-resolver";
+export { sanitizeModelField } from "./model-sanitizer";
+export { log, logDebug, logWarn, logError, getLogFilePath, setLogLevel, getLogLevel, setLogLevelFromEnv } from "./logger";
+export { camelToSnake, snakeToCamel, transformObjectKeys, objectToSnakeCase, objectToCamelCase } from "./snake-case";
+export { transformToolName } from "./tool-name";
+export { matchesToolMatcher, findMatchingHooks } from "./pattern-matcher";
+export { isHookDisabled } from "./hook-disabled";
+export { isPlainObject, deepMerge } from "./deep-merge";
+export { isMarkdownFile, isSymbolicLink, resolveSymlink, resolveSymlinkAsync } from "./file-utils";
+export { truncateToTokenLimit, getContextWindowUsage, dynamicTruncate, createDynamicTruncator, type TruncationResult, type TruncationOptions } from "./dynamic-truncator";
+export { getDataDir, getOpenCodeStorageDir, getCacheDir, getHiaiOpenCodeCacheDir, getOpenCodeCacheDir } from "./data-path";
+export { captureLearn, getRelevantLearns, getRecentLearns, formatLearnEntriesForPrompt, type LearnEntry } from "./learn-system";
+export { getConfigLoadErrors, clearConfigLoadErrors, addConfigLoadError, type ConfigLoadError } from "./config-errors";
+export { getClaudeConfigDir } from "./claude-config-dir";
+export { getAgentsConfigDir } from "./agents-config-dir";
+export { parseJsonc, parseJsoncSafe, readJsoncFile, detectConfigFile, detectPluginConfigFile, type JsoncParseResult } from "./jsonc-parser";
+export { AGENT_NAME_MAP, BUILTIN_AGENT_NAMES, migrateAgentNames, HOOK_NAME_MAP, migrateHookNames, MODEL_VERSION_MAP, migrateModelVersions, MODEL_TO_CATEGORY_MAP, migrateAgentConfigToCategory, shouldDeleteAgentConfig, migrateConfigFile } from "./migration";
+export { TAURI_APP_IDENTIFIER, TAURI_APP_IDENTIFIER_DEV, isDevBuild, getOpenCodeConfigDir, getOpenCodeConfigPaths, detectExistingConfigDir } from "./opencode-config-dir";
+export { resolveAgentDefinitionPaths } from "./resolve-agent-definition-paths";
 export type { OpenCodeBinaryType, OpenCodeConfigDirOptions, OpenCodeConfigPaths, } from "./opencode-config-dir-types";
-export * from "./opencode-version";
-export * from "./opencode-storage-detection";
-export * from "./permission-compat";
-export * from "./external-plugin-detector";
-export * from "./zip-extractor";
-export * from "./binary-downloader";
-export * from "./write-file-atomically";
-export * from "./agent-variant";
-export * from "./session-cursor";
-export * from "./shell-env";
-export * from "./system-directive";
-export * from "./agent-tool-restrictions";
-export * from "./model-requirements";
-export * from "./model-resolver";
+export { MINIMUM_OPENCODE_VERSION, OPENCODE_NATIVE_AGENTS_INJECTION_VERSION, OPENCODE_SQLITE_VERSION, parseVersion, compareVersions, getOpenCodeVersion, isOpenCodeVersionAtLeast, resetVersionCache, setVersionCache } from "./opencode-version";
+export { isSqliteBackend, resetSqliteBackendCache } from "./opencode-storage-detection";
+export { createAgentToolRestrictions, createAgentToolAllowlist, migrateToolsToPermission, migrateAgentConfig, type PermissionValue, type PermissionFormat } from "./permission-compat";
+export { detectExternalNotificationPlugin, detectExternalSkillPlugin, getNotificationConflictWarning, getSkillPluginConflictWarning, type ExternalNotifierResult, type ExternalSkillPluginResult } from "./external-plugin-detector";
+export { extractZip } from "./zip-extractor";
+export { getCachedBinaryPath, ensureCacheDir, downloadArchive, extractTarGz, extractZipArchive, cleanupArchive, ensureExecutable } from "./binary-downloader";
+export { writeFileAtomically } from "./write-file-atomically";
+export { resolveAgentVariant, resolveVariantForModel, applyAgentVariant } from "./agent-variant";
+export { consumeNewMessages, resetMessageCursor, getMessageCursor, restoreMessageCursor, type CursorMessage, type CursorState } from "./session-cursor";
+export { detectShellType, shellEscape, buildEnvPrefix, shellEscapeForDoubleQuotedCommand, type ShellType } from "./shell-env";
+export { SYSTEM_DIRECTIVE_PREFIX, createSystemDirective, isSystemDirective, hasSystemReminder, removeSystemReminders, SystemDirectiveTypes, type SystemDirectiveType } from "./system-directive";
+export { getAgentToolRestrictions, hasAgentToolRestrictions } from "./agent-tool-restrictions";
+export { AGENT_MODEL_REQUIREMENTS, CATEGORY_MODEL_REQUIREMENTS, initializeModelRequirements, type FallbackEntry, type ModelRequirement } from "./model-requirements";
+export { resolveModel, resolveModelWithFallback, normalizeFallbackModels, flattenToFallbackModelStrings, type ModelResolutionInput, type ModelSource, type ExtendedModelResolutionInput } from "./model-resolver";
 export { normalizeModel, normalizeModelID } from "./model-normalization";
-export { normalizeFallbackModels, flattenToFallbackModelStrings } from "./model-resolver";
 export { resolveModelPipeline } from "./model-resolution-pipeline";
 export type { ModelResolutionRequest, ModelResolutionProvenance, ModelResolutionResult, } from "./model-resolution-types";
-export * from "./model-availability";
-export * from "./model-capabilities";
-export * from "./model-capabilities-cache";
-export * from "./model-capability-heuristics";
-export * from "./model-settings-compatibility";
-export * from "./fallback-model-availability";
-export * from "./connected-providers-cache";
-export * from "./context-limit-resolver";
-export * from "./session-utils";
-export * from "./tmux";
-export * from "./model-suggestion-retry";
-export * from "./opencode-server-auth";
-export * from "./opencode-http-api";
-export * from "./port-utils";
-export * from "./git-worktree";
-export * from "./safe-create-hook";
-export * from "./truncate-description";
-export * from "./opencode-storage-paths";
-export * from "./opencode-message-dir";
-export * from "./opencode-command-dirs";
-export * from "./project-discovery-dirs";
-export * from "./normalize-sdk-response";
-export * from "./session-directory-resolver";
-export * from "./prompt-tools";
-export * from "./compaction-marker";
-export * from "./internal-initiator-marker";
-export * from "./plugin-command-discovery";
+export { fuzzyMatchModel, isModelAvailable, getConnectedProviders, fetchAvailableModels, __resetModelCache, isModelCacheAvailable } from "./model-availability";
+export { getBundledModelCapabilitiesSnapshot, getModelCapabilities, type GetModelCapabilitiesInput, type ModelCapabilities, type ModelCapabilitiesDiagnostics, type ModelCapabilitiesSnapshot, type ModelCapabilitiesSnapshotEntry } from "./model-capabilities";
+export { MODELS_DEV_SOURCE_URL, buildModelCapabilitiesSnapshotFromModelsDev, fetchModelCapabilitiesSnapshot, createModelCapabilitiesCacheStore, readModelCapabilitiesCache, hasModelCapabilitiesCache, writeModelCapabilitiesCache, refreshModelCapabilitiesCache } from "./model-capabilities-cache";
+export { initializeModelHeuristics, detectHeuristicModelFamily } from "./model-capability-heuristics";
+export { resolveCompatibleModelSettings, type ModelSettingsCompatibilityInput, type ModelSettingsCompatibilityChange, type ModelSettingsCompatibilityResult } from "./model-settings-compatibility";
+export { resolveFirstAvailableFallback, isAnyFallbackModelAvailable, isAnyProviderConnected } from "./fallback-model-availability";
+export { createConnectedProvidersCacheStore, findProviderModelMetadata, readConnectedProvidersCache, hasConnectedProvidersCache, readProviderModelsCache, hasProviderModelsCache, writeProviderModelsCache, updateConnectedProvidersCache, _resetMemCacheForTesting, type ModelMetadata, type ProviderModelsCache } from "./connected-providers-cache";
+export { resolveActualContextLimit, type ContextLimitModelCacheState } from "./context-limit-resolver";
+export { isCallerOrchestrator } from "./session-utils";
+export { isInsideTmux, getCurrentPaneId, isServerRunning, resetServerCheck, markServerRunningInProcess, getPaneDimensions, spawnTmuxPane, closeTmuxPane, replaceTmuxPane, spawnTmuxWindow, spawnTmuxSession, applyLayout, enforceMainPaneWidth, POLL_INTERVAL_BACKGROUND_MS, SESSION_TIMEOUT_MS, SESSION_MISSING_GRACE_MS, SESSION_READY_POLL_INTERVAL_MS, SESSION_READY_TIMEOUT_MS, type SpawnPaneResult, type SplitDirection, type PaneDimensions } from "./tmux";
+export { parseModelSuggestion, promptWithModelSuggestionRetry, promptSyncWithModelSuggestionRetry, type ModelSuggestionInfo } from "./model-suggestion-retry";
+export { getServerBasicAuthHeader, injectServerAuthIntoClient } from "./opencode-server-auth";
+export { getServerBaseUrl, patchPart, deletePart } from "./opencode-http-api";
+export { isPortAvailable, findAvailablePort, getAvailableServerPort, DEFAULT_SERVER_PORT, type AutoPortResult } from "./port-utils";
+export { parseGitStatusPorcelainLine, parseGitStatusPorcelain, parseGitDiffNumstat, collectGitDiffStats, formatFileChanges, type GitFileStatus, type GitFileStat, type ParsedGitStatusPorcelainLine } from "./git-worktree";
+export { safeCreateHook } from "./safe-create-hook";
+export { truncateDescription } from "./truncate-description";
+export { OPENCODE_STORAGE, MESSAGE_STORAGE, PART_STORAGE, SESSION_STORAGE } from "./opencode-storage-paths";
+export { getMessageDir } from "./opencode-message-dir";
+export { getOpenCodeCommandDirs, getOpenCodeSkillDirs } from "./opencode-command-dirs";
+export { findProjectClaudeSkillDirs, findProjectAgentsSkillDirs, findProjectOpencodeSkillDirs, findProjectOpencodeCommandDirs } from "./project-discovery-dirs";
+export { normalizeSDKResponse, type NormalizeSDKResponseOptions } from "./normalize-sdk-response";
+export { isWindowsAppDataDirectory, resolveSessionDirectory } from "./session-directory-resolver";
+export { normalizePromptTools, resolveInheritedPromptTools, type PromptToolPermission } from "./prompt-tools";
+export { isCompactionAgent, hasCompactionPart, isCompactionMessage, getCompactionPartStorageDir, hasCompactionPartInStorage } from "./compaction-marker";
+export { HIAI_INTERNAL_INITIATOR_MARKER, stripInternalInitiatorMarkers, createInternalAgentTextPart } from "./internal-initiator-marker";
+export { discoverPluginCommandDefinitions, type PluginCommandDiscoveryOptions } from "./plugin-command-discovery";
 export { SessionCategoryRegistry } from "./session-category-registry";
-export * from "./plugin-identity";
-export * from "./log-legacy-plugin-startup-warning";
-export * from "./task-system-enabled";
-export * from "./parse-tools-config";
+export { PLUGIN_NAME, LEGACY_PLUGIN_NAME, PUBLISHED_PACKAGE_NAME, ACCEPTED_PACKAGE_NAMES, CONFIG_BASENAME, LEGACY_CONFIG_BASENAME, LOG_FILENAME, CACHE_DIR_NAME } from "./plugin-identity";
+export { logLegacyPluginStartupWarning } from "./log-legacy-plugin-startup-warning";
+export { isTaskSystemEnabled, type TaskSystemConfig } from "./task-system-enabled";
+export { parseToolsConfig } from "./parse-tools-config";

package/dist/shared/internal-initiator-marker.d.ts

@@ -1,4 +1,4 @@
-export declare const OMO_INTERNAL_INITIATOR_MARKER = "<!-- OMO_INTERNAL_INITIATOR -->";
+export declare const HIAI_INTERNAL_INITIATOR_MARKER = "<!-- HIAI_INTERNAL_INITIATOR -->";
 export declare function stripInternalInitiatorMarkers(text: string): string;
 export declare function createInternalAgentTextPart(text: string): {
     type: "text";

package/dist/shared/logger.d.ts

@@ -1,4 +1,8 @@
-export declare function log(message: string, data?: unknown): void;
+export declare function log(message: string, data?: unknown, level?: string): void;
+export declare function logDebug(message: string, data?: unknown): void;
 export declare function logWarn(message: string, data?: unknown): void;
 export declare function logError(message: string, data?: unknown): void;
 export declare function getLogFilePath(): string;
+export declare function setLogLevel(level: string): void;
+export declare function getLogLevel(): string;
+export declare function setLogLevelFromEnv(): void;

package/dist/shared/reasoning-content-cache.d.ts

@@ -0,0 +1,68 @@
+/**
+ * MITIGATION ONLY - upstream fix required
+ *
+ * This module provides a temporary cache for reasoning_content that gets stripped
+ * during message serialization in OpenAI-compatible SDKs. The root cause is an upstream
+ * bug where reasoning_content fields are lost when messages are processed through
+ * the SDK's message handling pipeline.
+ *
+ * The actual fix requires an update to the upstream SDK. This cache is a workaround
+ * that stores reasoning_content separately and allows reinjection when needed.
+ *
+ * Usage:
+ *   1. Before message serialization: cache.save(sessionId, index, content)
+ *   2. After message deserialization: cache.retrieve(sessionId, index)
+ *   3. To restore: messages = cache.reinjectIntoMessages(sessionId, messages)
+ */
+export declare class ReasoningContentCache {
+    private cache;
+    private readonly TTL_MS;
+    private makeKey;
+    /**
+     * Save reasoning_content for a specific message in a session.
+     * @param sessionId - The session identifier
+     * @param index - The message index in the session
+     * @param content - The reasoning_content string to cache
+     */
+    save(sessionId: string, index: number, content: string): void;
+    /**
+     * Retrieve cached reasoning_content for a specific message.
+     * @param sessionId - The session identifier
+     * @param index - The message index in the session
+     * @returns The cached content or null if not found/expired
+     */
+    retrieve(sessionId: string, index: number): string | null;
+    /**
+     * Reinject reasoning_content into messages that may have lost it during serialization.
+     * This iterates through messages and restores reasoning_content from the cache where
+     * the field is missing or empty but we have a cached value.
+     *
+     * Handles two message structures:
+     * - MessageWithParts (with info/reasoning_content at msg.info.reasoning_content)
+     * - Flat objects (with reasoning_content at msg.reasoning_content, legacy path)
+     *
+     * @param sessionId - The session identifier
+     * @param messages - The messages array to process
+     * @returns Messages with reasoning_content restored where applicable
+     */
+    reinjectIntoMessages(sessionId: string, messages: unknown[]): unknown[];
+    /**
+     * Clear all cache entries for a specific session.
+     * Call this when a session is cleaned up.
+     */
+    clearSession(sessionId: string): void;
+    /**
+     * Clear all expired entries. Called automatically on retrieve,
+     * but can be triggered manually for batch cleanup.
+     */
+    clearExpired(): number;
+    /**
+     * Get cache statistics for monitoring.
+     */
+    stats(): {
+        size: number;
+        oldestTimestamp: number | null;
+        newestTimestamp: number | null;
+    };
+}
+export declare const reasoningContentCache: ReasoningContentCache;

package/dist/shared/safe-create-hook.d.ts

@@ -1,5 +1,5 @@
-interface SafeCreateHookOptions {
+export declare function safeCreateHook<T>(hookNameOrFactory: string | (() => T | null), factoryOrOptions?: (() => T | null) | {
     enabled?: boolean;
-}
-export declare function safeCreateHook<T>(name: string, factory: () => T, options?: SafeCreateHookOptions): T | null;
-export {};
+}, options?: {
+    enabled?: boolean;
+}): T | null;

package/dist/tools/call-hiai-agent/constants.d.ts

@@ -1,3 +1,3 @@
-export declare const PRIMARY_ALLOWED_AGENTS: readonly ["researcher", "strategist", "coder", "critic", "designer", "writer", "multimodal"];
-export declare const ALLOWED_AGENTS: readonly ["researcher", "strategist", "coder", "critic", "designer", "writer", "multimodal"];
+export declare const PRIMARY_ALLOWED_AGENTS: readonly ["researcher", "strategist", "coder", "critic", "designer", "writer", "vision"];
+export declare const ALLOWED_AGENTS: readonly ["researcher", "strategist", "coder", "critic", "designer", "writer", "vision"];
 export declare const CALL_HIAI_AGENT_DESCRIPTION = "Spawn canonical agents or custom agents. run_in_background REQUIRED (true=async with task_id, false=sync).\n\nCanonical built-in agents:\n{primary_agents}\n\nCustom agents registered via user or project agent directories are also supported.\n\nPass `session_id=<id>` to continue previous agent with full context. Nested subagent depth is tracked automatically and blocked past the configured limit. Prompts MUST be in English. Use `background_output` for async results.";

package/dist/tools/delegate-task/sub-agent.d.ts

@@ -1,7 +1,7 @@
 export declare const SUB_AGENT_CONFIG_KEY = "sub";
 export declare const CODER_AGENT_CONFIG_KEY = "coder";
 export declare const CRITIC_AGENT_CONFIG_KEY = "critic";
-export declare const CANONICAL_DELEGATE_AGENT_KEYS: readonly ["bob", "manager", "strategist", "critic", "coder", "sub", "researcher", "multimodal", "designer", "writer", "agent-skills"];
+export declare const CANONICAL_DELEGATE_AGENT_KEYS: readonly ["bob", "manager", "strategist", "critic", "coder", "sub", "researcher", "vision", "designer", "writer", "agent-skills"];
 type CanonicalDelegateAgentKey = (typeof CANONICAL_DELEGATE_AGENT_KEYS)[number];
 export type { CanonicalDelegateAgentKey };
 export declare function resolveCanonicalDelegateAgentKey(agentName: string): string;

package/dist/tools/look-at/constants.d.ts

@@ -1,2 +1,2 @@
-export declare const MULTIMODAL_LOOKER_AGENT: "ui";
+export declare const MULTIMODAL_LOOKER_AGENT: "vision";
 export declare const LOOK_AT_DESCRIPTION = "Extract basic information from media files (PDFs, images, diagrams) when a quick summary suffices over precise reading. Good for simple text-based content extraction without using the Read tool. NEVER use for visual precision, aesthetic evaluation, or exact accuracy - use Read tool instead for those cases.";