@heylemon/lemonade 0.4.5 → 0.4.8

package/bin/lemon-composio

@@ -36,17 +36,32 @@ case "$1" in
 
   execute)
     # Execute any Composio tool by slug
-    # Usage: lemon-composio execute TOOL_SLUG '{"param": "value"}'
-    [[ -z "$2" ]] && echo "Usage: lemon-composio execute <TOOL_SLUG> [json_parameters]" && exit 1
+    # Usage: lemon-composio execute TOOL_SLUG '{"param": "value"}' [--account=<id>]
+    [[ -z "$2" ]] && echo "Usage: lemon-composio execute <TOOL_SLUG> [json_parameters] [--account=<id>]" && exit 1
 
     tool_slug="$2"
     params="${3:-{\}}"
+    account_id=""
 
-    # Build the request body
-    EXEC_JSON=$(jq -n \
-      --arg toolName "$tool_slug" \
-      --argjson parameters "$params" \
-      '{toolName: $toolName, parameters: $parameters}')
+    for arg in "${@:3}"; do
+      case "$arg" in
+        --account=*) account_id="${arg#*=}" ;;
+      esac
+    done
+
+    # Build the request body (include accountId only when specified)
+    if [[ -n "$account_id" ]]; then
+      EXEC_JSON=$(jq -n \
+        --arg toolName "$tool_slug" \
+        --argjson parameters "$params" \
+        --arg accountId "$account_id" \
+        '{toolName: $toolName, parameters: $parameters, accountId: $accountId}')
+    else
+      EXEC_JSON=$(jq -n \
+        --arg toolName "$tool_slug" \
+        --argjson parameters "$params" \
+        '{toolName: $toolName, parameters: $parameters}')
+    fi
 
     echo "$EXEC_JSON" | curl -s -X POST \
       -H "Authorization: Bearer ${GATEWAY_TOKEN}" \
@@ -72,11 +87,13 @@ Commands:
         lemon-composio search "post to linkedin"
         lemon-composio search "issues" --toolkit=github
 
-  execute <TOOL_SLUG> [json_parameters]
+  execute <TOOL_SLUG> [json_parameters] [--account=<id>]
       Execute a Composio tool by its slug.
+      Use --account to target a specific connected account when
+      multiple accounts exist for the same provider.
       Examples:
         lemon-composio execute JIRA_CREATE_ISSUE '{"summary":"Bug fix","project_key":"PROJ"}'
-        lemon-composio execute LINKEDIN_CREATE_POST '{"text":"Hello world!"}'
+        lemon-composio execute GMAIL_SEND_EMAIL '{"to":"a@b.com"}' --account=int_abc
 
   status
       Show which integrations the user has connected.

package/dist/agents/system-prompt.js

