@zeke-02/docx-editor-agents 0.1.0

package/dist/server-uWvnaIh-.d.ts

@@ -0,0 +1,620 @@
+import { Document } from '@zeke-02/docx-editor-core/headless';
+
+interface HeadingBlock {
+    type: 'heading';
+    index: number;
+    /** Stable Word `w14:paraId`. Use this as the anchor for live-editor operations. */
+    paraId?: string;
+    level: number;
+    text: string;
+}
+interface ParagraphBlock {
+    type: 'paragraph';
+    index: number;
+    /** Stable Word `w14:paraId`. Use this as the anchor for live-editor operations. */
+    paraId?: string;
+    text: string;
+}
+interface TableBlock {
+    type: 'table';
+    index: number;
+    rows: string[][];
+    /** Per-cell paraIds, parallel to `rows`. cells[r][c] is the first paraId in that cell. */
+    cellParaIds?: (string | undefined)[][];
+}
+interface ListItemBlock {
+    type: 'list-item';
+    index: number;
+    /** Stable Word `w14:paraId`. Use this as the anchor for live-editor operations. */
+    paraId?: string;
+    text: string;
+    listLevel: number;
+    listType: 'bullet' | 'number';
+}
+type ContentBlock = HeadingBlock | ParagraphBlock | TableBlock | ListItemBlock;
+interface GetContentOptions {
+    fromIndex?: number;
+    toIndex?: number;
+    /** Annotate tracked changes inline. Default: true */
+    includeTrackedChanges?: boolean;
+    /** Annotate comments inline. Default: true */
+    includeCommentAnchors?: boolean;
+}
+interface ReviewChange {
+    id: number;
+    type: 'insertion' | 'deletion' | 'moveFrom' | 'moveTo';
+    author: string;
+    date: string | null;
+    text: string;
+    context: string;
+    paragraphIndex: number;
+}
+interface ReviewCommentReply {
+    id: number;
+    author: string;
+    date: string | null;
+    text: string;
+}
+interface ReviewComment {
+    id: number;
+    author: string;
+    date: string | null;
+    text: string;
+    anchoredText: string;
+    paragraphIndex: number;
+    replies: ReviewCommentReply[];
+    done: boolean;
+}
+interface ChangeFilter {
+    author?: string;
+    type?: 'insertion' | 'deletion' | 'moveFrom' | 'moveTo';
+}
+interface CommentFilter {
+    author?: string;
+    done?: boolean;
+}
+/**
+ * Live-editor (bridge) action options — anchored by Word `w14:paraId`.
+ * Stable across edits; the agent gets paraIds from `read_document` / `find_text`.
+ */
+interface AddCommentByParaIdOptions {
+    paraId: string;
+    text: string;
+    author?: string;
+    /** Optional: anchor to a specific phrase within the paragraph (must be unique). */
+    search?: string;
+}
+/**
+ * Headless / DocxReviewer action options — anchored by ordinal paragraph index.
+ * Used by the static-document review pipeline.
+ */
+interface AddCommentOptions {
+    paragraphIndex: number;
+    text: string;
+    author?: string;
+    /** Optional: anchor to specific text. Omit to anchor whole paragraph. */
+    search?: string;
+}
+interface ReplyOptions {
+    text: string;
+    author?: string;
+}
+/**
+ * Live-editor change. Pass `replaceWith: ''` to delete; pass `search: ''` to
+ * insert at end of paragraph; pass both non-empty for a replacement.
+ */
+interface ProposeChangeOptions {
+    paraId: string;
+    search: string;
+    replaceWith: string;
+    author?: string;
+}
+interface ProposeReplacementOptions {
+    paragraphIndex: number;
+    search: string;
+    replaceWith: string;
+    author?: string;
+}
+interface ProposeInsertionOptions {
+    paragraphIndex: number;
+    insertText: string;
+    author?: string;
+    position?: 'before' | 'after';
+    search?: string;
+}
+interface ProposeDeletionOptions {
+    paragraphIndex: number;
+    search: string;
+    author?: string;
+}
+/** Per-match handle returned by `findText` — pass `paraId` + `match` back as `search`. */
+interface FoundMatch {
+    paraId: string;
+    match: string;
+    before: string;
+    after: string;
+}
+/** @public */
+interface SelectionInfo {
+    paraId: string | null;
+    selectedText: string;
+    paragraphText: string;
+    before: string;
+    after: string;
+}
+/**
+ * Character formatting marks the agent can apply.
+ *
+ * Mirrors Word JS API `Range.font.*`. A `false` value clears that mark in the
+ * range; a missing key leaves it untouched. `color.themeColor` follows ECMA-376
+ * theme color values (e.g. `'accent1'`, `'text1'`) and resolves at render time.
+ */
+interface CharacterFormatting {
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean | {
+        style?: string;
+    };
+    strike?: boolean;
+    color?: {
+        rgb?: string;
+        themeColor?: string;
+    };
+    highlight?: string;
+    fontSize?: number;
+    fontFamily?: {
+        ascii?: string;
+        hAnsi?: string;
+    };
+}
+/**
+ * Apply character formatting to a range. `paraId` is required; if `search`
+ * is provided, the formatting only applies to that phrase within the
+ * paragraph (must match exactly once). Otherwise it applies to the whole
+ * paragraph's text.
+ */
+interface ApplyFormattingOptions {
+    paraId: string;
+    search?: string;
+    marks: CharacterFormatting;
+}
+/**
+ * Apply a paragraph style by `styleId` (e.g. `'Heading1'`, `'Title'`,
+ * `'Quote'`). The styleId must exist in the document's style definitions
+ * — unknown ids are no-ops.
+ */
+interface SetParagraphStyleOptions {
+    paraId: string;
+    styleId: string;
+}
+/** A single paragraph anchored on a page (returned by `getPage` / `getPages`). */
+interface PageParagraph {
+    paraId: string;
+    text: string;
+    /** True for headings, list items, and other styled blocks. */
+    styleId?: string;
+}
+/** What the agent sees when reading one or more pages. */
+interface PageContent {
+    /** 1-indexed page number. */
+    pageNumber: number;
+    /** Plain text of the page, formatted as `[paraId] text` lines. */
+    text: string;
+    /** Paragraphs on the page, in document order. */
+    paragraphs: PageParagraph[];
+}
+/**
+ * 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.
+ *
+ * @public
+ */
+interface AgentContextSnapshot {
+    /** User's current selection or cursor (null if editor isn't focused). */
+    selection: SelectionInfo | null;
+    /** 1-indexed page the cursor / selection is on. 0 if unknown. */
+    currentPage: number;
+    /** Total number of pages currently rendered. */
+    totalPages: number;
+}
+interface BatchReviewOptions {
+    accept?: number[];
+    reject?: number[];
+    comments?: AddCommentOptions[];
+    replies?: (ReplyOptions & {
+        commentId: number;
+    })[];
+    proposals?: ProposeReplacementOptions[];
+}
+interface BatchError {
+    operation: string;
+    id?: number;
+    search?: string;
+    error: string;
+}
+interface BatchResult {
+    accepted: number;
+    rejected: number;
+    commentsAdded: number;
+    repliesAdded: number;
+    proposalsAdded: number;
+    errors: BatchError[];
+}
+
+/**
+ * Headless DOCX reviewer — parse a file, read/comment/track changes
+ * against the document model, write the modified DOCX back out. No DOM,
+ * no editor instance. Pair with `createReviewerBridge()` to drive the
+ * built-in agent tools against a file on disk.
+ *
+ * @example
+ * ```ts
+ * const reviewer = await DocxReviewer.fromBuffer(buffer, 'AI Reviewer');
+ * reviewer.addComment(5, 'Fix this paragraph.');
+ * reviewer.replace(5, '$50k', '$500k');
+ * const output = await reviewer.toBuffer();
+ * ```
+ *
+ * @public
+ */
+declare class DocxReviewer {
+    private doc;
+    /** Default author for comments and tracked changes. Set once, used everywhere. */
+    readonly author: string;
+    /**
+     * Create a reviewer from a parsed Document.
+     * @param document - Parsed Document from the core package
+     * @param author - Default author name for comments and changes. (default: 'AI')
+     * @param originalBuffer - Original DOCX buffer, needed for toBuffer()
+     */
+    constructor(document: Document, author?: string, originalBuffer?: ArrayBuffer);
+    /**
+     * Create a reviewer from a DOCX file buffer.
+     * @param buffer - ArrayBuffer of the DOCX file
+     * @param author - Default author name for comments and changes. (default: 'AI')
+     */
+    static fromBuffer(buffer: ArrayBuffer, author?: string): Promise<DocxReviewer>;
+    private get body();
+    private resolveAuthor;
+    /** Get document content as structured blocks (headings, paragraphs, tables, lists). */
+    getContent(options?: GetContentOptions): ContentBlock[];
+    /**
+     * Get document content as plain text for LLM prompts.
+     * Each paragraph is prefixed with its index: `[0] text`, `[1] text`, etc.
+     * Table cells include position: `[5] (table, row 1, col 2) cell text`.
+     * Avoids JSON quote-escaping issues — LLMs can copy text verbatim.
+     */
+    getContentAsText(options?: GetContentOptions): string;
+    /** Get all tracked changes in the document. */
+    getChanges(filter?: ChangeFilter): ReviewChange[];
+    /** Get all comments with their replies. */
+    getComments(filter?: CommentFilter): ReviewComment[];
+    /**
+     * Add a comment on a paragraph.
+     * @param paragraphIndex - Index of the paragraph to comment on
+     * @param text - Comment text
+     * @returns The new comment ID
+     */
+    addComment(paragraphIndex: number, text: string): number;
+    /**
+     * Add a comment with full options (custom author, anchored to specific text).
+     * @param options - Comment options
+     * @returns The new comment ID
+     */
+    addComment(options: AddCommentOptions): number;
+    /**
+     * Reply to an existing comment.
+     * @param commentId - ID of the comment to reply to
+     * @param text - Reply text
+     * @returns The new reply comment ID
+     */
+    replyTo(commentId: number, text: string): number;
+    /** Reply to an existing comment with full options. */
+    replyTo(commentId: number, options: ReplyOptions): number;
+    /**
+     * Remove a comment by ID. Removing a top-level comment also removes its
+     * replies and the anchored range markers. Removing a reply only removes
+     * that reply.
+     * @param commentId - ID of the comment to remove
+     */
+    removeComment(commentId: number): void;
+    /**
+     * Replace text in a paragraph. Creates a tracked change (deletion + insertion).
+     * @param paragraphIndex - Index of the paragraph
+     * @param search - Short phrase to find within the paragraph
+     * @param replaceWith - Replacement text
+     */
+    replace(paragraphIndex: number, search: string, replaceWith: string): void;
+    /** Replace text with full options. */
+    replace(options: ProposeReplacementOptions): void;
+    /** @deprecated Use replace() instead. */
+    proposeReplacement(options: ProposeReplacementOptions): void;
+    /** Insert text as a tracked change. */
+    proposeInsertion(options: ProposeInsertionOptions): void;
+    /** Delete text as a tracked change. */
+    proposeDeletion(options: ProposeDeletionOptions): void;
+    /** Accept a tracked change by its revision ID. */
+    acceptChange(id: number): void;
+    /** Reject a tracked change by its revision ID. */
+    rejectChange(id: number): void;
+    /** Accept all tracked changes. Returns count accepted. */
+    acceptAll(): number;
+    /** Reject all tracked changes. Returns count rejected. */
+    rejectAll(): number;
+    /**
+     * Apply multiple review operations in one call.
+     * Uses the reviewer's default author. Individual failures are collected, not thrown.
+     */
+    applyReview(ops: BatchReviewOptions): BatchResult;
+    /** Get the modified Document model. */
+    toDocument(): Document;
+    /** Serialize back to a DOCX buffer. Requires the original buffer. */
+    toBuffer(): Promise<ArrayBuffer>;
+}
+
+/**
+ * Reviewer bridge — wraps a `DocxReviewer` (static document) in the same
+ * `EditorBridge` interface the live editor exposes. Lets the same MCP server
+ * / agent tools operate on a parsed-from-disk DOCX without a running editor.
+ *
+ * Trade-offs vs. the live bridge:
+ *  - `getSelection()` always returns `null` (no user, no selection).
+ *  - `scrollTo()` is a no-op that returns `true` (the doc isn't being viewed).
+ *  - `onSelectionChange` listeners never fire (returned unsubscribers are no-ops).
+ *  - `onContentChange` fires after every successful mutation through this bridge,
+ *    so MCP clients still get notifications when the agent is the only writer.
+ *  - paraId resolution maps to `paragraphIndex` by walking the document body
+ *    once. None of the reviewer's mutators (`addComment`, `proposeChange`,
+ *    `replyTo`, `resolveComment`) shift top-level indices, so the map is
+ *    cached for the bridge's lifetime.
+ *
+ * After the agent finishes mutating, call `reviewer.toBuffer()` to serialize
+ * back to DOCX. The bridge does NOT do that automatically — the host decides
+ * when to flush.
+ */
+
+/**
+ * Create an EditorBridge backed by a DocxReviewer. The agent (or MCP client)
+ * can read, comment, propose changes, etc., against a parsed DOCX file on
+ * disk. Call `reviewer.toBuffer()` afterwards to get the modified DOCX.
+ *
+ * @param reviewer - A DocxReviewer instance. The bridge mutates it in place.
+ *
+ * @public
+ */
+declare function createReviewerBridge(reviewer: DocxReviewer): EditorBridge;
+
+/**
+ * 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 {
+    getDocument(): unknown | null;
+    getEditorRef(): {
+        getDocument(): unknown | null;
+    } | null;
+    addComment(options: {
+        paraId: string;
+        text: string;
+        author: string;
+        search?: string;
+    }): number | null;
+    replyToComment(commentId: number, text: string, author: string): number | null;
+    resolveComment(commentId: number): void;
+    proposeChange(options: {
+        paraId: string;
+        search: string;
+        replaceWith: string;
+        author: string;
+    }): boolean;
+    scrollToParaId(paraId: string): boolean;
+    findInDocument(query: string, options?: {
+        caseSensitive?: boolean;
+        limit?: number;
+    }): FoundMatch[];
+    getSelectionInfo(): SelectionInfo | null;
+    getComments(): Array<{
+        id: number;
+        author: string;
+        date?: string;
+        parentId?: number;
+        content: unknown[];
+        done?: boolean;
+    }>;
+    /** Apply character formatting to a paragraph or sub-range. Returns false on missing paraId / ambiguous search. */
+    applyFormatting(options: {
+        paraId: string;
+        search?: string;
+        marks: CharacterFormatting;
+    }): boolean;
+    /** Apply a paragraph style by styleId. Returns false if paraId is unknown. */
+    setParagraphStyle(options: {
+        paraId: string;
+        styleId: string;
+    }): boolean;
+    /** Read a single page's paragraphs (1-indexed). Returns null if the page does not exist. */
+    getPageContent(pageNumber: number): PageContent | null;
+    /** Total number of pages currently rendered. */
+    getTotalPages(): number;
+    /** 1-indexed page the user's cursor / selection is on. 0 if unknown. */
+    getCurrentPage(): number;
+    onContentChange(listener: (doc: unknown) => void): () => void;
+    onSelectionChange(listener: (selection: unknown) => void): () => void;
+}
+/**
+ * High-level agent surface over a live editor (or a headless reviewer).
+ * Every built-in tool calls into this contract — implement it once and
+ * the agent toolkit works against your editor.
+ *
+ * @public
+ */
+interface EditorBridge {
+    /** Get document content as paraId-tagged text lines for LLM prompts. */
+    getContentAsText(options?: GetContentOptions): string;
+    /** Get document content as structured blocks (each paragraph carries its `paraId`). */
+    getContent(options?: GetContentOptions): ContentBlock[];
+    /** Get all comments in the document. */
+    getComments(filter?: CommentFilter): ReviewComment[];
+    /** Get all tracked changes in the document. */
+    getChanges(filter?: ChangeFilter): ReviewChange[];
+    /** Locate text in the document. Returns one handle per matching paragraph. */
+    findText(query: string, options?: {
+        caseSensitive?: boolean;
+        limit?: number;
+    }): FoundMatch[];
+    /** Read the user's current cursor / selection. */
+    getSelection(): SelectionInfo | null;
+    /** Add a comment, anchored to a paragraph by paraId. */
+    addComment(options: AddCommentByParaIdOptions): number | null;
+    /** Reply to an existing comment. Returns the reply ID or null. */
+    replyTo(commentId: number, options: ReplyOptions): number | null;
+    /** Resolve a comment (mark as done). */
+    resolveComment(commentId: number): void;
+    /** Suggest a tracked change. `replaceWith=''` deletes; `search=''` inserts at paragraph end. */
+    proposeChange(options: ProposeChangeOptions): boolean;
+    /**
+     * Apply character formatting (bold / italic / color / size / font / etc.)
+     * to a paragraph, or to a unique phrase within it. This is a direct edit —
+     * not a tracked change.
+     */
+    applyFormatting(options: ApplyFormattingOptions): boolean;
+    /**
+     * Apply a paragraph style by styleId (e.g. `'Heading1'`, `'Quote'`).
+     * Direct edit, not a tracked change.
+     */
+    setParagraphStyle(options: SetParagraphStyleOptions): boolean;
+    /** Read a single page (1-indexed). Returns null if the page does not exist. */
+    getPage(pageNumber: number): PageContent | null;
+    /** Read a range of pages (1-indexed, inclusive). Out-of-range pages are skipped. */
+    getPages(options: {
+        from: number;
+        to: number;
+    }): PageContent[];
+    /** Total number of pages currently rendered in the editor. */
+    getTotalPages(): number;
+    /** 1-indexed page the user's cursor / selection is on. 0 if unknown. */
+    getCurrentPage(): number;
+    /** Scroll the editor to a paragraph by paraId. */
+    scrollTo(paraId: string): boolean;
+    /** Subscribe to document content changes. Returns an unsubscribe function. */
+    onContentChange(listener: (event: ContentChangeEvent) => void): () => void;
+    /** Subscribe to selection changes (cursor moves / selection changes). Returns an unsubscribe function. */
+    onSelectionChange(listener: (event: SelectionChangeEvent) => void): () => void;
+}
+/** Event payload for `onContentChange`. */
+interface ContentChangeEvent {
+    /** Total comments in the document after the change. */
+    commentCount: number;
+    /** Total tracked changes after the change. */
+    changeCount: number;
+    /** Snapshot of all current comments. */
+    comments: ReviewComment[];
+    /** Snapshot of all current tracked changes. */
+    changes: ReviewChange[];
+}
+/** Event payload for `onSelectionChange`. */
+type SelectionChangeEvent = SelectionInfo | null;
+/**
+ * Create an EditorBridge from a DocxEditorRef.
+ *
+ * @param editorRef - A DocxEditorRef (or anything matching EditorRefLike)
+ * @param author - Default author name for comments and changes. (default: 'AI')
+ */
+declare function createEditorBridge(editorRef: EditorRefLike, author?: string): EditorBridge;
+
+/**
+ * Agent tool type definitions.
+ */
+
+/**
+ * Definition of an agent tool — name, JSON-schema input, handler.
+ * Use this to build custom tools alongside the built-in `agentTools`.
+ *
+ * @public
+ */
+interface AgentToolDefinition<TInput = Record<string, unknown>> {
+    /** Tool name (used in tool_use blocks) */
+    name: string;
+    /**
+     * Friendly UI label for the tool. Shown in the agent panel's timeline
+     * (e.g. "Reading document"). Falls back to a sentence-case version of
+     * `name` if omitted, so consumer-defined tools render readably without
+     * specifying this.
+     */
+    displayName?: string;
+    /** Human-readable description for the LLM */
+    description: string;
+    /** JSON Schema for the input parameters */
+    inputSchema: Record<string, unknown>;
+    /** Handler — receives parsed input + bridge, returns result */
+    handler: (input: TInput, bridge: EditorBridge) => AgentToolResult;
+}
+/**
+ * Result returned by a tool handler. `success: false` carries an `error`
+ * message; `success: true` may carry tool-specific `data`.
+ *
+ * @public
+ */
+interface AgentToolResult {
+    success: boolean;
+    data?: unknown;
+    error?: string;
+}
+
+/**
+ * Agent tool definitions and execution.
+ *
+ * Tools use OpenAI function-calling format. The pattern mirrors Word's JS API:
+ * locate first (`read_document` / `find_text` / `read_selection` return paraId
+ * handles), then mutate (`comment` / `suggest_change` / `reply_comment` /
+ * `resolve_comment` / `scroll`). paraId anchors are stable across edits.
+ */
+
+/**
+ * All built-in agent tools — read/write document content, comments, and
+ * tracked changes. Use `getToolSchemas()` to feed them to an LLM and
+ * `executeToolCall()` to run the handlers against an `EditorBridge`.
+ *
+ * @public
+ */
+declare const agentTools: AgentToolDefinition<any>[];
+/**
+ * Execute a tool call against an EditorBridge.
+ * Returns the result (never throws).
+ *
+ * @public
+ */
+declare function executeToolCall(toolName: string, input: Record<string, unknown>, bridge: EditorBridge): AgentToolResult;
+/**
+ * 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.
+ *
+ * @example getToolDisplayName('add_comment') // → 'Adding comment'
+ * @example getToolDisplayName('fetch_clause_template') // → 'Fetch clause template'
+ *
+ * @public
+ */
+declare function getToolDisplayName(name: string): string;
+/**
+ * Get tool schemas in OpenAI function-calling format. Works directly
+ * with the OpenAI SDK and Anthropic's tools API. For Vercel AI SDK,
+ * LangChain, or other agent runtimes, transform this output to that
+ * runtime's required shape — see `examples/agent-chat-demo/` for a
+ * Vercel AI SDK example. The package stays runtime-agnostic.
+ *
+ * @public
+ */
+declare function getToolSchemas(): {
+    type: "function";
+    function: {
+        name: string;
+        description: string;
+        parameters: Record<string, unknown>;
+    };
+}[];
+
+export { type AddCommentByParaIdOptions as A, type BatchError as B, type ContentBlock as C, DocxReviewer as D, type EditorBridge as E, type FoundMatch as F, type GetContentOptions as G, type ProposeChangeOptions as P, type ReviewComment as R, type SelectionInfo as S, type CommentFilter as a, type ChangeFilter as b, type ReviewChange as c, type ReplyOptions as d, type ApplyFormattingOptions as e, type SetParagraphStyleOptions as f, type PageContent as g, type ContentChangeEvent as h, type SelectionChangeEvent as i, type AgentToolDefinition as j, type AgentToolResult as k, type BatchResult as l, type BatchReviewOptions as m, agentTools as n, createReviewerBridge as o, executeToolCall as p, getToolSchemas as q, type EditorRefLike as r, type AgentContextSnapshot as s, getToolDisplayName as t, createEditorBridge as u };

