@morphllm/subagents 0.1.3 → 0.1.5

package/src/docx/agent.ts

@@ -1,200 +1,25 @@
 /**
  * DocxAgent - AI agent for DOCX document editing
  *
- * Uses OpenAI-compatible API to process requests and execute
- * document editing operations.
+ * OpenAI Agents SDK compatible client for morph-docx.
+ * Talks to api.subagents.com/v1/chat/completions with model "morph-docx".
  */
 
-import { BaseAgent } from '../core/base-agent';
-import type { Tool } from '../core/types';
-import { DocxClient } from './client';
-import type { DocxAgentOptions } from './types';
+import type { DocxAgentOptions, Message, ChatCompletionResponse, StreamChunk } from './types';
 
-const DEFAULT_INSTRUCTIONS = `You are an expert DOCX document editing assistant.
+const DEFAULT_BASE_URL = 'https://api.subagents.com/v1';
 
-When editing documents:
-1. First read the document to understand its structure
-2. Use track changes for all modifications
-3. Add comments to flag issues or request clarification
-4. Be precise with paragraph text matching - use unique text snippets
-
-Available tools:
-- read_document: Read the document content
-- add_comment: Add a comment to a specific paragraph
-- insert_text: Insert text within a paragraph (tracked change)
-- propose_deletion: Mark text for deletion (tracked change)
-- reply_comment: Reply to an existing comment
-- resolve_comment: Mark a comment as resolved
-- delete_comment: Delete a comment
-- insert_paragraph: Insert a new paragraph
-- validate_document: Validate DOCX structure`;
-
-const TOOLS: Tool[] = [
-  {
-    type: 'function',
-    function: {
-      name: 'read_document',
-      description: 'Read the document content as plain text',
-      parameters: {
-        type: 'object',
-        properties: {
-          doc_id: { type: 'string', description: 'Document ID' },
-        },
-        required: ['doc_id'],
-      },
-    },
-  },
-  {
-    type: 'function',
-    function: {
-      name: 'add_comment',
-      description: 'Add a comment to a specific paragraph in the document',
-      parameters: {
-        type: 'object',
-        properties: {
-          doc_id: { type: 'string', description: 'Document ID' },
-          para_text: { type: 'string', description: 'Unique text from the target paragraph' },
-          comment: { type: 'string', description: 'Comment text to add' },
-          highlight: { type: 'string', description: 'Optional specific text to highlight' },
-        },
-        required: ['doc_id', 'para_text', 'comment'],
-      },
-    },
-  },
-  {
-    type: 'function',
-    function: {
-      name: 'insert_text',
-      description: 'Insert text within a paragraph (creates a tracked change)',
-      parameters: {
-        type: 'object',
-        properties: {
-          doc_id: { type: 'string', description: 'Document ID' },
-          para_text: { type: 'string', description: 'Unique text from the target paragraph' },
-          after: { type: 'string', description: 'Text after which to insert' },
-          new_text: { type: 'string', description: 'Text to insert' },
-        },
-        required: ['doc_id', 'para_text', 'after', 'new_text'],
-      },
-    },
-  },
-  {
-    type: 'function',
-    function: {
-      name: 'propose_deletion',
-      description: 'Mark text for deletion (creates a tracked change)',
-      parameters: {
-        type: 'object',
-        properties: {
-          doc_id: { type: 'string', description: 'Document ID' },
-          para_text: { type: 'string', description: 'Unique text from the target paragraph' },
-          target: { type: 'string', description: 'Specific text to delete (optional, defaults to whole paragraph)' },
-        },
-        required: ['doc_id', 'para_text'],
-      },
-    },
-  },
-  {
-    type: 'function',
-    function: {
-      name: 'reply_comment',
-      description: 'Reply to an existing comment',
-      parameters: {
-        type: 'object',
-        properties: {
-          doc_id: { type: 'string', description: 'Document ID' },
-          comment_id: { type: 'string', description: 'ID of the comment to reply to' },
-          reply: { type: 'string', description: 'Reply text' },
-        },
-        required: ['doc_id', 'comment_id', 'reply'],
-      },
-    },
-  },
-  {
-    type: 'function',
-    function: {
-      name: 'resolve_comment',
-      description: 'Mark a comment as resolved',
-      parameters: {
-        type: 'object',
-        properties: {
-          doc_id: { type: 'string', description: 'Document ID' },
-          comment_id: { type: 'string', description: 'ID of the comment to resolve' },
-        },
-        required: ['doc_id', 'comment_id'],
-      },
-    },
-  },
-  {
-    type: 'function',
-    function: {
-      name: 'delete_comment',
-      description: 'Delete a comment and its replies',
-      parameters: {
-        type: 'object',
-        properties: {
-          doc_id: { type: 'string', description: 'Document ID' },
-          comment_id: { type: 'string', description: 'ID of the comment to delete' },
-        },
-        required: ['doc_id', 'comment_id'],
-      },
-    },
-  },
-  {
-    type: 'function',
-    function: {
-      name: 'insert_paragraph',
-      description: 'Insert a new paragraph after existing text',
-      parameters: {
-        type: 'object',
-        properties: {
-          doc_id: { type: 'string', description: 'Document ID' },
-          after_text: { type: 'string', description: 'Text after which to insert the new paragraph' },
-          new_text: { type: 'string', description: 'Content of the new paragraph' },
-        },
-        required: ['doc_id', 'after_text', 'new_text'],
-      },
-    },
-  },
-  {
-    type: 'function',
-    function: {
-      name: 'validate_document',
-      description: 'Validate the document structure',
-      parameters: {
-        type: 'object',
-        properties: {
-          doc_id: { type: 'string', description: 'Document ID' },
-        },
-        required: ['doc_id'],
-      },
-    },
-  },
-];
-
-export class DocxAgent extends BaseAgent<DocxClient> {
+export class DocxAgent {
+  private baseUrl: string;
+  private apiKey: string;
   private documentId?: string;
 
   constructor(options: DocxAgentOptions = {}) {
-    const client = new DocxClient(options);
-    super({ ...options, client });
+    this.baseUrl = options.baseUrl || process.env.MORPH_API_URL || DEFAULT_BASE_URL;
+    this.apiKey = options.apiKey || process.env.MORPH_API_KEY || '';
     this.documentId = options.documentId;
   }
 
-  protected getDefaultModel(): string {
-    return 'moonshot-v1-32k';
-  }
-
-  protected getDefaultInstructions(): string {
-    return this.documentId
-      ? `${DEFAULT_INSTRUCTIONS}\n\nCurrent document ID: ${this.documentId}`
-      : DEFAULT_INSTRUCTIONS;
-  }
-
-  protected getTools(): Tool[] {
-    return TOOLS;
-  }
-
   /** Set the current document ID */
   setDocument(docId: string) {
     this.documentId = docId;
@@ -205,107 +30,142 @@ export class DocxAgent extends BaseAgent<DocxClient> {
     return this.documentId;
   }
 
-  protected async executeTool(name: string, args: Record<string, unknown>): Promise<string> {
-    const docId = (args.doc_id as string) || this.documentId;
-
-    if (!docId) {
-      return 'Error: No document ID provided. Please upload a document first.';
+  /**
+   * Send a chat completion request (non-streaming).
+   * This runs the full agent loop on the server and returns the final response.
+   */
+  async chat(messages: Message[]): Promise<ChatCompletionResponse> {
+    // Add document context to user message if we have a document ID
+    const contextMessages = this.documentId
+      ? messages.map((m, i) => {
+          if (i === messages.length - 1 && m.role === 'user') {
+            return {
+              ...m,
+              content: `[Document ID: ${this.documentId}]\n\n${m.content}`,
+            };
+          }
+          return m;
+        })
+      : messages;
+
+    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        ...(this.apiKey && { Authorization: `Bearer ${this.apiKey}` }),
+      },
+      body: JSON.stringify({
+        model: 'morph-docx',
+        messages: contextMessages,
+        stream: false,
+      }),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`API error: ${error}`);
     }
 
-    try {
-      switch (name) {
-        case 'read_document': {
-          const result = await this.client.read(docId);
-          return `Document content (${result.paragraphs} paragraphs):\n\n${result.content}`;
-        }
+    return response.json();
+  }
 
-        case 'add_comment': {
-          const result = await this.client.edit(docId, [
-            {
-              type: 'add_comment',
-              para_text: args.para_text as string,
-              comment: args.comment as string,
-              highlight: args.highlight as string | undefined,
-            },
-          ]);
-          return result.results[0];
-        }
+  /**
+   * Send a streaming chat completion request.
+   * Returns an async generator that yields chunks as they arrive.
+   */
+  async *chatStream(messages: Message[]): AsyncGenerator<StreamChunk> {
+    // Add document context to user message if we have a document ID
+    const contextMessages = this.documentId
+      ? messages.map((m, i) => {
+          if (i === messages.length - 1 && m.role === 'user') {
+            return {
+              ...m,
+              content: `[Document ID: ${this.documentId}]\n\n${m.content}`,
+            };
+          }
+          return m;
+        })
+      : messages;
+
+    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        ...(this.apiKey && { Authorization: `Bearer ${this.apiKey}` }),
+      },
+      body: JSON.stringify({
+        model: 'morph-docx',
+        messages: contextMessages,
+        stream: true,
+      }),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`API error: ${error}`);
+    }
 
-        case 'insert_text': {
-          const result = await this.client.edit(docId, [
-            {
-              type: 'insert_text',
-              para_text: args.para_text as string,
-              after: args.after as string,
-              new_text: args.new_text as string,
-            },
-          ]);
-          return result.results[0];
-        }
+    const reader = response.body?.getReader();
+    if (!reader) {
+      throw new Error('No response body');
+    }
 
-        case 'propose_deletion': {
-          const result = await this.client.edit(docId, [
-            {
-              type: 'propose_deletion',
-              para_text: args.para_text as string,
-              target: args.target as string | undefined,
-            },
-          ]);
-          return result.results[0];
-        }
+    const decoder = new TextDecoder();
+    let buffer = '';
 
-        case 'reply_comment': {
-          const result = await this.client.edit(docId, [
-            {
-              type: 'reply_comment',
-              comment_id: args.comment_id as string,
-              reply: args.reply as string,
-            },
-          ]);
-          return result.results[0];
-        }
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
 
-        case 'resolve_comment': {
-          const result = await this.client.edit(docId, [
-            {
-              type: 'resolve_comment',
-              comment_id: args.comment_id as string,
-            },
-          ]);
-          return result.results[0];
-        }
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
 
-        case 'delete_comment': {
-          const result = await this.client.edit(docId, [
-            {
-              type: 'delete_comment',
-              comment_id: args.comment_id as string,
-            },
-          ]);
-          return result.results[0];
-        }
+      for (const line of lines) {
+        if (!line.startsWith('data: ')) continue;
+        const data = line.slice(6).trim();
+        if (data === '[DONE]') return;
 
-        case 'insert_paragraph': {
-          const result = await this.client.edit(docId, [
-            {
-              type: 'insert_paragraph',
-              after_text: args.after_text as string,
-              new_text: args.new_text as string,
-            },
-          ]);
-          return result.results[0];
+        try {
+          const chunk = JSON.parse(data);
+          yield chunk;
+        } catch {
+          // Skip malformed JSON
         }
-
-        case 'validate_document': {
-          const result = await this.client.validate(docId);
-          return `${result.result}: ${result.output}`;
-        }
-
-        default:
-          return `Error: Unknown tool '${name}'`;
       }
-    } catch (error) {
-      return `Error: ${error instanceof Error ? error.message : String(error)}`;
     }
   }
+
+  /**
+   * Helper: Simple completion that returns just the content string.
+   */
+  async complete(userMessage: string): Promise<string> {
+    const response = await this.chat([{ role: 'user', content: userMessage }]);
+    return response.choices[0]?.message?.content || '';
+  }
+
+  /**
+   * Create an OpenAI-compatible client configuration.
+   * Use this with the OpenAI SDK or OpenAI Agents SDK.
+   *
+   * @example
+   * ```typescript
+   * import OpenAI from 'openai';
+   * import { DocxAgent } from 'subagents/docx';
+   *
+   * const agent = new DocxAgent();
+   * const openai = new OpenAI(agent.getOpenAIConfig());
+   *
+   * const response = await openai.chat.completions.create({
+   *   model: 'morph-docx',
+   *   messages: [{ role: 'user', content: 'Hello!' }],
+   * });
+   * ```
+   */
+  getOpenAIConfig() {
+    return {
+      baseURL: this.baseUrl,
+      apiKey: this.apiKey || 'not-required',
+    };
+  }
 }