@@ -117,7 +117,7 @@ function buildConfirmationSection(isMinimal) {
         "",
         "Format:",
         "```",
-        "⚠️ CONFIRM: [brief action description]",
+        "CONFIRM: [brief action description]",
         "",
         "Action: [what will happen]",
         "To: [recipient/target]",
@@ -173,7 +173,7 @@ export function buildAgentSystemPrompt(params) {
         ls: "List directory contents",
         exec: "Run shell commands (use lemon-* CLIs for integrations; for third-party apps like Trello/Jira/Asana use ONLY lemon-composio, never bare commands)",
         process: "Manage background exec sessions",
-        web_search: "Search the web (Brave API)",
+        web_search: "Search the web (DuckDuckGo by default, no API key needed)",
         web_fetch: "Fetch and extract readable content from a URL",
         // Channel docking: add login tools here when a channel needs interactive linking.
         browser: "Control Lemonade's dedicated browser (never the user's personal browser)",
@@ -335,22 +335,22 @@ export function buildAgentSystemPrompt(params) {
         "Keep narration brief and value-dense; avoid repeating obvious steps.",
         "Use plain human language for narration unless in a technical context.",
         "",
-        "⚠️ CRITICAL: NEVER narrate your internal search/discovery process to the user. When searching for tools, trying different queries, checking connection status, etc. — do all of that SILENTLY. The user should only see the FINAL result or a brief status like 'Checking your LinkedIn...' Do NOT say things like 'Let me try a more specific search', 'Let me search for tools that can...', 'I found tools but...', 'Let me try one more search'. Just do the work and give the answer.",
+        "CRITICAL: NEVER narrate your internal search/discovery process to the user. When searching for tools, trying different queries, checking connection status, etc. — do all of that SILENTLY. The user should only see the FINAL result or a brief status like 'Checking your LinkedIn...' Do NOT say things like 'Let me try a more specific search', 'Let me search for tools that can...', 'I found tools but...', 'Let me try one more search'. Just do the work and give the answer.",
         "",
-        "⚠️ NEVER expose technical details to the user. NEVER mention tool names (e.g. LINKEDIN_GET_POST_CONTENT), tool slugs, API names, Composio, integration details, connection status, or internal implementation. The user doesn't know or care about tools — they just want results. Speak in plain human language only.",
+        "CRITICAL: NEVER expose technical details to the user. NEVER mention tool names (e.g. LINKEDIN_GET_POST_CONTENT), tool slugs, API names, Composio, integration details, connection status, or internal implementation. The user doesn't know or care about tools — they just want results. Speak in plain human language only.",
         "",
-        "⚠️ NEVER give up or tell the user to do it themselves. If CLI tools can't do it, use the browser. If the browser requires login, ask the user to log in and wait. If the user IS logged in, just do the task — navigate to their profile, find what they asked for, and give them the answer. You have a browser — USE IT. Do NOT say 'You might want to check LinkedIn directly' or 'I cannot do this'. You CAN do it via the browser.",
+        "CRITICAL: NEVER give up or tell the user to do it themselves. If CLI tools can't do it, use the browser. If the browser requires login, ask the user to log in and wait. If the user IS logged in, just do the task — navigate to their profile, find what they asked for, and give them the answer. You have a browser — USE IT. Do NOT say 'You might want to check LinkedIn directly' or 'I cannot do this'. You CAN do it via the browser.",
         "",
         "## Action Bias",
         "ALWAYS execute tasks directly instead of presenting options or asking how the user wants it done.",
         "If the user asks you to do something (take a screenshot, send a file, etc.), just do it — pick the best approach and act.",
         "Never reply with a list of approaches/options when a single tool call would suffice.",
-        "⚠️ NEVER stop after announcing what you're going to do. Do NOT say 'I'll check your LinkedIn' and then stop. Say it AND immediately do it in the same response — search, open browser, navigate, find the answer, and return it. The user should never have to ask twice. One request = one complete answer.",
+        "CRITICAL: NEVER stop after announcing what you're going to do. Do NOT say 'I'll check your LinkedIn' and then stop. Say it AND immediately do it in the same response — search, open browser, navigate, find the answer, and return it. The user should never have to ask twice. One request = one complete answer.",
         "For screenshots of native macOS windows: use Peekaboo (`peekaboo image`) via exec if the skill is available.",
         "",
         "## Third-Party App Requests (Trello, Jira, LinkedIn, Asana, HubSpot, Salesforce, Todoist, etc.)",
         "",
-        "⚠️ CRITICAL RULE: For ANY service not in the dedicated CLI list below, try `lemon-composio` FIRST. There are NO other CLIs. Running `trello`, `jira`, `composio`, `asana`, `hubspot`, or any bare command will FAIL. The ONLY command that works is `lemon-composio search` and `lemon-composio execute`. Do NOT run `which trello`, `trello --help`, `composio`, or try to discover CLIs. They do not exist.",
+        "CRITICAL RULE: For ANY service not in the dedicated CLI list below, try `lemon-composio` FIRST. There are NO other CLIs. Running `trello`, `jira`, `composio`, `asana`, `hubspot`, or any bare command will FAIL. The ONLY command that works is `lemon-composio search` and `lemon-composio execute`. Do NOT run `which trello`, `trello --help`, `composio`, or try to discover CLIs. They do not exist.",
         "",
         "Dedicated `lemon-*` CLIs (the COMPLETE list): lemon-gmail, lemon-calendar, lemon-drive, lemon-docs, lemon-sheets, lemon-slides, lemon-notion, lemon-slack, lemon-youtube, lemon-twitter, lemon-composio.",
         "ANYTHING not in this list → use `lemon-composio search`.",
@@ -367,17 +367,7 @@ export function buildAgentSystemPrompt(params) {
         "3. Do NOT disconnect without explicit user confirmation.",
         "",
         "### Task requests (do something WITH a service)",
-        "When the user mentions ANY service not in the dedicated CLI list, follow this EXACT sequence. Do ALL searching SILENTLY — the user should never see your search process:",
-        '1. Run `lemon-composio search "<what the user wants>"` — this is your FIRST action. No web search. No `which`. No `--help`. No questions.',
-        "2. If result shows `connected: true` → execute the tool immediately with `lemon-composio execute`.",
-        "3. If the search returns results but none match the exact action, try broader/different search terms SILENTLY. Do NOT tell the user you're retrying searches.",
-        "4. If the service IS connected but the specific action truly doesn't exist, open the browser to do it. Tell the user briefly: \"Let me do this in the browser — I'll have better control there.\" Do NOT mention Composio, tools, searches, integrations, or any technical details.",
-        '5. If result shows `connected: false` → include the `connectUrl` from the search result as plain text (no backticks, no bold, no brackets) e.g. lemon://connect?provider=jira. The app will automatically open the auth page. Say "Connecting [service name] for you: lemon://connect?provider=X" Then STOP and wait for them to complete the auth.',
-        "6. Once the user confirms they connected → execute the tool.",
-        "7. If `lemon-composio` has no results OR `lemon://connect` fails → use the browser as fallback. Open the service website, let the user log in, and complete the task via browser tools.",
-        "",
-        "### Already-connected services",
-        "If `lemon-composio search` shows a service as `connected: true`, do NOT try to connect it again. Do NOT output lemon://connect for an already-connected service. Just use the available tools directly.",
+        "When the user mentions ANY service not in the dedicated CLI list, use `lemon-composio` — see the 'Dynamic tool discovery' section below for the full flow. Do ALL searching SILENTLY — the user should never see your search process.",
         "",
         "### Account & Login Policy",
         "NEVER create accounts or sign up for services on behalf of the user. If a service requires login or account creation in the browser:",
@@ -403,7 +393,7 @@ export function buildAgentSystemPrompt(params) {
         "1. Service has a dedicated `lemon-*` CLI tool (Gmail, Calendar, Drive, Docs, Sheets, Slides, Notion, Slack, YouTube) → **always use the CLI tool**. Never open these in a browser or via URI.",
         '2. ANY other app/service (Trello, Jira, LinkedIn, HubSpot, Asana, Salesforce, Todoist, etc.) → **always run `lemon-composio search "<task>"`** first. Never say you can\'t do it without searching.',
         "3. If Composio has no results or connect fails → use Lemonade's dedicated `browser` tool as fallback to complete the task directly.",
-        "4. User wants an *answer* from the web → use `web_search` (+ `web_fetch` if needed).",
+        "4. User wants an *answer* from the web → use `web_search` (works out of the box, no API key needed). If it fails, use the `browser` tool to search Google as fallback. Never ask the user for API keys.",
         "5. User wants to *interact* with a page (fill forms, click buttons, scrape data) → use Lemonade's dedicated `browser` tool.",
         "6. User wants to *view* a general website (no CLI or Composio tool exists) → use Lemonade's dedicated `browser` tool to navigate there.",
         "",
@@ -433,10 +423,10 @@ export function buildAgentSystemPrompt(params) {
         "",
         "The response includes `connectedProviders` (all services the user has connected) and `serviceConnected` (whether the searched service is connected). Use these to determine connection status — even if no tools matched the query, `serviceConnected: true` means the user IS connected. Do NOT try to re-connect.",
         "",
-        "Then based on results:",
-        '1. **Tools found + connected** → Execute immediately: `lemon-composio execute <TOOL_SLUG> \'{"param": "value"}\'`. If the first search doesn\'t find the right tool, try different search terms (broader terms, service name only, etc.) before giving up.',
-        "2. **No tools found but `serviceConnected: true`** → The user IS connected but this specific action isn't available as a tool. Try a broader search first (e.g. just the service name). If still nothing, tell the user: \"Let me do this in the browser — I'll have better control there.\" Then use the browser. Do NOT try to connect again.",
-        "3. **Not connected (`serviceConnected: false`)** → Include the `connectUrl` from the result as plain text: lemon://connect?provider=X. NEVER output a connect URL if `serviceConnected` is true or if the provider appears in `connectedProviders`.",
+        "Do ALL searching SILENTLY — never narrate retries or internal search process. Then based on results:",
+        "1. **Tools found + connected** → Execute immediately with `lemon-composio execute`. If the first search doesn't find the right tool, try broader/different search terms SILENTLY before giving up.",
+        "2. **No tools found but `serviceConnected: true`** → The user IS connected but this specific action isn't available as a tool. Try a broader search first (e.g. just the service name). If still nothing, tell the user: \"Let me do this in the browser — I'll have better control there.\" Then use the browser. Do NOT try to connect again. NEVER output a connect URL for an already-connected service.",
+        '3. **Not connected (`serviceConnected: false`)** → Include the `connectUrl` from the result as plain text (no backticks, no bold, no brackets): lemon://connect?provider=X. Say "Connecting [service name] for you: lemon://connect?provider=X" Then STOP and wait for them to complete the auth. Once the user confirms, execute the tool.',
         '4. **Connect fails or no results at all** → Tell the user: "Let me do this in the browser — I\'ll have better control there." Then use the browser directly.',
         "",
         "Example flows:",
@@ -446,6 +436,15 @@ export function buildAgentSystemPrompt(params) {
         "",
         "**Check what's connected:** `lemon-composio status`",
         "",
+        "### Multi-account support",
+        "Search results and status now include `connectedAccounts` — an array of all connected accounts with `provider`, `email`, and `accountId`.",
+        "Each tool in search results also has an `accounts` array showing which accounts can run that tool.",
+        "When the user has multiple accounts for the same provider (e.g. two Gmail accounts), pick the right one based on context:",
+        '- If the user says "work email" or "personal calendar", match by the account email.',
+        '- If unclear which account to use, ask once: "You have multiple Gmail accounts connected (work@company.com, personal@gmail.com). Which one should I use?"',
+        "- Pass the chosen account to execute: `lemon-composio execute TOOL_SLUG '{...}' --account=<accountId>`",
+        "- If only one account exists for the provider, you don't need `--account` — it will be used automatically.",
+        "",
         "### Browser tool (Lemonade's dedicated browser only)",
         "For general websites without a CLI tool, or as fallback when Composio fails, use Lemonade's dedicated `browser` tool (Playwright-managed).",
         '**Never open URLs in the user\'s personal browser.** Do not use `exec open "URL"`, `open -a "Google Chrome"`, or AppleScript to launch URLs. All web browsing goes through the `browser` tool with `profile="lemonade"`.',
@@ -490,7 +489,7 @@ export function buildAgentSystemPrompt(params) {
         '- "create a new doc" → `lemon-docs create "Untitled"` (CLI, not browser)',
         '- "start a Google Meet" → `browser` navigate to `https://meet.new`',
         '- "check my email" → `lemon-gmail list` (CLI, not browser)',
-        '- "what is the capital of France?" → use `web_search` (user wants the answer, not a page)',
+        '- "what is the capital of France?" → use `web_search` (always available)',
         "",
         "## IDE & Coding Agent Control",
         "Control AI coding agents via CLI — never type into GUI windows:",
@@ -694,7 +693,7 @@ export function buildAgentSystemPrompt(params) {
     }
     // Skip silent replies for subagent/none modes
     if (!isMinimal) {
-        lines.push("## Silent Replies", `When you have nothing to say, respond with ONLY: ${SILENT_REPLY_TOKEN}`, "", "⚠️ Rules:", "- It must be your ENTIRE message — nothing else", `- Never append it to an actual response (never include "${SILENT_REPLY_TOKEN}" in real replies)`, "- Never wrap it in markdown or code blocks", "", `❌ Wrong: "Here's help... ${SILENT_REPLY_TOKEN}"`, `❌ Wrong: "${SILENT_REPLY_TOKEN}"`, `✅ Right: ${SILENT_REPLY_TOKEN}`, "");
+        lines.push("## Silent Replies", `When you have nothing to say, respond with ONLY: ${SILENT_REPLY_TOKEN}`, "", "Rules:", "- It must be your ENTIRE message — nothing else", `- Never append it to an actual response (never include "${SILENT_REPLY_TOKEN}" in real replies)`, "- Never wrap it in markdown or code blocks", "", `❌ Wrong: "Here's help... ${SILENT_REPLY_TOKEN}"`, `❌ Wrong: "${SILENT_REPLY_TOKEN}"`, `✅ Right: ${SILENT_REPLY_TOKEN}`, "");
     }
     // Skip heartbeats for subagent/none modes
     if (!isMinimal) {

package/dist/agents/tools/web-search.js

@@ -1,8 +1,9 @@
 import { Type } from "@sinclair/typebox";
+import * as DDG from "duck-duck-scrape";
 import { formatCliCommand } from "../../cli/command-format.js";
 import { jsonResult, readNumberParam, readStringParam } from "./common.js";
 import { DEFAULT_CACHE_TTL_MINUTES, DEFAULT_TIMEOUT_SECONDS, normalizeCacheKey, readCache, readResponseText, resolveCacheTtlMs, resolveTimeoutSeconds, withTimeout, writeCache, } from "./web-shared.js";
-const SEARCH_PROVIDERS = ["brave", "perplexity"];
+const SEARCH_PROVIDERS = ["brave", "perplexity", "duckduckgo"];
 const DEFAULT_SEARCH_COUNT = 5;
 const MAX_SEARCH_COUNT = 10;
 const BRAVE_SEARCH_ENDPOINT = "https://api.search.brave.com/res/v1/web/search";
@@ -74,7 +75,9 @@ function resolveSearchProvider(search) {
         return "perplexity";
     if (raw === "brave")
         return "brave";
-    return "brave";
+    if (raw === "duckduckgo" || raw === "ddg")
+        return "duckduckgo";
+    return "duckduckgo";
 }
 function resolvePerplexityConfig(search) {
     if (!search || typeof search !== "object")
@@ -212,6 +215,25 @@ async function runPerplexitySearch(params) {
     const citations = data.citations ?? [];
     return { content, citations };
 }
+async function runDuckDuckGoSearch(params) {
+    const start = Date.now();
+    const searchResults = await DDG.search(params.query, {
+        safeSearch: DDG.SafeSearchType.MODERATE,
+    });
+    const results = (searchResults.results ?? []).slice(0, params.count).map((r) => ({
+        title: r.title ?? "",
+        url: r.url ?? "",
+        description: r.description?.replace(/<\/?b>/g, "") ?? "",
+        siteName: resolveSiteName(r.url ?? ""),
+    }));
+    return {
+        query: params.query,
+        provider: "duckduckgo",
+        count: results.length,
+        tookMs: Date.now() - start,
+        results,
+    };
+}
 async function runWebSearch(params) {
     const cacheKey = normalizeCacheKey(params.provider === "brave"
         ? `${params.provider}:${params.query}:${params.count}:${params.country || "default"}:${params.search_lang || "default"}:${params.ui_lang || "default"}:${params.freshness || "default"}`
@@ -239,6 +261,15 @@ async function runWebSearch(params) {
         writeCache(SEARCH_CACHE, cacheKey, payload, params.cacheTtlMs);
         return payload;
     }
+    if (params.provider === "duckduckgo") {
+        const ddgResult = await runDuckDuckGoSearch({
+            query: params.query,
+            count: params.count,
+            timeoutSeconds: params.timeoutSeconds,
+        });
+        writeCache(SEARCH_CACHE, cacheKey, ddgResult, params.cacheTtlMs);
+        return ddgResult;
+    }
     if (params.provider !== "brave") {
         throw new Error("Unsupported web search provider.");
     }
@@ -294,19 +325,22 @@ export function createWebSearchTool(options) {
         return null;
     const provider = resolveSearchProvider(search);
     const perplexityConfig = resolvePerplexityConfig(search);
-    const description = provider === "perplexity"
-        ? "Search the web using Perplexity Sonar (direct or via OpenRouter). Returns AI-synthesized answers with citations from real-time web search."
-        : "Search the web using Brave Search API. Supports region-specific and localized search via country and language parameters. Returns titles, URLs, and snippets for fast research.";
+    const descriptions = {
+        perplexity: "Search the web using Perplexity Sonar (direct or via OpenRouter). Returns AI-synthesized answers with citations from real-time web search.",
+        brave: "Search the web using Brave Search API. Supports region-specific and localized search via country and language parameters. Returns titles, URLs, and snippets for fast research.",
+        duckduckgo: "Search the web using DuckDuckGo (no API key required). Returns titles, URLs, and snippets for fast research.",
+    };
     return {
         label: "Web Search",
         name: "web_search",
-        description,
+        description: descriptions[provider] ?? descriptions.duckduckgo,
         parameters: WebSearchSchema,
         execute: async (_toolCallId, args) => {
+            let effectiveProvider = provider;
             const perplexityAuth = provider === "perplexity" ? resolvePerplexityApiKey(perplexityConfig) : undefined;
             const apiKey = provider === "perplexity" ? perplexityAuth?.apiKey : resolveSearchApiKey(search);
-            if (!apiKey) {
-                return jsonResult(missingSearchKeyPayload(provider));
+            if (!apiKey && provider !== "duckduckgo") {
+                effectiveProvider = "duckduckgo";
             }
             const params = args;
             const query = readStringParam(params, "query", { required: true });
@@ -315,7 +349,7 @@ export function createWebSearchTool(options) {
             const search_lang = readStringParam(params, "search_lang");
             const ui_lang = readStringParam(params, "ui_lang");
             const rawFreshness = readStringParam(params, "freshness");
-            if (rawFreshness && provider !== "brave") {
+            if (rawFreshness && effectiveProvider !== "brave") {
                 return jsonResult({
                     error: "unsupported_freshness",
                     message: "freshness is only supported by the Brave web_search provider.",
@@ -333,10 +367,10 @@ export function createWebSearchTool(options) {
             const result = await runWebSearch({
                 query,
                 count: resolveSearchCount(count, DEFAULT_SEARCH_COUNT),
-                apiKey,
+                apiKey: apiKey ?? "",
                 timeoutSeconds: resolveTimeoutSeconds(search?.timeoutSeconds, DEFAULT_TIMEOUT_SECONDS),
                 cacheTtlMs: resolveCacheTtlMs(search?.cacheTtlMinutes, DEFAULT_CACHE_TTL_MINUTES),
-                provider,
+                provider: effectiveProvider,
                 country,
                 search_lang,
                 ui_lang,

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.4.5",
-  "commit": "fe3f413801f7c8eacfec8225f6735cd626c0233e",
-  "builtAt": "2026-02-24T09:45:57.128Z"
+  "version": "0.4.8",
+  "commit": "bd6ce676d45649b75d56ace5dd5ed43688021700",
+  "builtAt": "2026-02-24T17:07:07.985Z"
 }

package/dist/canvas-host/a2ui/.bundle.hash

@@ -1 +1 @@
-132afc79b9ddf8d1cbc0b38cf08ab7215d4bded00d598b85a269a1a94575c3da
+eeff6d1d4766fef20888820347f161ad21b9437d6735c618040c29b7af380047

package/dist/config/schema.js

@@ -143,7 +143,7 @@ const FIELD_LABELS = {
     "tools.message.broadcast.enabled": "Enable Message Broadcast",
     "tools.web.search.enabled": "Enable Web Search Tool",
     "tools.web.search.provider": "Web Search Provider",
-    "tools.web.search.apiKey": "Brave Search API Key",
+    "tools.web.search.apiKey": "Search API Key (Brave/Perplexity, optional)",
     "tools.web.search.maxResults": "Web Search Max Results",
     "tools.web.search.timeoutSeconds": "Web Search Timeout (sec)",
     "tools.web.search.cacheTtlMinutes": "Web Search Cache TTL (min)",
@@ -358,9 +358,9 @@ const FIELD_HELP = {
     "tools.message.crossContext.marker.prefix": 'Text prefix for cross-context markers (supports "{channel}").',
     "tools.message.crossContext.marker.suffix": 'Text suffix for cross-context markers (supports "{channel}").',
     "tools.message.broadcast.enabled": "Enable broadcast action (default: true).",
-    "tools.web.search.enabled": "Enable the web_search tool (requires a provider API key).",
-    "tools.web.search.provider": 'Search provider ("brave" or "perplexity").',
-    "tools.web.search.apiKey": "Brave Search API key (fallback: BRAVE_API_KEY env var).",
+    "tools.web.search.enabled": "Enable the web_search tool.",
+    "tools.web.search.provider": 'Search provider ("duckduckgo", "brave", or "perplexity"). Default: "duckduckgo" (free, no API key).',
+    "tools.web.search.apiKey": "Brave Search API key (fallback: BRAVE_API_KEY env var). Only needed for Brave provider.",
     "tools.web.search.maxResults": "Default number of results to return (1-10).",
     "tools.web.search.timeoutSeconds": "Timeout in seconds for web_search requests.",
     "tools.web.search.cacheTtlMinutes": "Cache TTL in minutes for web_search results.",

package/dist/config/zod-schema.agent-runtime.js

@@ -149,7 +149,9 @@ export const ToolPolicySchema = ToolPolicyBaseSchema.superRefine((value, ctx) =>
 export const ToolsWebSearchSchema = z
     .object({
     enabled: z.boolean().optional(),
-    provider: z.union([z.literal("brave"), z.literal("perplexity")]).optional(),
+    provider: z
+        .union([z.literal("brave"), z.literal("perplexity"), z.literal("duckduckgo")])
+        .optional(),
     apiKey: z.string().optional(),
     maxResults: z.number().int().positive().optional(),
     timeoutSeconds: z.number().int().positive().optional(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heylemon/lemonade",
-  "version": "0.4.5",
+  "version": "0.4.8",
   "description": "AI gateway CLI for Lemon - local AI assistant with integrations",
   "publishConfig": {
     "access": "restricted"
@@ -198,6 +198,7 @@
     "detect-libc": "^2.1.2",
     "discord-api-types": "^0.38.37",
     "dotenv": "^17.2.3",
+    "duck-duck-scrape": "^2.2.7",
     "express": "^5.2.1",
     "file-type": "^21.3.0",
     "grammy": "^1.39.3",

package/skills/gmail/SKILL.md

@@ -31,18 +31,9 @@ The recap covers:
 
 To create it, use the `cron` tool with `action=add`. Check `cron action=list` first to avoid duplicates.
 
-## Resolving Recipients (CRITICAL — never fabricate emails)
+## Resolving Recipients
 
-When the user says "send to Masood" or "email John from my team" and does NOT provide an email address:
-
-1. **Slack directory first** (fastest): Use the `message` tool with `action: "search-users"`, `channel: "slack"`, `query: "masood"`. This returns `name`, `handle`, and **`email`**. If found, use that email.
-2. **Gmail contacts**: Run `lemon-gmail find-contact "masood"` to search Google Contacts.
-3. **Sent email history**: Run `lemon-gmail sent-to "masood"` to find emails you've previously sent to someone with that name.
-4. **Ask the user**: If all lookups return nothing, ask: "I couldn't find Masood's email address. Could you provide it?"
-
-**NEVER fabricate an email address** like `masood@example.com` or guess a domain. Always resolve from real data or ask.
-
-**ALWAYS confirm** before sending: "I found Masood Ali (masood.ali@company.com). Should I send the email to this address?"
+**NEVER fabricate email addresses.** See the email skill for the full resolution flow (Slack → Gmail contacts → sent history → ask user). Always confirm the resolved email before sending.
 
 ## Sending with Attachments
 

package/skills/integrations/SKILL.md

@@ -1,10 +1,10 @@
 ---
 name: integrations
-description: Lemon integrations are configured at ~/.lemonade/skills/
+description: Manage and connect Lemon integrations
 metadata:
   lemonade:
     emoji: "🔗"
-    note: "Dynamic skills are auto-generated in ~/.lemonade/skills/"
+    note: "Dynamic skills are auto-generated when services are connected"
 ---
 
 # Lemon Integrations
@@ -25,11 +25,7 @@ when you connect services in Lemon Settings > Integrations.
 
 Provider IDs: gmail, slack, googlecalendar, googledrive, notion, youtube, jira, github, linear, trello, asana, etc.
 
-The generated skills are placed in `~/.lemonade/skills/` and include:
-- Full CLI paths for your machine
-- Proper authentication tokens
-
-If integrations aren't working, restart the Lemon app to regenerate them.
+Integration skills are auto-generated when you connect services. If integrations aren't working, restart the Lemon app to regenerate them.
 
 ## Connection Flow (Priority Order)
 
@@ -59,6 +55,16 @@ Some services (Jira, Trello, Asana, Confluence, etc.) require knowing the user's
 - **ClickUp:** https://app.clickup.com
 - **Monday.com:** https://monday.com
 
+## Multi-Account Support
+
+Users can connect multiple accounts for the same provider (e.g. two Gmail accounts, two Slack workspaces). When executing tools:
+
+- **Search results** include a `connectedAccounts` array with each account's `provider`, `email`, and `accountId`. Each tool also lists which `accounts` can run it.
+- **If only one account** exists for the provider, it's used automatically — no need to specify.
+- **If multiple accounts** exist, pick the right one based on context (e.g. "send from my work email" → match by email). If unclear, ask the user once.
+- **To target a specific account:** `lemon-composio execute TOOL_SLUG '{"params"}' --account=<accountId>`
+- **Status** (`lemon-composio status`) also returns `connectedAccounts` so you can see all accounts at a glance.
+
 ## Browser Fallback
 
 When CLI tools or Composio can't do something, ALWAYS use the browser. NEVER give up or tell the user to do it themselves.

package/skills/meetings/SKILL.md

@@ -28,14 +28,15 @@ lemon-calendar list
 
 Zoom does not have a `lemon-*` CLI. If the user specifically needs Zoom (not Google Meet), use the Composio integration if connected.
 
-### Check if Connected
+### Using Zoom via Composio
 
 ```bash
-curl -H "Authorization: Bearer $GATEWAY_TOKEN" \
-  https://voice-wisal.voice-f05.workers.dev/api/lemonade/tools/status
+lemon-composio search "create zoom meeting"
 ```
 
-Check `hasZoom` in response. If connected, use `ZOOM_CREATE_MEETING` Composio tool. If not, trigger OAuth: `lemon://connect?provider=zoom`
+If tools are found and connected, execute immediately. If Zoom is not connected, output the connect URL as plain text:
+
+lemon://connect?provider=zoom
 
 ## If NOT Connected
 
@@ -52,6 +53,6 @@ Include the connect URL as plain text in your reply. The app will automatically
 ## Remember
 
 - **`lemon-calendar` first** — For Google Calendar + Meet
-- **Never open browser** for calendar or meeting scheduling unless CLI fails
+- **`lemon-composio`** — For Zoom and other meeting services without a dedicated CLI
+- **Browser as last resort** — Only if CLI and Composio both fail
 - **Always include timezone** — Essential for meetings
-- **Be honest** — Offer to connect if not set up

package/skills/social-media/SKILL.md

@@ -4,8 +4,9 @@ Post to LinkedIn, Twitter/X, and other social platforms.
 
 ## Priority Order
 
-1. **`lemon-twitter`** CLI for Twitter/X — Always use this first
-2. **Browser** — Fallback only if CLI fails or service is not connected
+1. **`lemon-twitter`** CLI for Twitter/X
+2. **`lemon-composio`** for LinkedIn and other social platforms
+3. **Browser** — Fallback only if CLI/Composio fails or service is not connected
 
 ## Twitter/X
 
@@ -29,40 +30,26 @@ lemon-twitter search "query"
 
 ## LinkedIn
 
-LinkedIn does not currently have a `lemon-*` CLI. Use the Composio integration if connected, otherwise use browser as fallback.
+LinkedIn does not have a dedicated `lemon-*` CLI. Use `lemon-composio` to search and execute LinkedIn tools.
 
-### Check if Connected
+### Posting, checking activity, etc.
 
 ```bash
-curl -H "Authorization: Bearer $GATEWAY_TOKEN" \
-  https://voice-wisal.voice-f05.workers.dev/api/lemonade/tools/status
+lemon-composio search "create linkedin post"
+lemon-composio search "linkedin activity"
 ```
 
-Check `hasLinkedIn` in response.
+If tools are found and connected, execute immediately. If the specific action isn't available as a tool, use the browser as fallback.
 
-### If Connected (hasLinkedIn: true)
+### If Not Connected
 
-```bash
-curl -X POST \
-  -H "Authorization: Bearer $GATEWAY_TOKEN" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "toolName": "LINKEDIN_CREATE_POST",
-    "parameters": {
-      "text": "Your post content here",
-      "visibility": "PUBLIC"
-    }
-  }' \
-  https://voice-wisal.voice-f05.workers.dev/api/lemonade/tools/execute
-```
-
-### If NOT Connected
+Output the connect URL as plain text:
 
-Include the connect URL as plain text in your reply. The app will automatically open the auth page:
+lemon://connect?provider=linkedin
 
-"LinkedIn isn't connected yet. Opening the connection page for you: lemon://connect?provider=linkedin"
+### If Connect Fails
 
-If connect fails, use the browser as fallback: navigate to `linkedin.com/feed`, click "Start a post"
+Use the browser as fallback — navigate to linkedin.com and complete the task directly.
 
 ## Content Guidelines
 
@@ -78,7 +65,7 @@ If connect fails, use the browser as fallback: navigate to `linkedin.com/feed`,
 - Hashtags and mentions common
 - Good for: quick updates, engagement
 
-## ⚠️ ALWAYS Confirm Before Posting
+## ALWAYS Confirm Before Posting
 
 **Never post without user approval.**