oh-my-opencode 3.3.2 → 3.5.0

package/dist/features/tmux-subagent/manager.d.ts

@@ -33,20 +33,18 @@ export declare class TmuxSessionManager {
     private sourcePaneId;
     private sessions;
     private pendingSessions;
-    private pollInterval?;
     private deps;
+    private pollingManager;
     constructor(ctx: PluginInput, tmuxConfig: TmuxConfig, deps?: TmuxUtilDeps);
     private isEnabled;
     private getCapacityConfig;
     private getSessionMappings;
     private waitForSessionReady;
+    private pollSessions;
     onSessionCreated(event: SessionCreatedEvent): Promise<void>;
     onSessionDeleted(event: {
         sessionID: string;
     }): Promise<void>;
-    private startPolling;
-    private stopPolling;
-    private pollSessions;
     private closeSessionById;
     createEventHandler(): (input: {
         event: {

package/dist/features/tmux-subagent/oldest-agent-pane.d.ts

@@ -0,0 +1,7 @@
+import type { TmuxPaneInfo } from "./types";
+export interface SessionMapping {
+    sessionId: string;
+    paneId: string;
+    createdAt: Date;
+}
+export declare function findOldestAgentPane(agentPanes: TmuxPaneInfo[], sessionMappings: SessionMapping[]): TmuxPaneInfo | null;

package/dist/features/tmux-subagent/pane-split-availability.d.ts

@@ -0,0 +1,8 @@
+import type { SplitDirection, TmuxPaneInfo } from "./types";
+export declare function getColumnCount(paneCount: number): number;
+export declare function getColumnWidth(agentAreaWidth: number, paneCount: number): number;
+export declare function isSplittableAtCount(agentAreaWidth: number, paneCount: number): boolean;
+export declare function findMinimalEvictions(agentAreaWidth: number, currentCount: number): number | null;
+export declare function canSplitPane(pane: TmuxPaneInfo, direction: SplitDirection): boolean;
+export declare function canSplitPaneAnyDirection(pane: TmuxPaneInfo): boolean;
+export declare function getBestSplitDirection(pane: TmuxPaneInfo): SplitDirection | null;

package/dist/features/tmux-subagent/polling-constants.d.ts

@@ -0,0 +1,3 @@
+export declare const SESSION_TIMEOUT_MS: number;
+export declare const MIN_STABILITY_TIME_MS: number;
+export declare const STABLE_POLLS_REQUIRED = 3;

package/dist/features/tmux-subagent/polling-manager.d.ts

@@ -0,0 +1,12 @@
+import type { OpencodeClient } from "../../tools/delegate-task/types";
+import type { TrackedSession } from "./types";
+export declare class TmuxPollingManager {
+    private client;
+    private sessions;
+    private closeSessionById;
+    private pollInterval?;
+    constructor(client: OpencodeClient, sessions: Map<string, TrackedSession>, closeSessionById: (sessionId: string) => Promise<void>);
+    startPolling(): void;
+    stopPolling(): void;
+    private pollSessions;
+}

package/dist/features/tmux-subagent/polling.d.ts

@@ -0,0 +1,19 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { TmuxConfig } from "../../config/schema";
+import type { TrackedSession } from "./types";
+type OpencodeClient = PluginInput["client"];
+export interface SessionPollingController {
+    startPolling: () => void;
+    stopPolling: () => void;
+    closeSessionById: (sessionId: string) => Promise<void>;
+    waitForSessionReady: (sessionId: string) => Promise<boolean>;
+    pollSessions: () => Promise<void>;
+}
+export declare function createSessionPollingController(params: {
+    client: OpencodeClient;
+    tmuxConfig: TmuxConfig;
+    serverUrl: string;
+    sourcePaneId: string | undefined;
+    sessions: Map<string, TrackedSession>;
+}): SessionPollingController;
+export {};

package/dist/features/tmux-subagent/session-cleaner.d.ts

@@ -0,0 +1,23 @@
+import type { TmuxConfig } from "../../config/schema";
+import type { TrackedSession } from "./types";
+import type { SessionMapping } from "./decision-engine";
+import { TmuxPollingManager } from "./polling-manager";
+export interface TmuxUtilDeps {
+    isInsideTmux: () => boolean;
+    getCurrentPaneId: () => string | undefined;
+}
+export declare class SessionCleaner {
+    private tmuxConfig;
+    private deps;
+    private sessions;
+    private sourcePaneId;
+    private getSessionMappings;
+    private pollingManager;
+    private serverUrl;
+    constructor(tmuxConfig: TmuxConfig, deps: TmuxUtilDeps, sessions: Map<string, TrackedSession>, sourcePaneId: string | undefined, getSessionMappings: () => SessionMapping[], pollingManager: TmuxPollingManager, serverUrl: string);
+    private isEnabled;
+    onSessionDeleted(event: {
+        sessionID: string;
+    }): Promise<void>;
+    closeSessionById(sessionId: string): Promise<void>;
+}

package/dist/features/tmux-subagent/session-created-event.d.ts

@@ -0,0 +1,14 @@
+export interface SessionCreatedEvent {
+    type: string;
+    properties?: {
+        info?: {
+            id?: string;
+            parentID?: string;
+            title?: string;
+        };
+    };
+}
+export declare function coerceSessionCreatedEvent(input: {
+    type: string;
+    properties?: unknown;
+}): SessionCreatedEvent;

package/dist/features/tmux-subagent/session-created-handler.d.ts

@@ -0,0 +1,22 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { TmuxConfig } from "../../config/schema";
+import type { CapacityConfig, TrackedSession } from "./types";
+import { type SessionMapping } from "./decision-engine";
+import type { SessionCreatedEvent } from "./session-created-event";
+type OpencodeClient = PluginInput["client"];
+export interface SessionCreatedHandlerDeps {
+    client: OpencodeClient;
+    tmuxConfig: TmuxConfig;
+    serverUrl: string;
+    sourcePaneId: string | undefined;
+    sessions: Map<string, TrackedSession>;
+    pendingSessions: Set<string>;
+    isInsideTmux: () => boolean;
+    isEnabled: () => boolean;
+    getCapacityConfig: () => CapacityConfig;
+    getSessionMappings: () => SessionMapping[];
+    waitForSessionReady: (sessionId: string) => Promise<boolean>;
+    startPolling: () => void;
+}
+export declare function handleSessionCreated(deps: SessionCreatedHandlerDeps, event: SessionCreatedEvent): Promise<void>;
+export {};

package/dist/features/tmux-subagent/session-deleted-handler.d.ts

@@ -0,0 +1,15 @@
+import type { TmuxConfig } from "../../config/schema";
+import type { TrackedSession } from "./types";
+import { type SessionMapping } from "./decision-engine";
+export interface SessionDeletedHandlerDeps {
+    tmuxConfig: TmuxConfig;
+    serverUrl: string;
+    sourcePaneId: string | undefined;
+    sessions: Map<string, TrackedSession>;
+    isEnabled: () => boolean;
+    getSessionMappings: () => SessionMapping[];
+    stopPolling: () => void;
+}
+export declare function handleSessionDeleted(deps: SessionDeletedHandlerDeps, event: {
+    sessionID: string;
+}): Promise<void>;

package/dist/features/tmux-subagent/session-message-count.d.ts

@@ -0,0 +1 @@
+export declare function getMessageCount(data: unknown): number;

package/dist/features/tmux-subagent/session-ready-waiter.d.ts

@@ -0,0 +1,7 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+type OpencodeClient = PluginInput["client"];
+export declare function waitForSessionReady(params: {
+    client: OpencodeClient;
+    sessionId: string;
+}): Promise<boolean>;
+export {};

package/dist/features/tmux-subagent/session-spawner.d.ts

@@ -0,0 +1,34 @@
+import type { TmuxConfig } from "../../config/schema";
+import type { TrackedSession, CapacityConfig } from "./types";
+import { type SessionMapping } from "./decision-engine";
+import { TmuxPollingManager } from "./polling-manager";
+interface SessionCreatedEvent {
+    type: string;
+    properties?: {
+        info?: {
+            id?: string;
+            parentID?: string;
+            title?: string;
+        };
+    };
+}
+export interface TmuxUtilDeps {
+    isInsideTmux: () => boolean;
+    getCurrentPaneId: () => string | undefined;
+}
+export declare class SessionSpawner {
+    private tmuxConfig;
+    private deps;
+    private sessions;
+    private pendingSessions;
+    private sourcePaneId;
+    private getCapacityConfig;
+    private getSessionMappings;
+    private waitForSessionReady;
+    private pollingManager;
+    private serverUrl;
+    constructor(tmuxConfig: TmuxConfig, deps: TmuxUtilDeps, sessions: Map<string, TrackedSession>, pendingSessions: Set<string>, sourcePaneId: string | undefined, getCapacityConfig: () => CapacityConfig, getSessionMappings: () => SessionMapping[], waitForSessionReady: (sessionId: string) => Promise<boolean>, pollingManager: TmuxPollingManager, serverUrl: string);
+    private isEnabled;
+    onSessionCreated(event: SessionCreatedEvent): Promise<void>;
+}
+export {};

package/dist/features/tmux-subagent/session-status-parser.d.ts

@@ -0,0 +1,5 @@
+type SessionStatus = {
+    type: string;
+};
+export declare function parseSessionStatusMap(data: unknown): Record<string, SessionStatus>;
+export {};

package/dist/features/tmux-subagent/spawn-action-decider.d.ts

@@ -0,0 +1,4 @@
+import type { CapacityConfig, PaneAction, SpawnDecision, WindowState } from "./types";
+import { type SessionMapping } from "./oldest-agent-pane";
+export declare function decideSpawnActions(state: WindowState, sessionId: string, description: string, _config: CapacityConfig, sessionMappings: SessionMapping[]): SpawnDecision;
+export declare function decideCloseAction(state: WindowState, sessionId: string, sessionMappings: SessionMapping[]): PaneAction | null;

package/dist/features/tmux-subagent/spawn-target-finder.d.ts

@@ -0,0 +1,6 @@
+import type { SplitDirection, WindowState } from "./types";
+export interface SpawnTarget {
+    targetPaneId: string;
+    splitDirection: SplitDirection;
+}
+export declare function findSpawnTarget(state: WindowState): SpawnTarget | null;

package/dist/features/tmux-subagent/tmux-grid-constants.d.ts

@@ -0,0 +1,7 @@
+export declare const MAIN_PANE_RATIO = 0.5;
+export declare const MAX_COLS = 2;
+export declare const MAX_ROWS = 3;
+export declare const MAX_GRID_SIZE = 4;
+export declare const DIVIDER_SIZE = 1;
+export declare const MIN_SPLIT_WIDTH: number;
+export declare const MIN_SPLIT_HEIGHT: number;

package/dist/features/tool-metadata-store/index.d.ts

@@ -1,39 +1,2 @@
-/**
- * Pending tool metadata store.
- *
- * OpenCode's `fromPlugin()` wrapper always replaces the metadata returned by
- * plugin tools with `{ truncated, outputPath }`, discarding any sessionId,
- * title, or custom metadata set during `execute()`.
- *
- * This store captures metadata written via `ctx.metadata()` inside execute(),
- * then the `tool.execute.after` hook consumes it and merges it back into the
- * result *before* the processor writes the final part to the session store.
- *
- * Flow:
- *   execute() → storeToolMetadata(sessionID, callID, data)
- *   fromPlugin() → overwrites metadata with { truncated }
- *   tool.execute.after → consumeToolMetadata(sessionID, callID) → merges back
- *   processor → Session.updatePart(status:"completed", metadata: result.metadata)
- */
-export interface PendingToolMetadata {
-    title?: string;
-    metadata?: Record<string, unknown>;
-}
-/**
- * Store metadata to be restored after fromPlugin() overwrites it.
- * Called from tool execute() functions alongside ctx.metadata().
- */
-export declare function storeToolMetadata(sessionID: string, callID: string, data: PendingToolMetadata): void;
-/**
- * Consume stored metadata (one-time read, removes from store).
- * Called from tool.execute.after hook.
- */
-export declare function consumeToolMetadata(sessionID: string, callID: string): PendingToolMetadata | undefined;
-/**
- * Get current store size (for testing/debugging).
- */
-export declare function getPendingStoreSize(): number;
-/**
- * Clear all pending metadata (for testing).
- */
-export declare function clearPendingStore(): void;
+export { clearPendingStore, consumeToolMetadata, getPendingStoreSize, storeToolMetadata, } from "./store";
+export type { PendingToolMetadata } from "./store";

package/dist/features/tool-metadata-store/store.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Pending tool metadata store.
+ *
+ * OpenCode's `fromPlugin()` wrapper always replaces the metadata returned by
+ * plugin tools with `{ truncated, outputPath }`, discarding any sessionId,
+ * title, or custom metadata set during `execute()`.
+ *
+ * This store captures metadata written via `ctx.metadata()` inside execute(),
+ * then the `tool.execute.after` hook consumes it and merges it back into the
+ * result *before* the processor writes the final part to the session store.
+ *
+ * Flow:
+ *   execute() → storeToolMetadata(sessionID, callID, data)
+ *   fromPlugin() → overwrites metadata with { truncated }
+ *   tool.execute.after → consumeToolMetadata(sessionID, callID) → merges back
+ *   processor → Session.updatePart(status:"completed", metadata: result.metadata)
+ */
+export interface PendingToolMetadata {
+    title?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Store metadata to be restored after fromPlugin() overwrites it.
+ * Called from tool execute() functions alongside ctx.metadata().
+ */
+export declare function storeToolMetadata(sessionID: string, callID: string, data: PendingToolMetadata): void;
+/**
+ * Consume stored metadata (one-time read, removes from store).
+ * Called from tool.execute.after hook.
+ */
+export declare function consumeToolMetadata(sessionID: string, callID: string): PendingToolMetadata | undefined;
+/**
+ * Get current store size (for testing/debugging).
+ */
+export declare function getPendingStoreSize(): number;
+/**
+ * Clear all pending metadata (for testing).
+ */
+export declare function clearPendingStore(): void;

package/dist/hooks/agent-usage-reminder/hook.d.ts

@@ -0,0 +1,22 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+interface ToolExecuteInput {
+    tool: string;
+    sessionID: string;
+    callID: string;
+}
+interface ToolExecuteOutput {
+    title: string;
+    output: string;
+    metadata: unknown;
+}
+interface EventInput {
+    event: {
+        type: string;
+        properties?: unknown;
+    };
+}
+export declare function createAgentUsageReminderHook(_ctx: PluginInput): {
+    "tool.execute.after": (input: ToolExecuteInput, output: ToolExecuteOutput) => Promise<void>;
+    event: ({ event }: EventInput) => Promise<void>;
+};
+export {};

package/dist/hooks/agent-usage-reminder/index.d.ts

@@ -1,22 +1 @@
-import type { PluginInput } from "@opencode-ai/plugin";
-interface ToolExecuteInput {
-    tool: string;
-    sessionID: string;
-    callID: string;
-}
-interface ToolExecuteOutput {
-    title: string;
-    output: string;
-    metadata: unknown;
-}
-interface EventInput {
-    event: {
-        type: string;
-        properties?: unknown;
-    };
-}
-export declare function createAgentUsageReminderHook(_ctx: PluginInput): {
-    "tool.execute.after": (input: ToolExecuteInput, output: ToolExecuteOutput) => Promise<void>;
-    event: ({ event }: EventInput) => Promise<void>;
-};
-export {};
+export { createAgentUsageReminderHook } from "./hook";

package/dist/hooks/anthropic-context-window-limit-recovery/aggressive-truncation-strategy.d.ts

@@ -0,0 +1,14 @@
+import type { AutoCompactState } from "./types";
+import type { Client } from "./client";
+export declare function runAggressiveTruncationStrategy(params: {
+    sessionID: string;
+    autoCompactState: AutoCompactState;
+    client: Client;
+    directory: string;
+    truncateAttempt: number;
+    currentTokens: number;
+    maxTokens: number;
+}): Promise<{
+    handled: boolean;
+    nextTruncateAttempt: number;
+}>;

package/dist/hooks/anthropic-context-window-limit-recovery/client.d.ts

@@ -0,0 +1,60 @@
+export type Client = {
+    session: {
+        messages: (opts: {
+            path: {
+                id: string;
+            };
+            query?: {
+                directory?: string;
+            };
+        }) => Promise<unknown>;
+        summarize: (opts: {
+            path: {
+                id: string;
+            };
+            body: {
+                providerID: string;
+                modelID: string;
+            };
+            query: {
+                directory: string;
+            };
+        }) => Promise<unknown>;
+        revert: (opts: {
+            path: {
+                id: string;
+            };
+            body: {
+                messageID: string;
+                partID?: string;
+            };
+            query: {
+                directory: string;
+            };
+        }) => Promise<unknown>;
+        prompt_async: (opts: {
+            path: {
+                id: string;
+            };
+            body: {
+                parts: Array<{
+                    type: string;
+                    text: string;
+                }>;
+            };
+            query: {
+                directory: string;
+            };
+        }) => Promise<unknown>;
+    };
+    tui: {
+        showToast: (opts: {
+            body: {
+                title: string;
+                message: string;
+                variant: string;
+                duration: number;
+            };
+        }) => Promise<unknown>;
+    };
+};

package/dist/hooks/anthropic-context-window-limit-recovery/empty-content-recovery.d.ts

@@ -0,0 +1,8 @@
+import type { AutoCompactState } from "./types";
+import type { Client } from "./client";
+export declare function fixEmptyMessages(params: {
+    sessionID: string;
+    autoCompactState: AutoCompactState;
+    client: Client;
+    messageIndex?: number;
+}): Promise<boolean>;

package/dist/hooks/anthropic-context-window-limit-recovery/executor.d.ts

@@ -1,4 +1,4 @@
 import type { AutoCompactState } from "./types";
 import type { ExperimentalConfig } from "../../config";
-export declare function getLastAssistant(sessionID: string, client: any, directory: string): Promise<Record<string, unknown> | null>;
+export { getLastAssistant } from "./message-builder";
 export declare function executeCompact(sessionID: string, msg: Record<string, unknown>, autoCompactState: AutoCompactState, client: any, directory: string, experimental?: ExperimentalConfig): Promise<void>;

package/dist/hooks/anthropic-context-window-limit-recovery/index.d.ts

@@ -3,3 +3,6 @@ export type { AnthropicContextWindowLimitRecoveryOptions } from "./recovery-hook
 export type { AutoCompactState, ParsedTokenLimitError, TruncateState } from "./types";
 export { parseAnthropicTokenLimitError } from "./parser";
 export { executeCompact, getLastAssistant } from "./executor";
+export * from "./state";
+export * from "./message-builder";
+export * from "./recovery-strategy";

package/dist/hooks/anthropic-context-window-limit-recovery/message-builder.d.ts

@@ -0,0 +1,4 @@
+export declare const PLACEHOLDER_TEXT = "[user interrupted]";
+export declare function sanitizeEmptyMessagesBeforeSummarize(sessionID: string): number;
+export declare function formatBytes(bytes: number): string;
+export declare function getLastAssistant(sessionID: string, client: any, directory: string): Promise<Record<string, unknown> | null>;

package/dist/hooks/anthropic-context-window-limit-recovery/message-storage-directory.d.ts

@@ -0,0 +1,2 @@
+export declare function getMessageDir(sessionID: string): string;
+export declare function getMessageIds(sessionID: string): string[];

package/dist/hooks/anthropic-context-window-limit-recovery/recovery-strategy.d.ts

@@ -0,0 +1,2 @@
+export { runAggressiveTruncationStrategy } from "./aggressive-truncation-strategy";
+export { runSummarizeRetryStrategy } from "./summarize-retry-strategy";

package/dist/hooks/anthropic-context-window-limit-recovery/state.d.ts

@@ -0,0 +1,6 @@
+import type { AutoCompactState, RetryState, TruncateState } from "./types";
+export declare function getOrCreateRetryState(autoCompactState: AutoCompactState, sessionID: string): RetryState;
+export declare function getOrCreateTruncateState(autoCompactState: AutoCompactState, sessionID: string): TruncateState;
+export declare function clearSessionState(autoCompactState: AutoCompactState, sessionID: string): void;
+export declare function getEmptyContentAttempt(autoCompactState: AutoCompactState, sessionID: string): number;
+export declare function incrementEmptyContentAttempt(autoCompactState: AutoCompactState, sessionID: string): number;

package/dist/hooks/anthropic-context-window-limit-recovery/storage-paths.d.ts

@@ -0,0 +1,3 @@
+export declare const MESSAGE_STORAGE_DIR: string;
+export declare const PART_STORAGE_DIR: string;
+export declare const TRUNCATION_MESSAGE = "[TOOL RESULT TRUNCATED - Context limit exceeded. Original output was too large and has been truncated to recover the session. Please re-run this tool if you need the full output.]";

package/dist/hooks/anthropic-context-window-limit-recovery/storage.d.ts

@@ -1,28 +1,3 @@
-export interface ToolResultInfo {
-    partPath: string;
-    partId: string;
-    messageID: string;
-    toolName: string;
-    outputSize: number;
-}
-export declare function findToolResultsBySize(sessionID: string): ToolResultInfo[];
-export declare function findLargestToolResult(sessionID: string): ToolResultInfo | null;
-export declare function truncateToolResult(partPath: string): {
-    success: boolean;
-    toolName?: string;
-    originalSize?: number;
-};
-export declare function getTotalToolOutputSize(sessionID: string): number;
-export declare function countTruncatedResults(sessionID: string): number;
-export interface AggressiveTruncateResult {
-    success: boolean;
-    sufficient: boolean;
-    truncatedCount: number;
-    totalBytesRemoved: number;
-    targetBytesToRemove: number;
-    truncatedTools: Array<{
-        toolName: string;
-        originalSize: number;
-    }>;
-}
-export declare function truncateUntilTargetTokens(sessionID: string, currentTokens: number, maxTokens: number, targetRatio?: number, charsPerToken?: number): AggressiveTruncateResult;
+export type { AggressiveTruncateResult, ToolResultInfo } from "./tool-part-types";
+export { countTruncatedResults, findLargestToolResult, findToolResultsBySize, getTotalToolOutputSize, truncateToolResult, } from "./tool-result-storage";
+export { truncateUntilTargetTokens } from "./target-token-truncation";

package/dist/hooks/anthropic-context-window-limit-recovery/summarize-retry-strategy.d.ts

@@ -0,0 +1,11 @@
+import type { AutoCompactState } from "./types";
+import type { Client } from "./client";
+export declare function runSummarizeRetryStrategy(params: {
+    sessionID: string;
+    msg: Record<string, unknown>;
+    autoCompactState: AutoCompactState;
+    client: Client;
+    directory: string;
+    errorType?: string;
+    messageIndex?: number;
+}): Promise<void>;

package/dist/hooks/anthropic-context-window-limit-recovery/target-token-truncation.d.ts

@@ -0,0 +1,2 @@
+import type { AggressiveTruncateResult } from "./tool-part-types";
+export declare function truncateUntilTargetTokens(sessionID: string, currentTokens: number, maxTokens: number, targetRatio?: number, charsPerToken?: number): AggressiveTruncateResult;

package/dist/hooks/anthropic-context-window-limit-recovery/tool-part-types.d.ts

@@ -0,0 +1,39 @@
+export interface StoredToolPart {
+    id: string;
+    sessionID: string;
+    messageID: string;
+    type: "tool";
+    callID: string;
+    tool: string;
+    state: {
+        status: "pending" | "running" | "completed" | "error";
+        input: Record<string, unknown>;
+        output?: string;
+        error?: string;
+        time?: {
+            start: number;
+            end?: number;
+            compacted?: number;
+        };
+    };
+    truncated?: boolean;
+    originalSize?: number;
+}
+export interface ToolResultInfo {
+    partPath: string;
+    partId: string;
+    messageID: string;
+    toolName: string;
+    outputSize: number;
+}
+export interface AggressiveTruncateResult {
+    success: boolean;
+    sufficient: boolean;
+    truncatedCount: number;
+    totalBytesRemoved: number;
+    targetBytesToRemove: number;
+    truncatedTools: Array<{
+        toolName: string;
+        originalSize: number;
+    }>;
+}

package/dist/hooks/anthropic-context-window-limit-recovery/tool-result-storage.d.ts

@@ -0,0 +1,10 @@
+import type { ToolResultInfo } from "./tool-part-types";
+export declare function findToolResultsBySize(sessionID: string): ToolResultInfo[];
+export declare function findLargestToolResult(sessionID: string): ToolResultInfo | null;
+export declare function truncateToolResult(partPath: string): {
+    success: boolean;
+    toolName?: string;
+    originalSize?: number;
+};
+export declare function getTotalToolOutputSize(sessionID: string): number;
+export declare function countTruncatedResults(sessionID: string): number;

package/dist/hooks/anthropic-effort/hook.d.ts

@@ -0,0 +1,26 @@
+interface ChatParamsInput {
+    sessionID: string;
+    agent: {
+        name?: string;
+    };
+    model: {
+        providerID: string;
+        modelID: string;
+    };
+    provider: {
+        id: string;
+    };
+    message: {
+        variant?: string;
+    };
+}
+interface ChatParamsOutput {
+    temperature?: number;
+    topP?: number;
+    topK?: number;
+    options: Record<string, unknown>;
+}
+export declare function createAnthropicEffortHook(): {
+    "chat.params": (input: ChatParamsInput, output: ChatParamsOutput) => Promise<void>;
+};
+export {};

package/dist/hooks/anthropic-effort/index.d.ts

@@ -1,26 +1 @@
-interface ChatParamsInput {
-    sessionID: string;
-    agent: {
-        name?: string;
-    };
-    model: {
-        providerID: string;
-        modelID: string;
-    };
-    provider: {
-        id: string;
-    };
-    message: {
-        variant?: string;
-    };
-}
-interface ChatParamsOutput {
-    temperature?: number;
-    topP?: number;
-    topK?: number;
-    options: Record<string, unknown>;
-}
-export declare function createAnthropicEffortHook(): {
-    "chat.params": (input: ChatParamsInput, output: ChatParamsOutput) => Promise<void>;
-};
-export {};
+export { createAnthropicEffortHook } from "./hook";