lynkr 9.9.0 → 9.10.0

package/src/tools/tests.js

@@ -1,132 +0,0 @@
-const { registerTool } = require(".");
-const { runWorkspaceTests, listTestRuns, getTestSummary } = require("../tests");
-
-function formatJson(payload) {
-  return JSON.stringify(payload, null, 2);
-}
-
-function parseBoolean(value) {
-  if (typeof value === "boolean") return value;
-  if (typeof value === "string") {
-    const normalised = value.trim().toLowerCase();
-    if (normalised === "true" || normalised === "1" || normalised === "yes") return true;
-    if (normalised === "false" || normalised === "0" || normalised === "no") return false;
-  }
-  return undefined;
-}
-
-function parseNumber(value, fallback) {
-  if (value === undefined || value === null) return fallback;
-  const parsed = Number(value);
-  return Number.isFinite(parsed) ? parsed : fallback;
-}
-
-function parseArgs(args) {
-  if (!args) return [];
-  if (Array.isArray(args)) return args.map(String);
-  if (typeof args === "string" && args.trim().length > 0) {
-    return args
-      .split(/\s+/)
-      .map((item) => item.trim())
-      .filter(Boolean);
-  }
-  return [];
-}
-
-function registerTestRunTool() {
-  registerTool(
-    "workspace_test_run",
-    async ({ args = {} }) => {
-      const profile = args.profile ?? args.name ?? null;
-      const collectCoverage = parseBoolean(args.collect_coverage ?? args.collectCoverage);
-      const sandbox = typeof args.sandbox === "string" ? args.sandbox : undefined;
-      const sessionId = args.session_id ?? args.sessionId ?? null;
-
-      const result = await runWorkspaceTests({
-        profileName: profile,
-        args: parseArgs(args.args ?? args.extra_args),
-        cwd: typeof args.cwd === "string" ? args.cwd : undefined,
-        env: typeof args.env === "object" && args.env !== null ? args.env : undefined,
-        timeoutMs: parseNumber(args.timeout_ms ?? args.timeout, undefined),
-        sandbox,
-        sessionId,
-        collectCoverage: collectCoverage !== undefined ? collectCoverage : true,
-      });
-
-      return {
-        ok: true,
-        status: 200,
-        content: formatJson({
-          run: result.run,
-          coverage: result.coverage,
-        }),
-        metadata: {
-          status: result.run.status,
-          profile: result.run.profile,
-          durationMs: result.run.durationMs,
-        },
-      };
-    },
-    { category: "tests" },
-  );
-}
-
-function registerTestHistoryTool() {
-  registerTool(
-    "workspace_test_history",
-    async ({ args = {} }) => {
-      const includeLogs = parseBoolean(args.include_logs ?? args.includeLogs);
-      const limit = parseNumber(args.limit, 5);
-      const runs = listTestRuns({
-        limit,
-        includeLogs: includeLogs === true,
-      });
-      return {
-        ok: true,
-        status: 200,
-        content: formatJson({
-          runs,
-          count: runs.length,
-        }),
-        metadata: {
-          count: runs.length,
-        },
-      };
-    },
-    { category: "tests" },
-  );
-}
-
-function registerTestSummaryTool() {
-  registerTool(
-    "workspace_test_summary",
-    async ({ args = {} }) => {
-      const includeRecent = parseBoolean(args.include_recent ?? args.includeRecent);
-      const recentLimit = parseNumber(args.recent_limit ?? args.recentLimit, 5);
-      const summary = getTestSummary({
-        includeRecent,
-        recentLimit,
-      });
-      return {
-        ok: true,
-        status: 200,
-        content: formatJson(summary),
-        metadata: {
-          totalRuns: summary.totalRuns,
-          passRate: summary.passRate,
-        },
-      };
-    },
-    { category: "tests" },
-  );
-}
-
-function registerTestTools() {
-  registerTestRunTool();
-  registerTestHistoryTool();
-  registerTestSummaryTool();
-}
-
-module.exports = {
-  registerTestTools,
-};