package/dist/server.d.mts

@@ -0,0 +1,35 @@
+/**
+ * @zeke-02/docx-editor-agents/server
+ *
+ * Server entry for API routes, Node.js, serverless functions, and Workers.
+ *
+ * Import the toolkit here without pulling in React peer deps. Use this from
+ * Next.js routes, a FastAPI bridge, a Cloudflare Worker, or any other
+ * backend that streams an LLM call with tool definitions.
+ *
+ * @example
+ * ```ts
+ * import { getToolSchemas } from '@zeke-02/docx-editor-agents/server';
+ * import { streamText, jsonSchema, convertToModelMessages } from 'ai';
+ *
+ * // `getToolSchemas()` returns OpenAI function-calling format. For Vercel
+ * // AI SDK v5, adapt to `{ [name]: { description, inputSchema } }` once.
+ * const tools = Object.fromEntries(
+ *   getToolSchemas().map((s) => [
+ *     s.function.name,
+ *     { description: s.function.description, inputSchema: jsonSchema(s.function.parameters as never) },
+ *   ])
+ * );
+ *
+ * export async function POST(req: Request) {
+ *   const { messages } = await req.json();
+ *   const result = streamText({ model: 'openai/gpt-4o', messages: convertToModelMessages(messages), tools });
+ *   return result.toUIMessageStreamResponse();
+ * }
+ * ```
+ *
+ * @packageDocumentation
+ * @public
+ */
+export { s as AgentContextSnapshot, j as AgentToolDefinition, k as AgentToolResult, D as DocxReviewer, E as EditorBridge, S as SelectionInfo, o as createReviewerBridge, n as docxAgentTools, p as executeToolCall, t as getToolDisplayName, q as getToolSchemas } from './server-uWvnaIh-.mjs';
+import '@zeke-02/docx-editor-core/headless';

