## API Report File for "@eigenpal/docx-editor-agents"

> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).

```ts

import { CSSProperties } from 'react';
import * as react from 'react';
import { ReactNode } from 'react';

// @public (undocumented)
export function AgentChatLog(input: AgentChatLogProps): react.JSX.Element;

// @public (undocumented)
export interface AgentChatLogProps {
    autoScroll?: boolean;
    // (undocumented)
    className?: string;
    earlierLabel?: (count: number) => string;
    emptyState?: ReactNode;
    error?: string | null;
    humanizeToolName?: (name: string) => string;
    loading?: boolean;
    maxVisibleCalls?: number;
    // (undocumented)
    messages: AgentMessage[];
    // (undocumented)
    style?: CSSProperties;
    summaryLabel?: (count: number) => string;
    thinkingLabel?: string;
    workingLabel?: (count: number) => string;
}

// @public (undocumented)
export function AgentComposer(input: AgentComposerProps): react.JSX.Element;

// @public (undocumented)
export interface AgentComposerProps {
    // (undocumented)
    className?: string;
    // (undocumented)
    disabled?: boolean;
    footnote?: ReactNode;
    // (undocumented)
    onChange: (next: string) => void;
    // (undocumented)
    onSubmit: () => void;
    // (undocumented)
    placeholder?: string;
    sendLabel?: string;
    // (undocumented)
    value: string;
}

// @public
export interface AgentContextSnapshot {
    currentPage: number;
    selection: SelectionInfo | null;
    totalPages: number;
}

// @public (undocumented)
export interface AgentMessage {
    // (undocumented)
    id: string;
    // (undocumented)
    role: 'user' | 'assistant';
    status?: 'streaming' | 'done';
    // (undocumented)
    text: string;
    toolCalls?: AgentToolCall[];
}

// @public (undocumented)
export function AgentPanel(input: AgentPanelProps): react.JSX.Element;

// @public (undocumented)
export interface AgentPanelProps {
    children: ReactNode;
    className?: string;
    closed?: boolean;
    closeLabel?: string;
    defaultWidth?: number;
    icon?: ReactNode;
    maxWidth?: number;
    minWidth?: number;
    onClose?: () => void;
    onWidthChange?: (w: number) => void;
    resizeHandleLabel?: string;
    title?: string;
    width?: number;
}

// @public (undocumented)
export function AgentSuggestionChip(input: AgentSuggestionChipProps): react.JSX.Element;

// @public (undocumented)
export interface AgentSuggestionChipProps {
    // (undocumented)
    disabled?: boolean;
    // (undocumented)
    label: string;
    // (undocumented)
    onClick: () => void;
}

// @public
export function AgentTimeline(input: AgentTimelineProps): react.JSX.Element | null;

// @public (undocumented)
export interface AgentTimelineProps {
    earlierLabel?: (count: number) => string;
    humanizeName?: (name: string) => string;
    maxVisibleCalls?: number;
    streaming?: boolean;
    summaryLabel?: (count: number) => string;
    toolCalls: AgentToolCall[];
    workingLabel?: (count: number) => string;
}

// @public
export interface AgentToolCall {
    error?: string;
    id: string;
    input?: unknown;
    name: string;
    result?: string;
    status: 'running' | 'done' | 'error';
}

// @public
export interface AgentToolDefinition<TInput = Record<string, unknown>> {
    description: string;
    displayName?: string;
    handler: (input: TInput, bridge: EditorBridge) => AgentToolResult;
    inputSchema: Record<string, unknown>;
    name: string;
}

// @public
export interface AgentToolResult {
    // (undocumented)
    data?: unknown;
    // (undocumented)
    error?: string;
    // (undocumented)
    success: boolean;
}

// @public
export interface EditorRefLike {
    // (undocumented)
    addComment(options: {
        paraId: string;
        text: string;
        author: string;
        search?: string;
    }): number | null;
    applyFormatting(options: {
        paraId: string;
        search?: string;
        marks: CharacterFormatting;
    }): boolean;
    // (undocumented)
    findInDocument(query: string, options?: {
        caseSensitive?: boolean;
        limit?: number;
    }): FoundMatch[];
    // (undocumented)
    getComments(): Array<{
        id: number;
        author: string;
        date?: string;
        parentId?: number;
        content: unknown[];
        done?: boolean;
    }>;
    getCurrentPage(): number;
    // (undocumented)
    getDocument(): unknown | null;
    // (undocumented)
    getEditorRef(): {
        getDocument(): unknown | null;
    } | null;
    getPageContent(pageNumber: number): PageContent | null;
    // (undocumented)
    getSelectionInfo(): SelectionInfo | null;
    getTotalPages(): number;
    insertBreak(options: {
        paraId: string;
        type: 'page' | 'sectionNextPage' | 'sectionContinuous';
    }): boolean;
    // (undocumented)
    onContentChange(listener: (doc: unknown) => void): () => void;
    // (undocumented)
    onSelectionChange(listener: (selection: unknown) => void): () => void;
    // (undocumented)
    proposeChange(options: {
        paraId: string;
        search: string;
        replaceWith: string;
        author: string;
    }): boolean;
    // (undocumented)
    replyToComment(commentId: number, text: string, author: string): number | null;
    // (undocumented)
    resolveComment(commentId: number): void;
    // (undocumented)
    scrollToParaId(paraId: string): boolean;
    setParagraphStyle(options: {
        paraId: string;
        styleId: string;
    }): boolean;
}

// @public
export function getToolDisplayName(name: string): string;

// @public
export function useAgentChat(options: UseAgentChatOptions): UseAgentChatReturn;

// @public
export interface UseAgentChatOptions {
    author?: string;
    editorRef: React.RefObject<EditorRefLike | null>;
}

// @public (undocumented)
export interface UseAgentChatReturn {
    executeToolCall: (toolName: string, input: Record<string, unknown>) => AgentToolResult;
    toolSchemas: ReturnType<typeof getToolSchemas>;
}

// @public (undocumented)
export function useDocxAgentTools(options: UseDocxAgentToolsOptions): UseDocxAgentToolsReturn;

// @public
export interface UseDocxAgentToolsOptions {
    author?: string;
    editorRef: React.RefObject<EditorRefLike | null>;
    exclude?: readonly string[];
    include?: readonly string[];
    tools?: Record<string, AgentToolDefinition<any>>;
}

// @public (undocumented)
export interface UseDocxAgentToolsReturn {
    executeToolCall: (name: string, args: Record<string, unknown>) => AgentToolResult;
    getContext: () => AgentContextSnapshot;
    tools: ReturnType<typeof getToolSchemas>;
}

```