package/src/docx/client.ts

@@ -10,9 +10,13 @@ import type {
   EditOperation,
   EditResponse,
   ValidateResponse,
+  BuildOperation,
+  BuildResponse,
+  CreateResponse,
+  DocumentInfoResponse,
 } from './types';
 
-const DEFAULT_API_URL = 'https://docx-api-service-production.up.railway.app';
+const DEFAULT_API_URL = 'https://api.subagents.com/v1/morph-docx';
 
 export class DocxClient extends BaseClient {
   constructor(options: DocxClientOptions = {}) {
@@ -66,4 +70,57 @@ export class DocxClient extends BaseClient {
   async deleteDocument(docId: string): Promise<void> {
     return this.delete(`/documents/${docId}`);
   }
+
+  // --- Creation Operations ---
+
+  /**
+   * Create a new empty DOCX document.
+   */
+  async create(title?: string): Promise<CreateResponse> {
+    return this.post('/documents/create', { title });
+  }
+
+  /**
+   * Execute build operations on a document (add content).
+   */
+  async build(docId: string, operations: BuildOperation[]): Promise<BuildResponse> {
+    return this.post(`/documents/${docId}/build`, { operations });
+  }
+
+  /**
+   * Get document information.
+   */
+  async getInfo(docId: string): Promise<DocumentInfoResponse> {
+    return this.get(`/documents/${docId}/info`);
+  }
+
+  // --- Convenience Methods ---
+
+  /**
+   * Add a heading to the document.
+   */
+  async addHeading(docId: string, text: string, level = 1): Promise<BuildResponse> {
+    return this.build(docId, [{ type: 'add_heading', text, level }]);
+  }
+
+  /**
+   * Add a paragraph to the document.
+   */
+  async addParagraph(docId: string, text: string, options?: Partial<BuildOperation>): Promise<BuildResponse> {
+    return this.build(docId, [{ type: 'add_paragraph', text, ...options }]);
+  }
+
+  /**
+   * Add a table to the document.
+   */
+  async addTable(docId: string, headers: string[], rows: string[][]): Promise<BuildResponse> {
+    return this.build(docId, [{ type: 'add_table', headers, rows }]);
+  }
+
+  /**
+   * Add page numbers to the document.
+   */
+  async addPageNumbers(docId: string, format = 'Page {PAGE} of {NUMPAGES}'): Promise<BuildResponse> {
+    return this.build(docId, [{ type: 'add_page_numbers', format_string: format }]);
+  }
 }

package/src/docx/index.ts

@@ -1,5 +1,5 @@
 /**
- * @morphllm/subagents/docx
+ * subagents/docx
  *
  * DOCX document editing subagent for track changes, comments, and more.
  */

package/src/docx/types.ts

@@ -24,7 +24,81 @@ export type EditOperationType =
   | 'delete_comment'
   | 'insert_text'
   | 'insert_paragraph'
-  | 'propose_deletion';
+  | 'propose_deletion'
+  | 'reject_insertion'
+  | 'restore_deletion'
+  | 'enable_track_changes';
+
+/** Build operation types (for document creation) */
+export type BuildOperationType =
+  | 'add_heading'
+  | 'add_paragraph'
+  | 'add_table'
+  | 'add_image'
+  | 'add_list_item'
+  | 'add_hyperlink'
+  | 'add_page_break'
+  | 'add_section_break'
+  | 'add_header'
+  | 'add_footer'
+  | 'add_page_numbers'
+  | 'setup_styles';
+
+/** Build operation payload */
+export interface BuildOperation {
+  type: BuildOperationType;
+  text?: string;
+  level?: number;
+  style?: string;
+  alignment?: 'left' | 'center' | 'right' | 'justify';
+  bold?: boolean;
+  italic?: boolean;
+  font_size?: number;
+  font_name?: string;
+  color?: string;
+  space_before?: number;
+  space_after?: number;
+  headers?: string[];
+  rows?: string[][];
+  header_bg_color?: string;
+  image_url?: string;
+  image_data?: string;
+  width?: number;
+  height?: number;
+  list_type?: 'bullet' | 'number';
+  url?: string;
+  position?: 'header' | 'footer';
+  format_string?: string;
+  section_index?: number;
+  base_font?: string;
+  base_size?: number;
+  heading_font?: string;
+  primary_color?: string;
+  break_type?: 'next_page' | 'continuous' | 'even_page' | 'odd_page';
+}
+
+/** Response from create operations */
+export interface CreateResponse {
+  doc_id: string;
+  message: string;
+}
+
+/** Response from build operations */
+export interface BuildResponse {
+  results: string[];
+  doc_id: string;
+}
+
+/** Document info response */
+export interface DocumentInfoResponse {
+  paragraphs: number;
+  tables: number;
+  sections: number;
+  title: string;
+  author: string;
+  created: string;
+  modified: string;
+}
 
 /** Edit operation payload */
 export interface EditOperation {
@@ -62,7 +136,77 @@ export interface DocxClientOptions extends BaseClientOptions {
 }
 
 /** DOCX agent options */
-export interface DocxAgentOptions extends BaseAgentOptions {
+export interface DocxAgentOptions {
+  /** Base URL for the API. Defaults to api.subagents.com/v1 */
+  baseUrl?: string;
+  /** API key (optional, not required for public endpoints) */
+  apiKey?: string;
   /** Current document ID */
   documentId?: string;
 }
+
+/** Chat message */
+export interface Message {
+  role: 'system' | 'user' | 'assistant' | 'tool';
+  content: string;
+  tool_call_id?: string;
+  tool_calls?: ToolCall[];
+}
+
+/** Tool call in a message */
+export interface ToolCall {
+  id: string;
+  type: 'function';
+  function: {
+    name: string;
+    arguments: string;
+  };
+}
+
+/** Chat completion response (non-streaming) */
+export interface ChatCompletionResponse {
+  id: string;
+  object: 'chat.completion';
+  created: number;
+  model: string;
+  choices: {
+    index: number;
+    message: {
+      role: 'assistant';
+      content: string | null;
+      tool_calls?: ToolCall[];
+    };
+    finish_reason: string;
+  }[];
+  usage?: {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+  };
+}
+
+/** Stream chunk */
+export interface StreamChunk {
+  id?: string;
+  object?: string;
+  created?: number;
+  model?: string;
+  choices?: {
+    index: number;
+    delta: {
+      role?: string;
+      content?: string;
+      tool_calls?: {
+        index: number;
+        id?: string;
+        type?: string;
+        function?: {
+          name?: string;
+          arguments?: string;
+        };
+      }[];
+    };
+    finish_reason?: string | null;
+  }[];
+  error?: string;
+}