package/dist/server.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @zeke-02/docx-editor-agents/server
+ *
+ * Server entry for API routes, Node.js, serverless functions, and Workers.
+ *
+ * Import the toolkit here without pulling in React peer deps. Use this from
+ * Next.js routes, a FastAPI bridge, a Cloudflare Worker, or any other
+ * backend that streams an LLM call with tool definitions.
+ *
+ * @example
+ * ```ts
+ * import { getToolSchemas } from '@zeke-02/docx-editor-agents/server';
+ * import { streamText, jsonSchema, convertToModelMessages } from 'ai';
+ *
+ * // `getToolSchemas()` returns OpenAI function-calling format. For Vercel
+ * // AI SDK v5, adapt to `{ [name]: { description, inputSchema } }` once.
+ * const tools = Object.fromEntries(
+ *   getToolSchemas().map((s) => [
+ *     s.function.name,
+ *     { description: s.function.description, inputSchema: jsonSchema(s.function.parameters as never) },
+ *   ])
+ * );
+ *
+ * export async function POST(req: Request) {
+ *   const { messages } = await req.json();
+ *   const result = streamText({ model: 'openai/gpt-4o', messages: convertToModelMessages(messages), tools });
+ *   return result.toUIMessageStreamResponse();
+ * }
+ * ```
+ *
+ * @packageDocumentation
+ * @public
+ */
+export { s as AgentContextSnapshot, j as AgentToolDefinition, k as AgentToolResult, D as DocxReviewer, E as EditorBridge, S as SelectionInfo, o as createReviewerBridge, n as docxAgentTools, p as executeToolCall, t as getToolDisplayName, q as getToolSchemas } from './server-uWvnaIh-.js';
+import '@zeke-02/docx-editor-core/headless';

