@hotmeshio/long-tail 0.1.4 → 0.1.6

package/build/system/seed/server-definitions.js

@@ -10,18 +10,9 @@ const tool_manifests_escalation_1 = require("./tool-manifests-escalation");
 const tool_manifests_data_1 = require("./tool-manifests-data");
 const tool_manifests_browser_1 = require("./tool-manifests-browser");
 const tool_manifests_workflows_1 = require("./tool-manifests-workflows");
+const tool_manifests_admin_1 = require("./tool-manifests-admin");
+const tool_manifests_knowledge_1 = require("./tool-manifests-knowledge");
 exports.SEED_MCP_SERVERS = [
-    {
-        name: 'long-tail-db-query',
-        description: 'Read-only query tools for tasks, escalations, processes, and system health. Used by triage workflows to gather context before making decisions.',
-        transport_type: 'stdio',
-        transport_config: { builtin: true, process: 'in-memory' },
-        tool_manifest: tool_manifests_data_1.DB_QUERY_TOOLS,
-        metadata: { builtin: true, category: 'database' },
-        tags: ['database', 'query', 'analytics'],
-        compile_hints: 'Query tools return structured result sets. When a query result is consumed by a later step, wire the specific output field (e.g., "rows", "tasks") — not the entire result object.',
-        credential_providers: [],
-    },
     {
         name: 'long-tail-human-queue',
         description: 'Built-in escalation and human queue management. Exposes the escalation API as MCP tools for AI agents and remediation workflows.',
@@ -40,36 +31,30 @@ exports.SEED_MCP_SERVERS = [
         credential_providers: [],
     },
     {
-        name: 'mcp-workflows-longtail',
-        description: 'Compiled YAML workflows — hardened deterministic pipelines from successful MCP triage executions. Invoke proven solutions to edge cases without LLM reasoning.',
-        transport_type: 'stdio',
-        transport_config: { builtin: true, process: 'in-memory' },
-        tool_manifest: tool_manifests_workflows_1.MCP_WORKFLOW_TOOLS,
-        metadata: { builtin: true, category: 'workflows' },
-        tags: ['workflows', 'compiled', 'deterministic'],
-        compile_hints: null,
-        credential_providers: [],
-    },
-    {
-        name: 'long-tail-workflow-compiler',
-        description: 'Convert dynamic MCP tool call sequences into deterministic YAML workflows. Analyze executions, generate pipelines, deploy and activate.',
+        name: 'long-tail-translation',
+        description: 'Text translation using LLM. Translates content between languages with automatic source language detection.',
         transport_type: 'stdio',
         transport_config: { builtin: true, process: 'in-memory' },
-        tool_manifest: tool_manifests_workflows_1.WORKFLOW_COMPILER_TOOLS,
-        metadata: { builtin: true, category: 'compilation' },
-        tags: ['compilation', 'yaml', 'codegen'],
+        tool_manifest: tool_manifests_data_1.TRANSLATION_TOOLS,
+        metadata: { builtin: true, category: 'text-processing' },
+        tags: ['translation', 'language', 'text-processing'],
         compile_hints: null,
-        credential_providers: [],
+        credential_providers: ['anthropic'],
     },
     {
-        name: 'long-tail-document-vision',
-        description: 'Document vision and analysis tools. Processes document images, extracts structured data, validates against databases, and handles translations.',
+        name: 'long-tail-vision',
+        description: 'Image analysis and description using LLM vision. Analyzes images to extract structured data, text content, and descriptions.',
         transport_type: 'stdio',
         transport_config: { builtin: true, process: 'in-memory' },
-        tool_manifest: tool_manifests_data_1.VISION_TOOLS,
-        metadata: { builtin: true, category: 'document-processing' },
-        tags: ['document-processing', 'vision', 'ocr', 'translation'],
-        compile_hints: 'Vision tools process one document at a time. When iterating over multiple documents, each iteration should pass a single image path or URL.',
+        tool_manifest: tool_manifests_data_1.VISION_ANALYSIS_TOOLS,
+        metadata: { builtin: true, category: 'vision' },
+        tags: ['vision', 'image-analysis', 'multimodal'],
+        compile_hints: [
+            'Vision tools process one image at a time. When iterating over multiple images, each iteration should pass a single image URL or data URI.',
+            'The argument name is `image` (NOT `image_path`). It accepts a storage path (e.g., "screenshot.png"), a data URI, or an https:// URL. When following a screenshot or capture_page step, wire `image` from the producing step output field `path`. NEVER make `image` a trigger input when the image is produced by a prior step.',
+            'Vision tools do NOT use browser sessions. Do NOT wire page_id or _handle to vision tools — they read from storage, not from the browser.',
+            'analyze_image output fields: description (string), text_content (string), objects (array). The main analysis text is in `description` — NOT `analysis` or `content`.',
+        ].join(' '),
         credential_providers: ['anthropic'],
     },
     {
@@ -85,6 +70,8 @@ exports.SEED_MCP_SERVERS = [
             'run_script accepts a `steps` array — this is a fixed implementation detail, never a dynamic input.',
             'When run_script follows a signal hook (human input), dynamic values like passwords must be wired from the hook output into the stored steps array.',
             'The `steps` array should be stored as fixed tool_arguments, but individual values within it (url, username, password) that come from trigger inputs or signal hooks should be wired via data_flow edges to their specific argument keys (e.g., to_field: "password").',
+            'run_script exposes `screenshots` (array of paths) and `last_screenshot_path` (string) as top-level output fields. When a downstream step needs a screenshot path (e.g., vision analyze_image or describe_image), wire from `last_screenshot_path` — NEVER from the nested `steps` array.',
+            'The screenshot tool supports `describe: true` to auto-analyze via vision LLM. When the user intent includes understanding page content (not just capturing it), prefer screenshot with describe:true over a separate describe_image step — this eliminates an entire activity from the compiled DAG.',
         ].join(' '),
         credential_providers: [],
     },
@@ -102,9 +89,21 @@ exports.SEED_MCP_SERVERS = [
             'capture_authenticated_pages expects a `login` object and a `pages` array. The `login` object contains nested fields (url, username, password, selectors) — flatten credentials as dynamic trigger inputs but keep the object structure in stored tool_arguments. The `pages` array should flow from a transform edge that reshapes `links` into [{url, screenshot_path, wait_ms, full_page}].',
             'For screenshot_path derivation in transforms, use the `screenshot_dir` trigger input as a dynamic prefix (not hardcoded). Derivation strategy: slugify the href, prepend screenshot_dir + "/", append ".png".',
             'When login_and_capture follows a signal hook (human input), wire the password from the hook output to the `password` argument. Wire `url` and `username` from trigger inputs.',
+            'capture_page screenshot_path MUST include a file extension (e.g., .png). When deriving screenshot_path from a slug or identifier, always append ".png" using a concat derivation: { "strategy": "concat", "parts": ["{value}", ".png"] }. For date-stamped paths use: { "strategy": "concat", "parts": ["{value}", "-", "{date}", ".png"] }.',
         ].join(' '),
         credential_providers: [],
     },
+    {
+        name: 'long-tail-docs',
+        description: 'Product documentation search and retrieval. List, search, and read Long Tail documentation covering architecture, workflows, MCP, API reference, IAM, and more.',
+        transport_type: 'stdio',
+        transport_config: { builtin: true, process: 'in-memory' },
+        tool_manifest: tool_manifests_data_1.DOCS_TOOLS,
+        metadata: { builtin: true, category: 'documentation' },
+        tags: ['documentation', 'help', 'reference'],
+        compile_hints: null,
+        credential_providers: [],
+    },
     {
         name: 'long-tail-file-storage',
         description: 'Managed file storage for reading, writing, listing, and deleting files. Used by workflows and triage agents for persistent file I/O.',
@@ -157,4 +156,39 @@ exports.SEED_MCP_SERVERS = [
             'fields in subsequent steps rather than passing the full result.',
         credential_providers: ['anthropic'],
     },
+    {
+        name: 'long-tail-admin',
+        description: 'System administration tools for reflexive self-management. Certify and de-certify workflows, ' +
+            'update MCP server tags, connect/disconnect servers, create users, manage roles, and release ' +
+            'expired escalation claims. Closes the loop: the triage agent can compile a fix, certify it, ' +
+            'and configure the system without human intervention.',
+        transport_type: 'stdio',
+        transport_config: { builtin: true, process: 'in-memory' },
+        tool_manifest: tool_manifests_admin_1.ADMIN_TOOLS,
+        metadata: { builtin: true, category: 'admin' },
+        tags: ['admin', 'system', 'configuration'],
+        compile_hints: 'Admin tools modify system configuration. certify_workflow and decertify_workflow ' +
+            'change how the interceptor treats a workflow — use after deploying a compiled pipeline ' +
+            'to give it full task tracking and escalation support. update_server_tags changes tool ' +
+            'discovery scope — only use when a server genuinely serves a different purpose than tagged.',
+        credential_providers: [],
+    },
+    {
+        name: 'long-tail-knowledge',
+        description: 'Persistent knowledge store for autonomous agents. Store, retrieve, search, and accumulate ' +
+            'JSONB documents in isolated domains. Enables workflows to build long-term memory, ' +
+            'catalog research results, and share context across executions.',
+        transport_type: 'stdio',
+        transport_config: { builtin: true, process: 'in-memory' },
+        tool_manifest: tool_manifests_knowledge_1.KNOWLEDGE_TOOLS,
+        metadata: { builtin: true, category: 'knowledge' },
+        tags: ['knowledge', 'memory', 'state', 'storage'],
+        compile_hints: 'store_knowledge arguments: domain (string), key (string), data (the content to store — NOT "content"), data_key (optional sub-key). ' +
+            'store_knowledge upserts by domain+key — it merges data if the entry exists. ' +
+            'Use a consistent domain name across related workflows to build shared context. ' +
+            'search_knowledge uses JSONB containment (@>) — the query object must be a subset of the stored data. ' +
+            'append_knowledge adds to arrays without replacing existing entries — ideal for catalogs and logs. ' +
+            'list_domains returns all domains with counts, useful for discovering what knowledge exists.',
+        credential_providers: [],
+    },
 ];