@docrouter/mcp 0.1.2 → 0.2.0

package/dist/index.mjs

@@ -197,13 +197,14 @@ function validateSchemaFormat(schema) {
       errors.push("Schema must be an object");
       return { valid: false, errors, warnings };
     }
-    if (!schema.type || schema.type !== "json_schema") {
+    const schemaObj = schema;
+    if (!schemaObj.type || schemaObj.type !== "json_schema") {
       errors.push('Schema must have type: "json_schema"');
     }
-    if (!schema.json_schema || typeof schema.json_schema !== "object") {
+    if (!schemaObj.json_schema || typeof schemaObj.json_schema !== "object") {
       errors.push("Schema must have json_schema object");
     } else {
-      const jsonSchema = schema.json_schema;
+      const jsonSchema = schemaObj.json_schema;
       if (!jsonSchema.name || typeof jsonSchema.name !== "string") {
         errors.push("json_schema must have a name field");
       }
@@ -245,8 +246,14 @@ function validateSchemaFormat(schema) {
         }
       }
     }
-    if (schema.json_schema?.schema?.properties) {
-      checkForNonPortableFeatures(schema.json_schema.schema.properties, warnings);
+    if (schemaObj.json_schema && typeof schemaObj.json_schema === "object") {
+      const jsonSchema = schemaObj.json_schema;
+      if (jsonSchema.schema && typeof jsonSchema.schema === "object") {
+        const innerSchema = jsonSchema.schema;
+        if (innerSchema.properties) {
+          checkForNonPortableFeatures(innerSchema.properties, warnings);
+        }
+      }
     }
   } catch (error) {
     errors.push(`Schema validation error: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -276,18 +283,19 @@ function validateNestedObjects(properties, errors, warnings) {
         }
       }
       if (prop.type === "array" && prop.items) {
-        if (prop.items.type === "object") {
-          if (!prop.items.properties || typeof prop.items.properties !== "object") {
+        const items = prop.items;
+        if (items.type === "object") {
+          if (!items.properties || typeof items.properties !== "object") {
             errors.push(`Array items object "${propName}" must have properties object`);
           }
-          if (!Array.isArray(prop.items.required)) {
+          if (!Array.isArray(items.required)) {
             errors.push(`Array items object "${propName}" must have required array`);
           }
-          if (prop.items.additionalProperties !== false) {
+          if (items.additionalProperties !== false) {
             errors.push(`Array items object "${propName}" must have additionalProperties: false`);
           }
-          if (prop.items.properties) {
-            validateNestedObjects(prop.items.properties, errors);
+          if (items.properties) {
+            validateNestedObjects(items.properties, errors);
           }
         }
       }
@@ -316,8 +324,11 @@ function checkForNonPortableFeatures(properties, warnings) {
       if (prop.type === "object" && prop.properties) {
         checkForNonPortableFeatures(prop.properties, warnings);
       }
-      if (prop.type === "array" && prop.items && prop.items.type === "object" && prop.items.properties) {
-        checkForNonPortableFeatures(prop.items.properties, warnings);
+      if (prop.type === "array" && prop.items) {
+        const items = prop.items;
+        if (items.type === "object" && items.properties) {
+          checkForNonPortableFeatures(items.properties, warnings);
+        }
       }
     }
   }
@@ -330,13 +341,14 @@ function validateFormFormat(form) {
       errors.push("Form must be an object");
       return { valid: false, errors, warnings };
     }
-    if (!form.json_formio || !Array.isArray(form.json_formio)) {
+    const formObj = form;
+    if (!formObj.json_formio || !Array.isArray(formObj.json_formio)) {
       errors.push("Form must have json_formio array");
       return { valid: false, errors, warnings };
     }
-    validateFormComponents(form.json_formio, errors, warnings, "");
-    if (form.json_formio_mapping) {
-      validateFieldMappings(form.json_formio_mapping, form.json_formio, errors, warnings);
+    validateFormComponents(formObj.json_formio, errors, warnings, "");
+    if (formObj.json_formio_mapping) {
+      validateFieldMappings(formObj.json_formio_mapping, formObj.json_formio, errors, warnings);
     }
   } catch (error) {
     errors.push(`Form validation error: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -377,49 +389,50 @@ function validateFormComponents(components, errors, warnings, path) {
       errors.push(`${componentPath}: Component must be an object`);
       continue;
     }
-    if (!component.type) {
+    const comp = component;
+    if (!comp.type) {
       errors.push(`${componentPath}: Component must have a "type" field`);
-    } else if (!validFieldTypes.includes(component.type)) {
-      warnings.push(`${componentPath}: Unknown field type "${component.type}" - may not render correctly`);
+    } else if (!validFieldTypes.includes(comp.type)) {
+      warnings.push(`${componentPath}: Unknown field type "${comp.type}" - may not render correctly`);
     }
-    if (component.input === true || ["textfield", "email", "number", "select", "textarea", "checkbox", "datetime", "phoneNumber"].includes(component.type)) {
-      if (!component.key) {
+    if (comp.input === true || ["textfield", "email", "number", "select", "textarea", "checkbox", "datetime", "phoneNumber"].includes(comp.type)) {
+      if (!comp.key) {
         errors.push(`${componentPath}: Input component must have a "key" field`);
       } else {
-        if (collectedKeys.has(component.key)) {
-          errors.push(`${componentPath}: Duplicate key "${component.key}" found`);
+        if (collectedKeys.has(comp.key)) {
+          errors.push(`${componentPath}: Duplicate key "${comp.key}" found`);
         }
-        collectedKeys.add(component.key);
-        if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(component.key)) {
-          warnings.push(`${componentPath}: Key "${component.key}" should be a valid identifier (alphanumeric and underscore only)`);
+        collectedKeys.add(comp.key);
+        if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(comp.key)) {
+          warnings.push(`${componentPath}: Key "${comp.key}" should be a valid identifier (alphanumeric and underscore only)`);
         }
       }
-      if (!component.label) {
+      if (!comp.label) {
         warnings.push(`${componentPath}: Input component should have a "label" field for better UX`);
       }
     }
-    if (component.type === "select") {
-      if (!component.data || !component.data.values) {
+    if (comp.type === "select") {
+      if (!comp.data || !comp.data.values) {
         errors.push(`${componentPath}: Select field must have data.values array`);
-      } else if (!Array.isArray(component.data.values)) {
+      } else if (!Array.isArray(comp.data.values)) {
         errors.push(`${componentPath}: data.values must be an array`);
-      } else if (component.data.values.length === 0) {
+      } else if (comp.data.values.length === 0) {
         warnings.push(`${componentPath}: Select field has empty values array`);
       }
     }
-    if (component.type === "panel" || component.type === "fieldset") {
-      if (!component.components || !Array.isArray(component.components)) {
-        errors.push(`${componentPath}: ${component.type} must have components array`);
+    if (comp.type === "panel" || comp.type === "fieldset") {
+      if (!comp.components || !Array.isArray(comp.components)) {
+        errors.push(`${componentPath}: ${comp.type} must have components array`);
       } else {
-        validateFormComponents(component.components, errors, warnings, `${componentPath}.components`);
+        validateFormComponents(comp.components, errors, warnings, `${componentPath}.components`);
       }
     }
-    if (component.type === "columns") {
-      if (!component.columns || !Array.isArray(component.columns)) {
+    if (comp.type === "columns") {
+      if (!comp.columns || !Array.isArray(comp.columns)) {
         errors.push(`${componentPath}: columns layout must have columns array`);
       } else {
-        for (let j = 0; j < component.columns.length; j++) {
-          const column = component.columns[j];
+        for (let j = 0; j < comp.columns.length; j++) {
+          const column = comp.columns[j];
           if (!column.components || !Array.isArray(column.components)) {
             errors.push(`${componentPath}.columns[${j}]: Column must have components array`);
           } else {
@@ -428,8 +441,8 @@ function validateFormComponents(components, errors, warnings, path) {
         }
       }
     }
-    if (component.validate) {
-      if (typeof component.validate !== "object") {
+    if (comp.validate) {
+      if (typeof comp.validate !== "object") {
         errors.push(`${componentPath}: validate must be an object`);
       }
     }
@@ -443,11 +456,13 @@ function validateFieldMappings(mappings, formComponents, errors, warnings) {
   const formKeys = /* @__PURE__ */ new Set();
   const collectKeys = (components) => {
     for (const comp of components) {
-      if (comp.key) formKeys.add(comp.key);
-      if (comp.components) collectKeys(comp.components);
-      if (comp.columns) {
-        for (const col of comp.columns) {
-          if (col.components) collectKeys(col.components);
+      const compObj = comp;
+      if (compObj.key) formKeys.add(compObj.key);
+      if (compObj.components) collectKeys(compObj.components);
+      if (compObj.columns) {
+        for (const col of compObj.columns) {
+          const colObj = col;
+          if (colObj.components) collectKeys(colObj.components);
         }
       }
     }
@@ -503,11 +518,11 @@ var tools = [
             type: "object",
             properties: {
               name: { type: "string", description: "Document name" },
-              content: { type: "string", description: "Base64 encoded document content" },
-              type: { type: "string", description: "Document type (pdf, image, etc.)" },
+              content: { type: "string", description: "Base64 encoded document content (supports both plain base64 and data URLs)" },
+              tag_ids: { type: "array", items: { type: "string" }, description: "Optional list of tag IDs" },
               metadata: { type: "object", description: "Optional metadata" }
             },
-            required: ["name", "content", "type"]
+            required: ["name", "content"]
           }
         }
       },
@@ -1005,7 +1020,7 @@ var tools = [
         max_tokens: { type: "number", description: "Maximum tokens" },
         stream: { type: "boolean", description: "Enable streaming" }
       },
-      required: ["messages"]
+      required: ["messages", "model"]
     }
   },
   // ========== HELPER TOOLS ==========
@@ -1206,11 +1221,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       // ========== DOCUMENTS ==========
       case "upload_documents": {
         const documentsInput = getArg(args, "documents");
-        const documents = documentsInput.map((doc) => ({
-          ...doc,
-          content: Buffer.from(doc.content, "base64")
-        }));
-        const result = await docrouterClient.uploadDocuments({ documents });
+        const result = await docrouterClient.uploadDocuments({ documents: documentsInput });
         return {
           content: [
             {
@@ -1636,7 +1647,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       case "run_llm_chat": {
         const result = await docrouterClient.runLLMChat({
           messages: getArg(args, "messages"),
-          model: getOptionalArg(args, "model"),
+          model: getArg(args, "model"),
           temperature: getOptionalArg(args, "temperature"),
           max_tokens: getOptionalArg(args, "max_tokens"),
           stream: getOptionalArg(args, "stream")