package/dist/server.js

@@ -0,0 +1 @@
+'use strict';var chunkVXAJD6QK_js=require('./chunk-VXAJD6QK.js'),chunk2RGRAPLW_js=require('./chunk-2RGRAPLW.js'),chunkRI5S75JY_js=require('./chunk-RI5S75JY.js');Object.defineProperty(exports,"DocxReviewer",{enumerable:true,get:function(){return chunkVXAJD6QK_js.a}});Object.defineProperty(exports,"createReviewerBridge",{enumerable:true,get:function(){return chunk2RGRAPLW_js.m}});Object.defineProperty(exports,"docxAgentTools",{enumerable:true,get:function(){return chunkRI5S75JY_js.a}});Object.defineProperty(exports,"executeToolCall",{enumerable:true,get:function(){return chunkRI5S75JY_js.b}});Object.defineProperty(exports,"getToolDisplayName",{enumerable:true,get:function(){return chunkRI5S75JY_js.c}});Object.defineProperty(exports,"getToolSchemas",{enumerable:true,get:function(){return chunkRI5S75JY_js.d}});

package/dist/server.mjs

@@ -0,0 +1 @@
+export{a as DocxReviewer}from'./chunk-UNUH3LRU.mjs';export{m as createReviewerBridge}from'./chunk-AU3KR5IN.mjs';export{a as docxAgentTools,b as executeToolCall,c as getToolDisplayName,d as getToolSchemas}from'./chunk-24MVJKCP.mjs';