package/src/tools/tinyfish.js

@@ -1,358 +0,0 @@
-const { URL } = require("url");
-const { Agent } = require("undici");
-const config = require("../config");
-const logger = require("../logger");
-const { registerTool } = require(".");
-
-/**
- * Dedicated HTTP agent for TinyFish SSE streams.
- * The default webAgent in web-client.js has a 30s bodyTimeout which is too
- * short for browser-automation tasks that can take up to 120s.
- */
-const sseAgent = new Agent({
-  connections: 10,
-  pipelining: 1,
-  keepAliveTimeout: 60000,
-  connectTimeout: 15000,
-  bodyTimeout: 0, // no body timeout — we manage timeout via AbortController
-  headersTimeout: 15000,
-  maxRedirections: 3,
-  strictContentLength: false,
-});
-
-// ---------------------------------------------------------------------------
-// Argument normalisers
-// ---------------------------------------------------------------------------
-
-function normalizeUrl(args) {
-  const raw = args.url ?? args.uri ?? args.href ?? args.target_url;
-  if (typeof raw !== "string" || raw.trim().length === 0) {
-    throw new Error("web_agent requires a non-empty url string.");
-  }
-  // Validate URL
-  try {
-    new URL(raw.trim());
-  } catch {
-    throw new Error(`web_agent received an invalid URL: ${raw}`);
-  }
-  return raw.trim();
-}
-
-function normalizeGoal(args) {
-  const goal = args.goal ?? args.task ?? args.prompt ?? args.instruction;
-  if (typeof goal !== "string" || goal.trim().length === 0) {
-    throw new Error("web_agent requires a non-empty goal string.");
-  }
-  return goal.trim();
-}
-
-function resolveBrowserProfile(args) {
-  const profile = args.browser_profile ?? args.browserProfile ?? config.tinyfish.browserProfile;
-  if (profile === "stealth") return "stealth";
-  return "lite";
-}
-
-// ---------------------------------------------------------------------------
-// SSE stream consumer
-// ---------------------------------------------------------------------------
-
-async function consumeSSEStream(response, timeoutMs) {
-  const reader = response.body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  const startTime = Date.now();
-
-  try {
-    while (true) {
-      if (Date.now() - startTime > timeoutMs) {
-        const err = new Error(`TinyFish SSE stream timed out after ${timeoutMs}ms`);
-        err.code = "ETIMEDOUT";
-        err.status = 504;
-        throw err;
-      }
-
-      const { done, value } = await reader.read();
-      if (done) break;
-
-      buffer += decoder.decode(value, { stream: true });
-
-      // SSE events are separated by double newlines
-      const parts = buffer.split("\n\n");
-      // Keep the last (possibly incomplete) chunk in the buffer
-      buffer = parts.pop() || "";
-
-      for (const part of parts) {
-        // Extract the data: line(s)
-        const lines = part.split("\n");
-        let dataStr = "";
-        for (const line of lines) {
-          if (line.startsWith("data: ")) {
-            dataStr += line.slice(6);
-          } else if (line.startsWith("data:")) {
-            dataStr += line.slice(5);
-          }
-        }
-
-        if (!dataStr) continue;
-
-        let event;
-        try {
-          event = JSON.parse(dataStr);
-        } catch {
-          // Not valid JSON — skip this SSE frame
-          logger.debug({ raw: dataStr.slice(0, 200) }, "TinyFish: non-JSON SSE frame, skipping");
-          continue;
-        }
-
-        logger.debug(
-          { type: event.type, status: event.status },
-          "TinyFish SSE event"
-        );
-
-        if (event.type === "COMPLETE" || event.type === "complete") {
-          const status = (event.status ?? "").toUpperCase();
-          if (status === "COMPLETED" || status === "SUCCESS") {
-            return event.resultJson ?? event.result ?? event.data ?? event;
-          }
-          // Task failed
-          const errMsg = event.error ?? event.message ?? "TinyFish task failed";
-          const err = new Error(typeof errMsg === "string" ? errMsg : JSON.stringify(errMsg));
-          err.code = "TINYFISH_TASK_FAILED";
-          err.status = 502;
-          throw err;
-        }
-      }
-    }
-
-    // Stream ended without a COMPLETE event
-    const err = new Error("TinyFish SSE stream ended without a COMPLETE event");
-    err.code = "TINYFISH_INCOMPLETE";
-    err.status = 502;
-    throw err;
-  } finally {
-    reader.releaseLock();
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Core API call
-// ---------------------------------------------------------------------------
-
-async function callTinyFishAPI({ url, goal, browserProfile, proxyConfig, timeoutMs }) {
-  const endpoint = config.tinyfish.endpoint;
-  const apiKey = config.tinyfish.apiKey;
-
-  if (!apiKey) {
-    return {
-      ok: false,
-      status: 503,
-      content: JSON.stringify({
-        error: "tinyfish_not_configured",
-        message:
-          "TinyFish API key is not configured. Set TINYFISH_API_KEY in your .env file. Get a key from https://tinyfish.ai",
-      }, null, 2),
-    };
-  }
-
-  const body = {
-    url,
-    goal,
-    browserProfile,
-  };
-
-  if (proxyConfig) {
-    body.proxy = proxyConfig;
-  }
-
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), timeoutMs);
-
-  try {
-    const response = await fetch(endpoint, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "X-API-Key": apiKey,
-        Accept: "text/event-stream",
-      },
-      body: JSON.stringify(body),
-      signal: controller.signal,
-      dispatcher: sseAgent,
-    });
-
-    // Handle non-2xx responses before attempting SSE parse
-    if (!response.ok) {
-      const text = await response.text().catch(() => "");
-      const shouldRetry = response.status === 429 || response.status >= 500;
-
-      if (shouldRetry) {
-        // Retry once with 2s backoff
-        logger.warn(
-          { status: response.status, body: text.slice(0, 200) },
-          "TinyFish API error, retrying once"
-        );
-        await new Promise((r) => setTimeout(r, 2000));
-
-        const retryController = new AbortController();
-        const retryTimeout = setTimeout(() => retryController.abort(), timeoutMs);
-        try {
-          const retryResponse = await fetch(endpoint, {
-            method: "POST",
-            headers: {
-              "Content-Type": "application/json",
-              "X-API-Key": apiKey,
-              Accept: "text/event-stream",
-            },
-            body: JSON.stringify(body),
-            signal: retryController.signal,
-            dispatcher: sseAgent,
-          });
-
-          if (!retryResponse.ok) {
-            const retryText = await retryResponse.text().catch(() => "");
-            const err = new Error(
-              `TinyFish API error (${retryResponse.status}): ${retryResponse.statusText}`
-            );
-            err.status = retryResponse.status;
-            err.body = retryText;
-            throw err;
-          }
-
-          const result = await consumeSSEStream(retryResponse, timeoutMs);
-          return {
-            ok: true,
-            status: 200,
-            result,
-          };
-        } finally {
-          clearTimeout(retryTimeout);
-        }
-      }
-
-      const err = new Error(
-        `TinyFish API error (${response.status}): ${response.statusText}`
-      );
-      err.status = response.status;
-      err.body = text;
-      throw err;
-    }
-
-    const result = await consumeSSEStream(response, timeoutMs);
-    return {
-      ok: true,
-      status: 200,
-      result,
-    };
-  } catch (error) {
-    if (error.name === "AbortError") {
-      const err = new Error(`TinyFish request timed out after ${timeoutMs}ms`);
-      err.code = "ETIMEDOUT";
-      err.status = 504;
-      throw err;
-    }
-    throw error;
-  } finally {
-    clearTimeout(timeout);
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Tool registration
-// ---------------------------------------------------------------------------
-
-function registerTinyFishTool() {
-  registerTool(
-    "web_agent",
-    async ({ args = {} }) => {
-      const url = normalizeUrl(args);
-      const goal = normalizeGoal(args);
-      const browserProfile = resolveBrowserProfile(args);
-      const timeoutMs = config.tinyfish.timeoutMs;
-
-      // Build proxy config if enabled
-      let proxyConfig = null;
-      if (config.tinyfish.proxyEnabled) {
-        proxyConfig = {
-          enabled: true,
-          country: config.tinyfish.proxyCountry,
-        };
-      }
-
-      try {
-        const response = await callTinyFishAPI({
-          url,
-          goal,
-          browserProfile,
-          proxyConfig,
-          timeoutMs,
-        });
-
-        // Guard clause: not configured
-        if (!response.ok && response.status === 503) {
-          return response;
-        }
-
-        const resultStr =
-          typeof response.result === "string"
-            ? response.result
-            : JSON.stringify(response.result, null, 2);
-
-        logger.debug(
-          {
-            url,
-            goal: goal.slice(0, 100),
-            browserProfile,
-            resultLength: resultStr.length,
-          },
-          "TinyFish web_agent completed"
-        );
-
-        return {
-          ok: true,
-          status: 200,
-          content: resultStr,
-          metadata: {
-            url,
-            goal,
-            browserProfile,
-            resultLength: resultStr.length,
-          },
-        };
-      } catch (err) {
-        logger.error(
-          { err, url, goal: goal.slice(0, 100) },
-          "web_agent request failed"
-        );
-        return {
-          ok: false,
-          status: err.status ?? 500,
-          content: JSON.stringify(
-            {
-              error: err.code ?? "web_agent_failed",
-              message: err.message,
-              url,
-              ...(err.status ? { http_status: err.status } : {}),
-            },
-            null,
-            2
-          ),
-          metadata: {
-            url,
-            goal,
-            error_code: err.code,
-            ...(err.status ? { http_status: err.status } : {}),
-          },
-        };
-      }
-    },
-    { category: "tinyfish" }
-  );
-}
-
-function registerTinyFishTools() {
-  registerTinyFishTool();
-}
-
-module.exports = {
-  registerTinyFishTools,
-};

package/src/tools/truncate.js

@@ -1,106 +0,0 @@
-const logger = require("../logger");
-const config = require("../config");
-
-const TRUNCATION_LIMITS = {
-  Read: { maxChars: 8000, strategy: 'middle' },
-  Bash: { maxChars: 30000, strategy: 'tail' },
-  Grep: { maxChars: 12000, strategy: 'head' },
-  Glob: { maxChars: 8000, strategy: 'head' },
-  WebFetch: { maxChars: 16000, strategy: 'head' },
-  WebSearch: { maxChars: 12000, strategy: 'head' },
-  WebAgent: { maxChars: 16000, strategy: 'head' },
-  LSP: { maxChars: 8000, strategy: 'head' },
-  Edit: { maxChars: 8000, strategy: 'middle' },
-  Write: { maxChars: 8000, strategy: 'middle' },
-  Task: { maxChars: 20000, strategy: 'tail' },
-  AgentTask: { maxChars: 20000, strategy: 'tail' },
-};
-
-/**
- * Apply truncation strategy to text
- */
-function applyTruncationStrategy(text, maxChars, strategy) {
-  if (text.length <= maxChars) {
-    return text;
-  }
-
-  switch (strategy) {
-    case 'head':
-      // Keep beginning
-      return text.slice(0, maxChars);
-
-    case 'tail':
-      // Keep end
-      return text.slice(-maxChars);
-
-    case 'middle': {
-      // Keep start and end, remove middle
-      const keepSize = Math.floor(maxChars / 2);
-      const start = text.slice(0, keepSize);
-      const end = text.slice(-keepSize);
-      const removed = text.length - (keepSize * 2);
-      return `${start}\n\n... [${removed} characters truncated for token efficiency] ...\n\n${end}`;
-    }
-
-    default:
-      return text.slice(0, maxChars);
-  }
-}
-
-/**
- * Truncate tool output based on tool type
- */
-function truncateToolOutput(toolName, output) {
-  // Skip if truncation disabled
-  if (config.toolTruncation?.enabled === false) {
-    return output;
-  }
-
-  if (!output || typeof output !== 'string') {
-    return output;
-  }
-
-  const limit = TRUNCATION_LIMITS[toolName];
-  if (!limit) {
-    // No truncation for unknown tools
-    return output;
-  }
-
-  if (output.length <= limit.maxChars) {
-    return output;
-  }
-
-  const truncated = applyTruncationStrategy(output, limit.maxChars, limit.strategy);
-  const removed = output.length - truncated.length;
-
-  logger.debug({
-    tool: toolName,
-    originalLength: output.length,
-    truncatedLength: truncated.length,
-    removed,
-    strategy: limit.strategy
-  }, 'Truncated tool output for token efficiency');
-
-  return truncated;
-}
-
-/**
- * Get truncation limit for a specific tool
- */
-function getTruncationLimit(toolName) {
-  return TRUNCATION_LIMITS[toolName] || null;
-}
-
-/**
- * Update truncation limit for a tool (useful for testing)
- */
-function setTruncationLimit(toolName, maxChars, strategy = 'head') {
-  TRUNCATION_LIMITS[toolName] = { maxChars, strategy };
-}
-
-module.exports = {
-  truncateToolOutput,
-  getTruncationLimit,
-  setTruncationLimit,
-  TRUNCATION_LIMITS
-};

package/src/tools/web-client.js

@@ -1,71 +0,0 @@
-const { Agent, fetch: undiciFetch, setGlobalDispatcher } = require("undici");
-const logger = require("../logger");
-
-/**
- * Create an optimized HTTP agent for web search and fetch operations
- * with connection pooling and keep-alive enabled
- */
-function createWebAgent() {
-  const agent = new Agent({
-    // Connection pooling settings
-    connections: 50, // Max concurrent connections per origin
-    pipelining: 10, // Max pipelined requests per connection
-
-    // Keep-alive settings
-    keepAliveTimeout: 60000, // Keep connections alive for 60s
-    keepAliveMaxTimeout: 600000, // Maximum keep-alive time (10 minutes)
-
-    // Connection timeouts
-    connectTimeout: 10000, // 10s to establish connection
-    bodyTimeout: 30000, // 30s to receive response body
-    headersTimeout: 10000, // 10s to receive headers
-
-    // Connection reuse
-    maxRedirections: 5,
-
-    // Performance optimizations
-    strictContentLength: false, // Don't require Content-Length header
-  });
-
-  logger.info({
-    connections: 50,
-    keepAliveTimeout: 60000,
-    pipelining: 10,
-  }, "Web HTTP agent initialized with connection pooling");
-
-  return agent;
-}
-
-/**
- * Global web agent instance - reused across all web search/fetch calls
- */
-const webAgent = createWebAgent();
-
-/**
- * Fetch with the optimized agent (uses undici.fetch for dispatcher support)
- */
-async function fetchWithAgent(url, options = {}) {
-  return undiciFetch(url, {
-    ...options,
-    dispatcher: webAgent,
-  });
-}
-
-/**
- * Get connection pool statistics
- */
-function getAgentStats() {
-  // Undici doesn't expose detailed stats easily, but we can log connection info
-  return {
-    agent: "undici",
-    keepAlive: true,
-    maxConnections: 50,
-    pipelining: 10,
-  };
-}
-
-module.exports = {
-  webAgent,
-  fetchWithAgent,
-  getAgentStats,
-};