lynkr 8.0.0 → 8.0.1

package/README.md

@@ -50,7 +50,7 @@ Lynkr is a **self-hosted proxy server** that unlocks Claude Code CLI , Cursor ID
 npm install -g pino-pretty 
 npm install -g lynkr
 
-lynk start
+lynkr start
 ```
 
 **Option 2: Git Clone**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lynkr",
-  "version": "8.0.0",
+  "version": "8.0.1",
   "description": "Self-hosted Claude Code & Cursor proxy with Databricks,AWS BedRock,Azure  adapters, openrouter, Ollama,llamacpp,LM Studio, workspace tooling, and MCP integration.",
   "main": "index.js",
   "bin": {

package/src/api/openai-router.js

@@ -126,6 +126,13 @@ const CLIENT_TOOL_MAPPINGS = {
       mapArgs: (a) => ({
         query: a.query || ""
       })
+    },
+    "WebAgent": {
+      name: "web_agent",
+      mapArgs: (a) => ({
+        url: a.url || "",
+        goal: a.goal || ""
+      })
     }
   },
 
@@ -181,6 +188,13 @@ const CLIENT_TOOL_MAPPINGS = {
         path: a.path || a.directory || ".",
         recursive: false
       })
+    },
+    "WebAgent": {
+      name: "web_agent",
+      mapArgs: (a) => ({
+        url: a.url || "",
+        goal: a.goal || ""
+      })
     }
   },
 
@@ -237,6 +251,13 @@ const CLIENT_TOOL_MAPPINGS = {
         path: a.path || a.directory || ".",
         recursive: false
       })
+    },
+    "WebAgent": {
+      name: "web_agent",
+      mapArgs: (a) => ({
+        url: a.url || "",
+        goal: a.goal || ""
+      })
     }
   },
 
@@ -287,6 +308,13 @@ const CLIENT_TOOL_MAPPINGS = {
       mapArgs: (a) => ({
         filepath: a.path || a.directory || "."
       })
+    },
+    "WebAgent": {
+      name: "web_agent",
+      mapArgs: (a) => ({
+        url: a.url || "",
+        goal: a.goal || ""
+      })
     }
   }
 };
@@ -406,8 +434,10 @@ router.post("/chat/completions", async (req, res) => {
     //      that have a mapping in CLIENT_TOOL_MAPPINGS — this ensures clients like
     //      Codex don't see tools they can't handle (Task, WebFetch, NotebookEdit)
     //      while Claude Code (unknown client) gets the full IDE_SAFE_TOOLS set.
+    // Skip injection if client explicitly opted out (tool_choice: "none" or empty tools array).
     const clientType = detectClient(req.headers);
-    if (!anthropicRequest.tools || anthropicRequest.tools.length === 0) {
+    const clientExplicitlyDisabledTools = req.body.tool_choice === "none" || Array.isArray(req.body.tools);
+    if (!clientExplicitlyDisabledTools && (!anthropicRequest.tools || anthropicRequest.tools.length === 0)) {
       const clientMappings = CLIENT_TOOL_MAPPINGS[clientType];
       const clientTools = clientMappings
         ? IDE_SAFE_TOOLS.filter(t => clientMappings[t.name])
@@ -1450,8 +1480,10 @@ router.post("/responses", async (req, res) => {
     }, "After Chat→Anthropic conversion");
 
     // Inject tools if client didn't send any (same two-layer filtering as chat/completions).
+    // Skip injection if client explicitly opted out (tool_choice: "none" or empty tools array).
     const clientType = detectClient(req.headers);
-    if (!anthropicRequest.tools || anthropicRequest.tools.length === 0) {
+    const clientExplicitlyDisabledTools = req.body.tool_choice === "none" || Array.isArray(req.body.tools);
+    if (!clientExplicitlyDisabledTools && (!anthropicRequest.tools || anthropicRequest.tools.length === 0)) {
       const clientMappings = CLIENT_TOOL_MAPPINGS[clientType];
       const clientTools = clientMappings
         ? IDE_SAFE_TOOLS.filter(t => clientMappings[t.name])

package/src/clients/standard-tools.js

@@ -380,6 +380,29 @@ EXAMPLE: User says "explore this project" → Call Task with subagent_type="Expl
       required: ["url", "prompt"]
     }
   },
+  {
+    name: "WebAgent",
+    description: "Launches a browser agent to navigate a website and accomplish a goal. Use when you need to interact with dynamic web content (click buttons, fill forms, extract data from JS-rendered pages) beyond what a simple HTTP fetch can do. Returns structured JSON. Takes 10-60 seconds.",
+    input_schema: {
+      type: "object",
+      properties: {
+        url: {
+          type: "string",
+          description: "Target URL to navigate to"
+        },
+        goal: {
+          type: "string",
+          description: "What to accomplish on the page. Be specific about what data to extract or actions to take."
+        },
+        browser_profile: {
+          type: "string",
+          enum: ["lite", "stealth"],
+          description: "lite (default, faster) or stealth (for bot-protected sites)"
+        }
+      },
+      required: ["url", "goal"]
+    }
+  },
   {
     name: "NotebookEdit",
     description: "Completely replaces the contents of a specific cell in a Jupyter notebook (.ipynb file). Use for editing interactive documents that combine code, text, and visualizations.",

package/src/config/index.js

@@ -397,6 +397,14 @@ const webFetchBodyPreviewMax = Number.parseInt(process.env.WEB_FETCH_BODY_PREVIE
 const webSearchRetryEnabled = process.env.WEB_SEARCH_RETRY_ENABLED !== "false"; // default true
 const webSearchMaxRetries = Number.parseInt(process.env.WEB_SEARCH_MAX_RETRIES ?? "2", 10);
 
+// TinyFish AI Browser Automation configuration
+const tinyfishApiKey = process.env.TINYFISH_API_KEY?.trim() || null;
+const tinyfishEndpoint = process.env.TINYFISH_ENDPOINT?.trim() || "https://agent.tinyfish.ai/v1/automation/run-sse";
+const tinyfishBrowserProfile = process.env.TINYFISH_BROWSER_PROFILE?.trim() || "lite";
+const tinyfishTimeoutMs = parseInt(process.env.TINYFISH_TIMEOUT_MS ?? "120000", 10);
+const tinyfishProxyEnabled = process.env.TINYFISH_PROXY_ENABLED === "true";
+const tinyfishProxyCountry = process.env.TINYFISH_PROXY_COUNTRY?.trim() || "US";
+
 const policyMaxSteps = Number.parseInt(process.env.POLICY_MAX_STEPS ?? "8", 10);
 const policyMaxToolCalls = Number.parseInt(process.env.POLICY_MAX_TOOL_CALLS ?? "12", 10);
 const policyToolLoopThreshold = Number.parseInt(process.env.POLICY_TOOL_LOOP_THRESHOLD ?? "10", 10);
@@ -660,6 +668,14 @@ var config = {
     retryEnabled: webSearchRetryEnabled,
     maxRetries: Number.isNaN(webSearchMaxRetries) ? 2 : webSearchMaxRetries,
   },
+  tinyfish: {
+    apiKey: tinyfishApiKey,
+    endpoint: tinyfishEndpoint,
+    browserProfile: tinyfishBrowserProfile,
+    timeoutMs: Number.isNaN(tinyfishTimeoutMs) ? 120000 : tinyfishTimeoutMs,
+    proxyEnabled: tinyfishProxyEnabled,
+    proxyCountry: tinyfishProxyCountry,
+  },
   policy: {
     maxStepsPerTurn: Number.isNaN(policyMaxSteps) ? 8 : policyMaxSteps,
     maxToolCallsPerTurn: Number.isNaN(policyMaxToolCalls) ? 12 : policyMaxToolCalls,
@@ -938,6 +954,10 @@ function reloadConfig() {
   config.modelProvider.fallbackProvider = (process.env.FALLBACK_PROVIDER ?? "databricks").toLowerCase();
   config.modelProvider.suggestionModeModel = (process.env.SUGGESTION_MODE_MODEL ?? "default").trim();
 
+  // TinyFish config reload
+  config.tinyfish.apiKey = process.env.TINYFISH_API_KEY?.trim() || null;
+  config.tinyfish.browserProfile = process.env.TINYFISH_BROWSER_PROFILE?.trim() || "lite";
+
   config.toon.enabled = process.env.TOON_ENABLED === "true";
   const newToonMinBytes = Number.parseInt(process.env.TOON_MIN_BYTES ?? "4096", 10);
   config.toon.minBytes = Number.isNaN(newToonMinBytes) ? 4096 : newToonMinBytes;

package/src/orchestrator/index.js

@@ -1358,7 +1358,7 @@ function sanitizePayload(payload) {
     clean.tools = selectedTools.length > 0 ? selectedTools : undefined;
   }
 
-  clean.stream = payload.stream ?? false;
+  clean.stream = payload?.stream ?? false;
 
   if (
     config.modelProvider?.type === "azure-anthropic" &&
@@ -2248,7 +2248,7 @@ IMPORTANT TOOL USAGE RULES:
       const serverSideToolCalls = [];
       const clientSideToolCalls = [];
 
-      const SERVER_SIDE_TOOLS = new Set(["task", "web_search", "web_fetch", "websearch", "webfetch"]);
+      const SERVER_SIDE_TOOLS = new Set(["task", "web_search", "web_fetch", "websearch", "webfetch", "web_agent"]);
 
       for (const call of toolCalls) {
         const toolName = (call.function?.name ?? call.name ?? "").toLowerCase();

package/src/server.js

@@ -78,18 +78,8 @@ function createApp() {
   // Metrics collection
   app.use(metricsMiddleware);
 
-  // Enable compression for all responses (gzip/deflate)
-  app.use(compression({
-    level: 6, // Balanced compression level
-    threshold: 1024, // Only compress responses > 1KB
-    filter: (req, res) => {
-      // Don't compress event streams
-      if (res.getHeader('Content-Type') === 'text/event-stream') {
-        return false;
-      }
-      return compression.filter(req, res);
-    }
-  }));
+  // Note: If using a tunnel (ngrok, Cloudflare Tunnel) and seeing BrotliDecompressionError,
+  // start ngrok with: ngrok http 8081 --request-header-remove "Accept-Encoding"
 
   app.use(express.json({ limit: config.server.jsonLimit }));
   app.use(sessionMiddleware);

package/src/tools/index.js

@@ -30,6 +30,10 @@ const TOOL_ALIASES = {
   WebSearch: "web_search",
   web_fetch: "web_fetch",
   webfetch: "web_fetch",
+  web_agent: "web_agent",
+  webagent: "web_agent",
+  WebAgent: "web_agent",
+  tinyfish: "web_agent",
   task: "fs_write",
   write: "fs_write",
   filewrite: "fs_write",

package/src/tools/lazy-loader.js

@@ -57,6 +57,11 @@ const TOOL_CATEGORIES = {
     loader: () => require('./tasks').registerTaskTools,
     priority: 2,
   },
+  tinyfish: {
+    keywords: ['tinyfish', 'web_agent', 'automate', 'scrape', 'extract', 'crawl', 'browser'],
+    loader: () => require('./tinyfish').registerTinyFishTools,
+    priority: 2,
+  },
   tests: {
     keywords: ['test', 'jest', 'mocha', 'pytest', 'unittest', 'spec', 'coverage', 'assert'],
     loader: () => require('./tests').registerTestTools,
@@ -277,6 +282,8 @@ function loadCategoryForTool(toolName) {
     'workspace_mcp_servers': 'mcp',
 
     // Agent task
+    // TinyFish (web agent)
+    'web_agent': 'tinyfish',
     'agent_task': 'agentTask',
   };
 

package/src/tools/tinyfish.js

@@ -0,0 +1,358 @@
+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

@@ -8,6 +8,7 @@ const TRUNCATION_LIMITS = {
   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' },

package/.github/FUNDING.yml

@@ -1,15 +0,0 @@
-# These are supported funding model platforms
-
-github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
-patreon: # Replace with a single Patreon username
-open_collective: # Replace with a single Open Collective username
-ko_fi: # Replace with a single Ko-fi username
-tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
-community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
-liberapay: # Replace with a single Liberapay username
-issuehunt: # Replace with a single IssueHunt username
-lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
-polar: # Replace with a single Polar username
-buy_me_a_coffee: srinivasveera
-thanks_dev: # Replace with a single thanks.dev username
-custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']