@morphllm/subagents 0.1.3 → 0.1.4

package/dist/docx/index.mjs

@@ -67,7 +67,7 @@ var BaseClient = class {
 };
 
 // src/docx/client.ts
-var DEFAULT_API_URL = "https://docx-api-service-production.up.railway.app";
+var DEFAULT_API_URL = "https://subagents.morphllm.com/v1/morph-docx";
 var DocxClient = class extends BaseClient {
   constructor(options = {}) {
     super(options);
@@ -113,333 +113,60 @@ var DocxClient = class extends BaseClient {
   async deleteDocument(docId) {
     return this.delete(`/documents/${docId}`);
   }
-};
-
-// src/core/base-agent.ts
-var BaseAgent = class {
-  constructor(options) {
-    this.openai = options.openai;
-    this.model = options.model || this.getDefaultModel();
-    this.instructions = options.instructions || this.getDefaultInstructions();
-    this.client = options.client;
+  // --- Creation Operations ---
+  /**
+   * Create a new empty DOCX document.
+   */
+  async create(title) {
+    return this.post("/documents/create", { title });
   }
-  /** Get the underlying client */
-  getClient() {
-    return this.client;
+  /**
+   * Execute build operations on a document (add content).
+   */
+  async build(docId, operations) {
+    return this.post(`/documents/${docId}/build`, { operations });
   }
   /**
-   * Run the agent with a user message.
-   * Returns the final response and all tool calls made.
+   * Get document information.
    */
-  async run(userMessage, conversationHistory = []) {
-    if (!this.openai) {
-      throw new Error("OpenAI client is required for agent.run(). Pass it in the constructor options.");
-    }
-    const messages = [
-      { role: "system", content: this.instructions },
-      ...conversationHistory,
-      { role: "user", content: userMessage }
-    ];
-    const toolCalls = [];
-    let response = "";
-    const tools = this.getTools();
-    while (true) {
-      const completion = await this.openai.chat.completions.create({
-        model: this.model,
-        messages,
-        tools,
-        tool_choice: "auto"
-      });
-      const assistantMessage = completion.choices[0].message;
-      if (assistantMessage.tool_calls && assistantMessage.tool_calls.length > 0) {
-        messages.push({
-          role: "assistant",
-          content: assistantMessage.content || ""
-        });
-        for (const tc of assistantMessage.tool_calls) {
-          const fn = tc.function;
-          const args = JSON.parse(fn.arguments);
-          const toolCall = {
-            id: tc.id,
-            name: fn.name,
-            arguments: args,
-            status: "running"
-          };
-          toolCalls.push(toolCall);
-          const result = await this.executeTool(fn.name, args);
-          if (result.startsWith("Error:")) {
-            toolCall.error = result;
-            toolCall.status = "error";
-          } else {
-            toolCall.result = result;
-            toolCall.status = "completed";
-          }
-          messages.push({
-            role: "tool",
-            content: result,
-            tool_call_id: tc.id
-          });
-        }
-      } else {
-        response = assistantMessage.content || "";
-        break;
-      }
-    }
-    return { response, toolCalls };
+  async getInfo(docId) {
+    return this.get(`/documents/${docId}/info`);
   }
+  // --- Convenience Methods ---
   /**
-   * Run the agent with streaming output.
-   * Yields events for real-time UI updates.
+   * Add a heading to the document.
    */
-  async *runStream(userMessage, conversationHistory = []) {
-    if (!this.openai) {
-      throw new Error("OpenAI client is required for agent.runStream(). Pass it in the constructor options.");
-    }
-    const messages = [
-      { role: "system", content: this.instructions },
-      ...conversationHistory,
-      { role: "user", content: userMessage }
-    ];
-    const tools = this.getTools();
-    while (true) {
-      yield { type: "message_start", message: { role: "assistant" } };
-      const stream = await this.openai.chat.completions.create({
-        model: this.model,
-        messages,
-        tools,
-        tool_choice: "auto",
-        stream: true
-      });
-      let contentBuffer = "";
-      const toolCallBuffers = /* @__PURE__ */ new Map();
-      for await (const chunk of stream) {
-        const delta = chunk.choices[0]?.delta;
-        if (delta?.content) {
-          contentBuffer += delta.content;
-          yield { type: "content_delta", delta: { text: delta.content } };
-        }
-        if (delta?.tool_calls) {
-          for (const tc of delta.tool_calls) {
-            const idx = tc.index;
-            if (!toolCallBuffers.has(idx)) {
-              toolCallBuffers.set(idx, { id: "", name: "", arguments: "" });
-            }
-            const buffer = toolCallBuffers.get(idx);
-            if (tc.id) buffer.id = tc.id;
-            if (tc.function?.name) buffer.name = tc.function.name;
-            if (tc.function?.arguments) buffer.arguments += tc.function.arguments;
-          }
-        }
-      }
-      if (toolCallBuffers.size > 0) {
-        messages.push({
-          role: "assistant",
-          content: contentBuffer
-        });
-        for (const [_, buffer] of toolCallBuffers) {
-          const args = JSON.parse(buffer.arguments);
-          yield {
-            type: "tool_start",
-            tool: { id: buffer.id, name: buffer.name, arguments: args }
-          };
-          const result = await this.executeTool(buffer.name, args);
-          if (result.startsWith("Error:")) {
-            yield { type: "tool_end", tool: { id: buffer.id, error: result } };
-          } else {
-            yield { type: "tool_end", tool: { id: buffer.id, result } };
-          }
-          messages.push({
-            role: "tool",
-            content: result,
-            tool_call_id: buffer.id
-          });
-        }
-      } else {
-        yield { type: "message_end" };
-        break;
-      }
-    }
+  async addHeading(docId, text, level = 1) {
+    return this.build(docId, [{ type: "add_heading", text, level }]);
+  }
+  /**
+   * Add a paragraph to the document.
+   */
+  async addParagraph(docId, text, options) {
+    return this.build(docId, [{ type: "add_paragraph", text, ...options }]);
+  }
+  /**
+   * Add a table to the document.
+   */
+  async addTable(docId, headers, rows) {
+    return this.build(docId, [{ type: "add_table", headers, rows }]);
+  }
+  /**
+   * Add page numbers to the document.
+   */
+  async addPageNumbers(docId, format = "Page {PAGE} of {NUMPAGES}") {
+    return this.build(docId, [{ type: "add_page_numbers", format_string: format }]);
   }
 };
 
 // src/docx/agent.ts
-var DEFAULT_INSTRUCTIONS = `You are an expert DOCX document editing assistant.
-
-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`;
-var TOOLS = [
-  {
-    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"]
-      }
-    }
-  }
-];
-var DocxAgent = class extends BaseAgent {
+var DEFAULT_BASE_URL = "https://subagents.morphllm.com/v1";
+var DocxAgent = class {
   constructor(options = {}) {
-    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;
   }
-  getDefaultModel() {
-    return "moonshot-v1-32k";
-  }
-  getDefaultInstructions() {
-    return this.documentId ? `${DEFAULT_INSTRUCTIONS}
-
-Current document ID: ${this.documentId}` : DEFAULT_INSTRUCTIONS;
-  }
-  getTools() {
-    return TOOLS;
-  }
   /** Set the current document ID */
   setDocument(docId) {
     this.documentId = docId;
@@ -448,100 +175,127 @@ Current document ID: ${this.documentId}` : DEFAULT_INSTRUCTIONS;
   getDocumentId() {
     return this.documentId;
   }
-  async executeTool(name, args) {
-    const docId = args.doc_id || 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) {
+    const contextMessages = this.documentId ? messages.map((m, i) => {
+      if (i === messages.length - 1 && m.role === "user") {
+        return {
+          ...m,
+          content: `[Document ID: ${this.documentId}]
+
+${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):
+    return response.json();
+  }
+  /**
+   * Send a streaming chat completion request.
+   * Returns an async generator that yields chunks as they arrive.
+   */
+  async *chatStream(messages) {
+    const contextMessages = this.documentId ? messages.map((m, i) => {
+      if (i === messages.length - 1 && m.role === "user") {
+        return {
+          ...m,
+          content: `[Document ID: ${this.documentId}]
 
-${result.content}`;
-        }
-        case "add_comment": {
-          const result = await this.client.edit(docId, [
-            {
-              type: "add_comment",
-              para_text: args.para_text,
-              comment: args.comment,
-              highlight: args.highlight
-            }
-          ]);
-          return result.results[0];
-        }
-        case "insert_text": {
-          const result = await this.client.edit(docId, [
-            {
-              type: "insert_text",
-              para_text: args.para_text,
-              after: args.after,
-              new_text: args.new_text
-            }
-          ]);
-          return result.results[0];
-        }
-        case "propose_deletion": {
-          const result = await this.client.edit(docId, [
-            {
-              type: "propose_deletion",
-              para_text: args.para_text,
-              target: args.target
-            }
-          ]);
-          return result.results[0];
-        }
-        case "reply_comment": {
-          const result = await this.client.edit(docId, [
-            {
-              type: "reply_comment",
-              comment_id: args.comment_id,
-              reply: args.reply
-            }
-          ]);
-          return result.results[0];
-        }
-        case "resolve_comment": {
-          const result = await this.client.edit(docId, [
-            {
-              type: "resolve_comment",
-              comment_id: args.comment_id
-            }
-          ]);
-          return result.results[0];
-        }
-        case "delete_comment": {
-          const result = await this.client.edit(docId, [
-            {
-              type: "delete_comment",
-              comment_id: args.comment_id
-            }
-          ]);
-          return result.results[0];
-        }
-        case "insert_paragraph": {
-          const result = await this.client.edit(docId, [
-            {
-              type: "insert_paragraph",
-              after_text: args.after_text,
-              new_text: args.new_text
-            }
-          ]);
-          return result.results[0];
-        }
-        case "validate_document": {
-          const result = await this.client.validate(docId);
-          return `${result.result}: ${result.output}`;
+${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}`);
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+      throw new Error("No response body");
+    }
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.startsWith("data: ")) continue;
+        const data = line.slice(6).trim();
+        if (data === "[DONE]") return;
+        try {
+          const chunk = JSON.parse(data);
+          yield chunk;
+        } catch {
         }
-        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) {
+    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 '@morphllm/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"
+    };
+  }
 };
 
 export { DocxAgent, DocxClient };