@hasna/connectors 1.3.45 → 1.3.46

package/bin/serve.js

@@ -16400,7 +16400,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/connectors",
-    version: "1.3.45",
+    version: "1.3.46",
     description: "Open source connector library - Install API connectors with a single command",
     type: "module",
     bin: {
@@ -16432,11 +16432,12 @@ var init_package = __esm(() => {
       "build:dashboard": "cd dashboard && bun run build",
       postinstall: 'mkdir -p $HOME/.hasna/connectors 2>/dev/null || true; [ "$SKIP_DASHBOARD" = "1" ] || [ ! -f dashboard/package.json ] || [ -d dashboard/node_modules ] || (cd dashboard && bun install)',
       dev: "bun run ./src/cli/index.tsx",
+      "check:package-secrets": "bun run scripts/check-package-secrets.ts",
       typecheck: "tsc --noEmit && tsc -p tsconfig.social.json --noEmit",
       test: "bun test",
       "secrets:scan:npmrc": "bun run scripts/scan-npmrc-auth.mjs",
       "sdk:build": "cd sdk && bun run build",
-      prepublishOnly: "bun run secrets:scan:npmrc && bun run build && bun test"
+      prepublishOnly: "bun run secrets:scan:npmrc && bun run check:package-secrets && bun run build && bun test"
     },
     keywords: [
       "connectors",
@@ -27814,6 +27815,13 @@ var connectors = [
     category: "AI & ML",
     tags: ["transcription", "meetings", "ai"]
   },
+  {
+    name: "wandb",
+    displayName: "Weights & Biases",
+    description: "ML experiment tracking and run management via GraphQL",
+    category: "AI & ML",
+    tags: ["ml", "experiments", "tracking"]
+  },
   {
     name: "wato",
     displayName: "Wato",
@@ -27821,6 +27829,13 @@ var connectors = [
     category: "AI & ML",
     tags: ["ai", "agents", "memory", "workflows"]
   },
+  {
+    name: "weights-biases",
+    displayName: "Weights & Biases",
+    description: "ML experiment tracking (runs, events, search)",
+    category: "AI & ML",
+    tags: ["ai", "ml", "wandb", "experiment-tracking"]
+  },
   {
     name: "wavelineextract",
     displayName: "Waveline Extract",
@@ -29459,6 +29474,20 @@ var connectors3 = [
     description: "HR platform for employees, leave, attendance, and timesheets",
     category: "Business Tools",
     tags: ["hr", "employees", "zoho"]
+  },
+  {
+    name: "zymbly",
+    displayName: "Zymbly",
+    description: "Aircraft maintenance and CMMS platform for work orders, parts, and maintenance notes",
+    category: "Business Tools",
+    tags: ["maintenance", "aircraft", "work-orders", "cmms"]
+  },
+  {
+    name: "zotero",
+    displayName: "Zotero",
+    description: "Bibliography and reference library API for items, collections, and attachments",
+    category: "Business Tools",
+    tags: ["bibliography", "citations", "research", "library", "references"]
   }
 ];
 
@@ -31969,6 +31998,13 @@ var connectors9 = [
     category: "Developer Tools",
     tags: ["cdn", "dns", "edge"]
   },
+  {
+    name: "cloudflare-workers",
+    displayName: "Cloudflare Workers",
+    description: "Cloudflare Workers REST API connector for scripts, multipart uploads, routes, deployments, versions, secrets, cron schedules, tails, subdomains, beta Workers, and scoped raw account or zone requests",
+    category: "Developer Tools",
+    tags: ["cloudflare", "workers", "serverless", "edge", "deployments", "developer-tools"]
+  },
   {
     name: "googlecloud",
     displayName: "Google Cloud",
@@ -34361,6 +34397,13 @@ var connectors14 = [
     description: "Reviews and user-generated content platform for e-commerce",
     category: "Marketing & Sales",
     tags: ["reviews", "ugc", "ecommerce", "marketing"]
+  },
+  {
+    name: "zoominfo",
+    displayName: "ZoomInfo",
+    description: "ZoomInfo B2B sales intelligence API for contact and company search, enrichment, lookup, and output field discovery",
+    category: "Marketing & Sales",
+    tags: ["sales-intelligence", "enrichment", "contacts", "companies", "b2b"]
   }
 ];
 
@@ -44630,30 +44673,126 @@ init_package();
 
 // src/mcp/tools/discovery.ts
 init_zod2();
+
+// src/lib/compact-output.ts
+var DEFAULT_MCP_LIMIT = 20;
+var MAX_COMPACT_LIMIT = 100;
+var DEFAULT_TEXT_WIDTH = 96;
+var DEFAULT_OUTPUT_CHARS = 6000;
+function parseNonNegativeInt(raw, flag) {
+  if (raw === undefined)
+    return { value: undefined };
+  if (!/^\d+$/.test(raw)) {
+    return {
+      value: undefined,
+      error: `Invalid value for ${flag}: '${raw}'. Expected a non-negative integer.`
+    };
+  }
+  return { value: parseInt(raw, 10) };
+}
+function normalizeLimit(value, fallback, max = MAX_COMPACT_LIMIT) {
+  if (value === undefined || !Number.isFinite(value))
+    return fallback;
+  return Math.min(Math.max(1, Math.floor(value)), max);
+}
+function parseCursor(raw) {
+  if (raw === undefined || raw === "")
+    return { value: 0 };
+  return parseNonNegativeInt(raw, "--cursor");
+}
+function pageItems(items, options) {
+  const offset = Math.max(0, options.offset ?? 0);
+  const limit = options.limit === undefined ? undefined : Math.max(1, Math.floor(options.limit));
+  const paged = limit === undefined ? items.slice(offset) : items.slice(offset, offset + limit);
+  const nextOffset = limit === undefined || offset + paged.length >= items.length ? null : offset + paged.length;
+  return {
+    items: paged,
+    total: items.length,
+    offset,
+    limit: limit ?? null,
+    nextOffset
+  };
+}
+function truncateText(value, max = DEFAULT_TEXT_WIDTH) {
+  const text = (value ?? "").replace(/\s+/g, " ").trim();
+  if (text.length <= max)
+    return text;
+  if (max <= 3)
+    return text.slice(0, max);
+  return `${text.slice(0, max - 3).trimEnd()}...`;
+}
+function firstNonEmptyLines(value, maxLines, maxWidth = DEFAULT_TEXT_WIDTH) {
+  return (value ?? "").split(`
+`).map((line) => line.trim()).filter(Boolean).slice(0, maxLines).map((line) => truncateText(line, maxWidth));
+}
+function compactConnector(connector, descriptionWidth = DEFAULT_TEXT_WIDTH) {
+  return {
+    name: connector.name,
+    displayName: connector.displayName,
+    version: connector.version,
+    category: connector.category,
+    description: truncateText(connector.description, descriptionWidth)
+  };
+}
+function maybeTruncateOutput(text, options = {}) {
+  const enabled = options.enabled ?? true;
+  const maxChars = options.maxChars ?? DEFAULT_OUTPUT_CHARS;
+  if (!enabled || text.length <= maxChars) {
+    return { text, truncated: false };
+  }
+  const hint = options.hint ?? "Use --verbose for full output.";
+  const omitted = text.length - maxChars;
+  return {
+    text: `${text.slice(0, maxChars).trimEnd()}
+
+[truncated ${omitted} chars] ${hint}`,
+    truncated: true
+  };
+}
+
+// src/mcp/tools/discovery.ts
 function registerDiscoveryTools(server, stripped) {
   server.registerTool("search_connectors", {
     title: "Search Connectors",
     description: "Search connectors by name or keyword.",
-    inputSchema: { query: exports_external2.string() }
-  }, async ({ query }) => {
+    inputSchema: {
+      query: exports_external2.string(),
+      limit: exports_external2.number().optional(),
+      verbose: exports_external2.boolean().optional()
+    }
+  }, async ({ query, limit, verbose }) => {
     const { getInstalledConnectors: getInstalledConnectors2 } = await Promise.resolve().then(() => (init_installer(), exports_installer));
     const { getPromotedConnectors: getPromotedConnectors2 } = await Promise.resolve().then(() => (init_promotions(), exports_promotions));
     const { getUsageMap: getUsageMap2 } = await Promise.resolve().then(() => (init_usage(), exports_usage));
+    const resultLimit = normalizeLimit(limit, DEFAULT_MCP_LIMIT);
     const results = searchConnectors(query, {
       installed: getInstalledConnectors2(),
       promoted: getPromotedConnectors2(),
-      usage: getUsageMap2()
+      usage: getUsageMap2(),
+      limit: resultLimit
     });
-    return stripped(JSON.stringify(results.map((c) => ({ name: c.name, displayName: c.displayName, version: c.version, category: c.category, description: c.description, score: c.score, badges: c.badges })), null, 2));
+    return stripped(JSON.stringify(results.map((c) => ({
+      name: c.name,
+      displayName: c.displayName,
+      version: c.version,
+      category: c.category,
+      description: verbose ? c.description : truncateText(c.description, 120),
+      score: c.score,
+      badges: c.badges,
+      ...verbose ? { matchReasons: c.matchReasons } : {}
+    })), null, 2));
   });
   server.registerTool("list_connectors", {
     title: "List Connectors",
-    description: "List connectors. category filters; compact=true returns names only.",
+    description: "List connectors with compact, paged defaults. Use verbose=true or compact=false for full metadata.",
     inputSchema: {
       category: exports_external2.string().optional(),
-      compact: exports_external2.boolean().optional()
+      compact: exports_external2.boolean().optional(),
+      limit: exports_external2.number().optional(),
+      cursor: exports_external2.string().optional(),
+      verbose: exports_external2.boolean().optional()
     }
-  }, async ({ category, compact }) => {
+  }, async ({ category, compact, limit, cursor, verbose }) => {
     let connectors18 = CONNECTORS;
     if (category) {
       const matched = CATEGORIES.find((c) => c.toLowerCase() === category.toLowerCase());
@@ -44670,23 +44809,42 @@ function registerDiscoveryTools(server, stripped) {
       }
       connectors18 = getConnectorsByCategory(matched);
     }
-    const data = compact ? connectors18.map((c) => c.name) : connectors18.map((c) => ({
+    const parsedCursor = parseCursor(cursor);
+    if (parsedCursor.error) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: parsedCursor.error }) }],
+        isError: true
+      };
+    }
+    const page = pageItems(connectors18, {
+      offset: parsedCursor.value ?? 0,
+      limit: normalizeLimit(limit, DEFAULT_MCP_LIMIT)
+    });
+    const data = compact === true ? page.items.map((c) => c.name) : verbose || compact === false ? page.items.map((c) => ({
       name: c.name,
       displayName: c.displayName,
       version: c.version,
       category: c.category,
-      description: c.description
-    }));
-    return stripped(JSON.stringify(data, null, 2));
+      description: c.description,
+      tags: c.tags
+    })) : page.items.map((c) => compactConnector(c, 120));
+    return stripped(JSON.stringify({
+      connectors: data,
+      total: connectors18.length,
+      count: data.length,
+      nextCursor: page.nextOffset === null ? null : String(page.nextOffset),
+      hint: page.nextOffset === null ? "Use verbose=true or compact=false for full connector metadata." : `Call again with cursor="${page.nextOffset}", or use verbose=true / compact=false for full connector metadata.`
+    }, null, 2));
   });
   server.registerTool("connector_docs", {
     title: "Connector Documentation",
-    description: "Get connector docs. essential=true returns auth+envVars only.",
+    description: "Get compact connector docs by default. Use verbose=true for full parsed docs or essential=true for auth+env only.",
     inputSchema: {
       name: exports_external2.string(),
-      essential: exports_external2.boolean().optional()
+      essential: exports_external2.boolean().optional(),
+      verbose: exports_external2.boolean().optional()
     }
-  }, async ({ name, essential }) => {
+  }, async ({ name, essential, verbose }) => {
     const meta = getConnector(name);
     if (!meta) {
       return {
@@ -44702,7 +44860,7 @@ function registerDiscoveryTools(server, stripped) {
         isError: true
       };
     }
-    const data = essential ? { name: meta.name, auth: docs.auth, envVars: docs.envVars } : {
+    const data = essential ? { name: meta.name, auth: docs.auth, envVars: docs.envVars } : verbose ? {
       name: meta.name,
       displayName: meta.displayName,
       version: meta.version,
@@ -44713,6 +44871,19 @@ function registerDiscoveryTools(server, stripped) {
       envVars: docs.envVars,
       cliCommands: docs.cliCommands,
       dataStorage: docs.dataStorage
+    } : {
+      name: meta.name,
+      displayName: meta.displayName,
+      version: meta.version,
+      category: meta.category,
+      description: truncateText(meta.description, 120),
+      overview: firstNonEmptyLines(docs.overview, 1, 140)[0] ?? "",
+      auth: firstNonEmptyLines(docs.auth, 4, 140),
+      envVars: docs.envVars.slice(0, 8),
+      envVarCount: docs.envVars.length,
+      cliCommands: firstNonEmptyLines(docs.cliCommands, 8, 140),
+      dataStorage: firstNonEmptyLines(docs.dataStorage, 2, 140),
+      hint: `Use connector_docs({ name: "${name}", verbose: true }) for full parsed docs, or raw CLI docs with connectors docs ${name} --raw.`
     };
     return {
       content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
@@ -45137,9 +45308,11 @@ function registerOperationsTools(server, stripped) {
     description: "Discover available API operations for a connector. Returns CLI commands the connector supports (e.g. messages, products, customers). Use this before run_connector_operation to know what's available.",
     inputSchema: {
       name: exports_external2.string().describe("Connector name (e.g. stripe, gmail, anthropic)"),
-      command: exports_external2.string().optional().describe("Get detailed help for a specific subcommand (e.g. products, messages)")
+      command: exports_external2.string().optional().describe("Get detailed help for a specific subcommand (e.g. products, messages)"),
+      verbose: exports_external2.boolean().optional().describe("Include full auth status and raw help text."),
+      limit: exports_external2.number().optional().describe("Limit operation rows in compact mode.")
     }
-  }, async ({ name, command }) => {
+  }, async ({ name, command, verbose, limit }) => {
     const meta = getConnector(name);
     if (!meta) {
       return {
@@ -45171,6 +45344,32 @@ function registerOperationsTools(server, stripped) {
     }
     const ops = await getConnectorOperations(name);
     const auth = getAuthStatus(name);
+    if (!verbose) {
+      const operationLimit = normalizeLimit(limit, 50);
+      const operations = ops.operations.slice(0, operationLimit).map((operation) => ({
+        name: operation.name,
+        aliases: operation.aliases,
+        usage: operation.usage,
+        summary: truncateText(operation.summary || "", 140),
+        source: operation.source
+      }));
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              connector: name,
+              displayName: meta.displayName,
+              auth: { type: auth.type, configured: auth.configured },
+              commands: ops.commands,
+              operations,
+              totalOperations: ops.operations.length,
+              hint: `Use list_connector_operations({ name: "${name}", verbose: true }) for full help text, or command="<subcommand>" for one command.`
+            }, null, 2)
+          }
+        ]
+      };
+    }
     return {
       content: [
         {
@@ -45194,9 +45393,11 @@ function registerOperationsTools(server, stripped) {
       name: exports_external2.string().describe("Connector name (e.g. stripe, gmail, anthropic)"),
       args: exports_external2.array(exports_external2.string()).describe("CLI arguments for the connector command (e.g. ['products', 'list', '--limit', '5'])"),
       format: exports_external2.enum(["json", "pretty"]).optional().describe("Output format (default: json for structured parsing)"),
-      timeout: exports_external2.number().optional().describe("Timeout in milliseconds (default: 30000)")
+      timeout: exports_external2.number().optional().describe("Timeout in milliseconds (default: 30000)"),
+      verbose: exports_external2.boolean().optional().describe("Return full stdout/stderr without output truncation."),
+      maxOutputChars: exports_external2.number().optional().describe("Maximum output characters when verbose is false (default: 6000).")
     }
-  }, async ({ name, args, format, timeout }) => {
+  }, async ({ name, args, format, timeout, verbose, maxOutputChars }) => {
     const meta = getConnector(name);
     if (!meta) {
       return {
@@ -45219,6 +45420,11 @@ function registerOperationsTools(server, stripped) {
 ${result.stderr}`;
     const looksLikeHelp = /Usage:|Commands:|Options:/i.test(combinedOutput);
     if (!result.success && !looksLikeHelp) {
+      const output = maybeTruncateOutput(result.stderr || result.stdout, {
+        enabled: !verbose,
+        maxChars: maxOutputChars ?? DEFAULT_OUTPUT_CHARS,
+        hint: "Set verbose=true or maxOutputChars higher for full error output."
+      });
       return {
         content: [
           {
@@ -45226,7 +45432,9 @@ ${result.stderr}`;
             text: JSON.stringify({
               connector: name,
               success: false,
-              error: result.stderr || result.stdout
+              error: output.text,
+              outputTruncated: output.truncated,
+              hint: verbose ? undefined : "MCP error output is compact by default. Set verbose=true or maxOutputChars for more output."
             }, null, 2)
           }
         ],
@@ -45240,7 +45448,11 @@ ${result.stderr}`;
           text: JSON.stringify({
             connector: name,
             success: true,
-            output: looksLikeHelp ? (result.stdout || result.stderr).trim() : result.stdout
+            output: maybeTruncateOutput(looksLikeHelp ? (result.stdout || result.stderr).trim() : result.stdout, {
+              enabled: !verbose,
+              maxChars: maxOutputChars ?? DEFAULT_OUTPUT_CHARS,
+              hint: "Set verbose=true or maxOutputChars higher for full output."
+            }).text
           }, null, 2)
         }
       ]
@@ -45257,11 +45469,14 @@ function registerSearchTools(server, stripped) {
     description: "Search for available operations across installed connectors.",
     inputSchema: {
       query: exports_external2.string(),
-      installedOnly: exports_external2.boolean().optional()
+      installedOnly: exports_external2.boolean().optional(),
+      limit: exports_external2.number().optional(),
+      verbose: exports_external2.boolean().optional()
     }
-  }, async ({ query, installedOnly }) => {
+  }, async ({ query, installedOnly, limit, verbose }) => {
     const installed = installedOnly ? getInstalledConnectors() : null;
     const results = [];
+    const resultLimit = normalizeLimit(limit, DEFAULT_MCP_LIMIT);
     const connectors18 = installed || getInstalledConnectors();
     for (const name of connectors18) {
       try {
@@ -45280,22 +45495,31 @@ function registerSearchTools(server, stripped) {
             results.push({
               connector: name,
               operation: operation.name,
-              description: operation.summary || ops.helpText || ""
+              description: verbose ? operation.summary || ops.helpText || "" : truncateText(operation.summary || ops.helpText || "", 160)
             });
+            if (results.length >= resultLimit)
+              break;
           }
         }
+        if (results.length >= resultLimit)
+          break;
       } catch {}
     }
-    return stripped(JSON.stringify(results, null, 2));
+    return stripped(JSON.stringify({
+      results,
+      count: results.length,
+      hint: "Use limit=<n> for more rows and verbose=true for longer descriptions."
+    }, null, 2));
   });
   server.registerTool("describe_tools", {
     title: "Describe Tools",
     description: "Get detailed documentation for a connector's operations.",
     inputSchema: {
       name: exports_external2.string(),
-      operation: exports_external2.string().optional()
+      operation: exports_external2.string().optional(),
+      verbose: exports_external2.boolean().optional()
     }
-  }, async ({ name, operation }) => {
+  }, async ({ name, operation, verbose }) => {
     const meta = getConnector(name);
     if (!meta) {
       return {
@@ -45311,7 +45535,23 @@ function registerSearchTools(server, stripped) {
       };
     }
     const ops = await getConnectorOperations(name);
-    return stripped(JSON.stringify({ connector: name, displayName: meta.displayName, ...ops }, null, 2));
+    if (verbose) {
+      return stripped(JSON.stringify({ connector: name, displayName: meta.displayName, ...ops }, null, 2));
+    }
+    return stripped(JSON.stringify({
+      connector: name,
+      displayName: meta.displayName,
+      commands: ops.commands,
+      operations: ops.operations.map((item) => ({
+        name: item.name,
+        aliases: item.aliases,
+        usage: item.usage,
+        summary: truncateText(item.summary || "", 140),
+        source: item.source
+      })),
+      totalOperations: ops.operations.length,
+      hint: `Use describe_tools({ name: "${name}", verbose: true }) for full help text.`
+    }, null, 2));
   });
 }
 // src/mcp/tools/ranking.ts
@@ -45358,60 +45598,179 @@ init_zod2();
 init_database();
 init_jobs();
 init_scheduler();
+var DEFAULT_EXECUTION_OUTPUT_CHARS = 2000;
+var MAX_EXECUTION_OUTPUT_CHARS = 50000;
+function normalizeOutputChars(value) {
+  return normalizeLimit(value, DEFAULT_EXECUTION_OUTPUT_CHARS, MAX_EXECUTION_OUTPUT_CHARS);
+}
+function compactExecutionText(text, options, label) {
+  return maybeTruncateOutput(text, {
+    enabled: !options.verbose,
+    maxChars: normalizeOutputChars(options.maxOutputChars),
+    hint: `Set verbose=true or maxOutputChars higher for full ${label} output.`
+  });
+}
+function compactJobExecutionResult(result, options = {}) {
+  const output = compactExecutionText(result.output, options, "job");
+  return {
+    ...result,
+    output: output.text,
+    outputTruncated: output.truncated,
+    hint: options.verbose ? undefined : "MCP job output is compact by default. Set verbose=true or maxOutputChars for more output."
+  };
+}
+function compactWorkflowExecutionResult(result, options = {}) {
+  let truncatedOutputs = 0;
+  const steps = result.steps.map((step) => {
+    const output = compactExecutionText(step.output, options, "workflow step");
+    if (output.truncated)
+      truncatedOutputs++;
+    return {
+      ...step,
+      output: output.text,
+      outputTruncated: output.truncated
+    };
+  });
+  const finalOutput = compactExecutionText(result.final_output, options, "workflow final");
+  if (finalOutput.truncated)
+    truncatedOutputs++;
+  return {
+    ...result,
+    steps,
+    final_output: finalOutput.text,
+    finalOutputTruncated: finalOutput.truncated,
+    truncatedOutputs,
+    hint: options.verbose ? undefined : "MCP workflow output is compact by default. Set verbose=true or maxOutputChars for more output."
+  };
+}
 function registerJobsTools(server, stripped) {
   server.registerTool("list_jobs", {
     title: "List Jobs",
-    description: "List scheduled connector jobs.",
-    inputSchema: {}
-  }, async () => {
+    description: "List scheduled connector jobs with compact, paged defaults.",
+    inputSchema: {
+      limit: exports_external2.number().optional(),
+      cursor: exports_external2.string().optional(),
+      verbose: exports_external2.boolean().optional()
+    }
+  }, async ({ limit, cursor, verbose }) => {
+    const parsedCursor = parseCursor(cursor);
+    if (parsedCursor.error) {
+      return { content: [{ type: "text", text: JSON.stringify({ error: parsedCursor.error }) }], isError: true };
+    }
     const db = getDatabase();
     const jobs = listJobs(db);
-    return stripped(JSON.stringify(jobs, null, 2));
+    const page = pageItems(jobs, {
+      offset: parsedCursor.value ?? 0,
+      limit: normalizeLimit(limit, DEFAULT_MCP_LIMIT)
+    });
+    const data = verbose ? page.items : page.items.map((job) => ({
+      name: job.name,
+      connector: job.connector,
+      command: `${job.command}${job.args.length ? ` ${job.args.join(" ")}` : ""}`,
+      cron: job.cron,
+      enabled: job.enabled,
+      strip: job.strip,
+      lastRunAt: job.last_run_at
+    }));
+    return stripped(JSON.stringify({
+      jobs: data,
+      total: jobs.length,
+      count: data.length,
+      nextCursor: page.nextOffset === null ? null : String(page.nextOffset),
+      hint: "Use verbose=true for full job records, get_latest_job_run for run output, or connectors jobs show <name>."
+    }, null, 2));
   });
   server.registerTool("get_latest_job_run", {
     title: "Get Latest Job Run",
-    description: "Get the most recent run output for a job.",
-    inputSchema: { name: exports_external2.string() }
-  }, async ({ name }) => {
+    description: "Get the most recent run output for a job. Output is truncated unless verbose=true.",
+    inputSchema: {
+      name: exports_external2.string(),
+      verbose: exports_external2.boolean().optional(),
+      maxOutputChars: exports_external2.number().optional()
+    }
+  }, async ({ name, verbose, maxOutputChars }) => {
     const db = getDatabase();
     const job = getJobByName(name, db);
     if (!job)
       return { content: [{ type: "text", text: JSON.stringify({ error: `Job "${name}" not found` }) }], isError: true };
     const run = getLatestRun(job.id, db);
-    return stripped(JSON.stringify(run ?? { message: "No runs yet" }, null, 2));
+    if (!run)
+      return stripped(JSON.stringify({ message: "No runs yet" }, null, 2));
+    const outputLimit = normalizeLimit(maxOutputChars, 2000, 50000);
+    return stripped(JSON.stringify({
+      ...run,
+      raw_output: run.raw_output && !verbose ? truncateText(run.raw_output, outputLimit) : run.raw_output,
+      stripped_output: run.stripped_output && !verbose ? truncateText(run.stripped_output, outputLimit) : run.stripped_output,
+      hint: verbose ? undefined : "Long run output is truncated in MCP. Use verbose=true or maxOutputChars for more output."
+    }, null, 2));
   });
   server.registerTool("run_job", {
     title: "Run Job",
     description: "Manually trigger a scheduled job.",
-    inputSchema: { name: exports_external2.string() }
-  }, async ({ name }) => {
+    inputSchema: {
+      name: exports_external2.string(),
+      verbose: exports_external2.boolean().optional().describe("Return full job output without truncation."),
+      maxOutputChars: exports_external2.number().optional().describe("Maximum output characters when verbose is false (default: 2000).")
+    }
+  }, async ({ name, verbose, maxOutputChars }) => {
     const db = getDatabase();
     const job = getJobByName(name, db);
     if (!job)
       return { content: [{ type: "text", text: JSON.stringify({ error: `Job "${name}" not found` }) }], isError: true };
     const result = await triggerJob(job, db);
-    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    return stripped(JSON.stringify(compactJobExecutionResult(result, { verbose, maxOutputChars }), null, 2));
   });
   server.registerTool("list_workflows", {
     title: "List Workflows",
-    description: "List connector workflows.",
-    inputSchema: {}
-  }, async () => {
+    description: "List connector workflows with compact, paged defaults.",
+    inputSchema: {
+      limit: exports_external2.number().optional(),
+      cursor: exports_external2.string().optional(),
+      verbose: exports_external2.boolean().optional()
+    }
+  }, async ({ limit, cursor, verbose }) => {
+    const parsedCursor = parseCursor(cursor);
+    if (parsedCursor.error) {
+      return { content: [{ type: "text", text: JSON.stringify({ error: parsedCursor.error }) }], isError: true };
+    }
     const db = getDatabase();
     const workflows = listWorkflows(db);
-    return stripped(JSON.stringify(workflows, null, 2));
+    const page = pageItems(workflows, {
+      offset: parsedCursor.value ?? 0,
+      limit: normalizeLimit(limit, DEFAULT_MCP_LIMIT)
+    });
+    const data = verbose ? page.items : page.items.map((workflow) => ({
+      name: workflow.name,
+      enabled: workflow.enabled,
+      stepCount: workflow.steps.length,
+      steps: workflow.steps.slice(0, 5).map((step) => ({
+        connector: step.connector,
+        command: step.command
+      }))
+    }));
+    return stripped(JSON.stringify({
+      workflows: data,
+      total: workflows.length,
+      count: data.length,
+      nextCursor: page.nextOffset === null ? null : String(page.nextOffset),
+      hint: "Use verbose=true for full workflow records, or connectors workflows show <name>."
+    }, null, 2));
   });
   server.registerTool("run_workflow", {
     title: "Run Workflow",
     description: "Execute a connector workflow pipeline.",
-    inputSchema: { name: exports_external2.string() }
-  }, async ({ name }) => {
+    inputSchema: {
+      name: exports_external2.string(),
+      verbose: exports_external2.boolean().optional().describe("Return full workflow step output without truncation."),
+      maxOutputChars: exports_external2.number().optional().describe("Maximum output characters per output field when verbose is false (default: 2000).")
+    }
+  }, async ({ name, verbose, maxOutputChars }) => {
     const db = getDatabase();
     const wf = getWorkflowByName(name, db);
     if (!wf)
       return { content: [{ type: "text", text: JSON.stringify({ error: `Workflow "${name}" not found` }) }], isError: true };
     const result = await runWorkflow(wf);
-    return stripped(JSON.stringify(result, null, 2));
+    return stripped(JSON.stringify(compactWorkflowExecutionResult(result, { verbose, maxOutputChars }), null, 2));
   });
 }
 // src/mcp/tools/llm.ts
@@ -45462,11 +45821,38 @@ function registerAgentTools(server, stripped) {
   });
   server.registerTool("list_agents", {
     title: "List Agents",
-    description: "List all registered agents.",
-    inputSchema: {}
-  }, async () => {
+    description: "List registered agents with compact, paged defaults.",
+    inputSchema: {
+      limit: exports_external2.number().optional(),
+      cursor: exports_external2.string().optional(),
+      verbose: exports_external2.boolean().optional()
+    }
+  }, async ({ limit, cursor, verbose }) => {
+    const parsedCursor = parseCursor(cursor);
+    if (parsedCursor.error) {
+      return { content: [{ type: "text", text: JSON.stringify({ error: parsedCursor.error }) }], isError: true };
+    }
     const agents = listAgents();
-    return { content: [{ type: "text", text: JSON.stringify(agents, null, 2) }] };
+    const page = pageItems(agents, {
+      offset: parsedCursor.value ?? 0,
+      limit: normalizeLimit(limit, DEFAULT_MCP_LIMIT)
+    });
+    const data = verbose ? page.items : page.items.map((agent) => ({
+      id: agent.id,
+      name: agent.name,
+      role: agent.role,
+      lastSeenAt: agent.last_seen_at,
+      projectId: agent.project_id
+    }));
+    return {
+      content: [{ type: "text", text: JSON.stringify({
+        agents: data,
+        total: agents.length,
+        count: data.length,
+        nextCursor: page.nextOffset === null ? null : String(page.nextOffset),
+        hint: "Use verbose=true for full agent records."
+      }, null, 2) }]
+    };
   });
   server.registerTool("heartbeat", {
     title: "Heartbeat",