declare function AgentChatLog(input: AgentChatLogProps): react_jsx_runtime.JSX.Element;

declare function AgentComposer(input: AgentComposerProps): react_jsx_runtime.JSX.Element;

declare function AgentPanel(input: AgentPanelProps): react_jsx_runtime.JSX.Element;

declare function AgentSuggestionChip(input: AgentSuggestionChipProps): react_jsx_runtime.JSX.Element;

Collapsible timeline of an assistant turn's tool calls. Lives above the assistant text bubble. Auto-collapses when the turn finishes; click the summary row to re-expand.

declare function AgentTimeline(input: AgentTimelineProps): react_jsx_runtime.JSX.Element | null;

Friendly UI label for a tool — sourced from the registry's `displayName`, falling back to a sentence-case version of the snake_case name. Used by `<AgentTimeline>` and any other UI that lists running / completed tools.

declare function getToolDisplayName(name: string): string;

getToolDisplayName('add_comment') // → 'Adding comment'

getToolDisplayName('fetch_clause_template') // → 'Fetch clause template'

Hook that creates an EditorBridge and provides tool execution.

declare function useAgentChat(options: UseAgentChatOptions): UseAgentChatReturn;

declare function useDocxAgentTools(options: UseDocxAgentToolsOptions): UseDocxAgentToolsReturn;

interface AgentChatLogProps

interface AgentComposerProps

Snapshot of what the user is looking at — pass this to your agent's system prompt so it knows the current selection / page without an extra `read_selection` round-trip.

interface AgentContextSnapshot

interface AgentMessage

interface AgentPanelProps

interface AgentSuggestionChipProps

interface AgentTimelineProps

Shared agent UI types — framework-agnostic. Both React and Vue adapters (and the AI SDK adapters) consume this single declaration.

Keeping the types here lets us tweak the chat schema without writing the same drift fix in four files.

interface AgentToolCall

Definition of an agent tool — name, JSON-schema input, handler. Use this to build custom tools alongside the built-in `agentTools`.

interface AgentToolDefinition<TInput = Record<string, unknown>>

Result returned by a tool handler. `success: false` carries an `error` message; `success: true` may carry tool-specific `data`.

interface AgentToolResult

Agent-bridge contract every editor adapter (React, Vue, future) MUST satisfy. Versioning: additions are coordinated minor bumps across the fixed group; signature changes / removals are major. See `openspec/changes/vue-editor-robust-implementation/design.md` Decision 18.

interface EditorRefLike

useAgentChat — React hook that wires agent tools to a live DocxEditor.

interface UseAgentChatOptions

```tsx
import { useAgentChat } from '@eigenpal/docx-editor-agents/react';

const { executeToolCall, toolSchemas } = useAgentChat({ editorRef, author: 'Assistant' });

// Pass toolSchemas to your AI provider, execute tool calls on the client
const result = executeToolCall('add_comment', { paragraphIndex: 3, text: 'Fix this.' });
```

interface UseAgentChatReturn

useDocxAgentTools — wires the toolkit to a live DocxEditor for BYO chat frameworks.

Returns three things consumers need to plug an agent into the editor:

- `tools` — schemas in OpenAI function-calling format. Pass to `streamText({ tools })`, OpenAI's `tools` field, Anthropic's `tools`, or any provider that accepts that shape. - `executeToolCall` — the executor. Hand to AI SDK's `onToolCall`, or call yourself when you wire up tool calls manually. - `getContext` — snapshot of `{selection, currentPage, paragraphCount}` for system-prompt injection. Pass through `prepareRequestBody` (AI SDK) or inline into your own request body so the agent always knows what the user is looking at without an extra tool round-trip.

Custom tools merge with the built-ins via the `tools` option. Names collide → consumer wins (your override replaces the built-in by name).

interface UseDocxAgentToolsOptions

```tsx
const { tools, executeToolCall, getContext } = useDocxAgentTools({
  editorRef,
  author: 'Assistant',
  tools: {
    fetch_clause: {
      name: 'fetch_clause',
      description: 'Fetch a clause template by name.',
      inputSchema: { type: 'object', properties: { name: { type: 'string' } } },
      handler: async (input) => ({ success: true, data: await fetchTemplate(input.name) }),
    },
  },
});
```

interface UseDocxAgentToolsReturn