@mseep/clawdcursor 1.5.5

package/dist/llm/browser-config.js

@@ -0,0 +1,83 @@
+"use strict";
+/**
+ * Browser Configuration — centralised helpers for browser detection and CDP port.
+ *
+ * All files that need to know which browser processes to match, what CDP port
+ * to connect to, or where the browser executable lives should import from here
+ * instead of hardcoding values.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGENT_CDP_PORT = exports.DEFAULT_CDP_PORT = void 0;
+exports.getBrowserExePath = getBrowserExePath;
+exports.getBrowserProcessNames = getBrowserProcessNames;
+exports.getCDPPort = getCDPPort;
+exports.getBrowserProcessRegex = getBrowserProcessRegex;
+exports.getChromePaths = getChromePaths;
+exports.getEdgePaths = getEdgePaths;
+exports.getBrowserPaths = getBrowserPaths;
+exports.DEFAULT_CDP_PORT = 9223;
+/**
+ * Port for the AGENT-OWNED dedicated browser instance (the one CDPDriver
+ * launches itself with `--user-data-dir=~/.clawdcursor/cdp-profile`).
+ *
+ * Deliberately DIFFERENT from DEFAULT_CDP_PORT (9223): ownership is encoded in
+ * the port. 9223 is reserved for browsers the USER put on the wire (their own
+ * launch flags, `relaunch_with_cdp`, the browser relay) — attaching there means
+ * "driving the user's session" and gets new-tab discipline. Sharing one port
+ * for both meant the driver could not tell its own instance from the user's:
+ * whoever squatted 9223 won, and a lingering agent instance the user adopted
+ * (music, browsing) got its tabs hijacked (root-cause fix 2026-06-11).
+ */
+exports.AGENT_CDP_PORT = Number(process.env.CLAWD_AGENT_CDP_PORT ?? '') || 9333;
+const DEFAULT_BROWSER_PROCESSES = ['msedge', 'chrome', 'chromium', 'firefox', 'brave', 'opera', 'arc', 'safari'];
+/** Get configured browser executable path, or null for auto-detection */
+function getBrowserExePath(config) {
+    return config?.browser?.executablePath || null;
+}
+/** Get list of browser process names to match against */
+function getBrowserProcessNames(config) {
+    if (config?.browser?.processName) {
+        return [config.browser.processName, ...DEFAULT_BROWSER_PROCESSES];
+    }
+    return DEFAULT_BROWSER_PROCESSES;
+}
+/** Get CDP debugging port */
+function getCDPPort(config) {
+    return config?.browser?.cdpPort || exports.DEFAULT_CDP_PORT;
+}
+/** Build a regex matching browser process names */
+function getBrowserProcessRegex(config) {
+    const names = getBrowserProcessNames(config);
+    return new RegExp(names.join('|'), 'i');
+}
+const PLATFORM = process.platform;
+/** Get default Chrome executable paths for the current platform */
+function getChromePaths() {
+    if (PLATFORM === 'darwin')
+        return ['/Applications/Google Chrome.app/Contents/MacOS/Google Chrome'];
+    if (PLATFORM === 'linux')
+        return ['/usr/bin/google-chrome', '/usr/bin/google-chrome-stable', '/usr/bin/chromium', '/usr/bin/chromium-browser'];
+    return [
+        'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe',
+        'C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe',
+    ];
+}
+/** Get default Edge executable paths for the current platform */
+function getEdgePaths() {
+    if (PLATFORM === 'darwin')
+        return ['/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge'];
+    if (PLATFORM === 'linux')
+        return ['/usr/bin/microsoft-edge'];
+    return [
+        'C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe',
+        'C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe',
+    ];
+}
+/** Get browser executable paths, respecting config overrides. Tries custom path first, then defaults. */
+function getBrowserPaths(browser, config) {
+    const customExe = getBrowserExePath(config);
+    if (customExe)
+        return [customExe];
+    return browser === 'chrome' ? getChromePaths() : getEdgePaths();
+}
+//# sourceMappingURL=browser-config.js.map

package/dist/llm/browser-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-config.js","sourceRoot":"","sources":["../../src/llm/browser-config.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;AAuBH,8CAEC;AAGD,wDAKC;AAGD,gCAEC;AAGD,wDAGC;AAKD,wCAOC;AAGD,oCAOC;AAGD,0CAIC;AArEY,QAAA,gBAAgB,GAAG,IAAI,CAAC;AAErC;;;;;;;;;;;GAWG;AACU,QAAA,cAAc,GAAG,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,oBAAoB,IAAI,EAAE,CAAC,IAAI,IAAI,CAAC;AAErF,MAAM,yBAAyB,GAAG,CAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;AAEjH,yEAAyE;AACzE,SAAgB,iBAAiB,CAAC,MAAoB;IACpD,OAAO,MAAM,EAAE,OAAO,EAAE,cAAc,IAAI,IAAI,CAAC;AACjD,CAAC;AAED,yDAAyD;AACzD,SAAgB,sBAAsB,CAAC,MAAoB;IACzD,IAAI,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,CAAC;QACjC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,WAAW,EAAE,GAAG,yBAAyB,CAAC,CAAC;IACpE,CAAC;IACD,OAAO,yBAAyB,CAAC;AACnC,CAAC;AAED,6BAA6B;AAC7B,SAAgB,UAAU,CAAC,MAAoB;IAC7C,OAAO,MAAM,EAAE,OAAO,EAAE,OAAO,IAAI,wBAAgB,CAAC;AACtD,CAAC;AAED,mDAAmD;AACnD,SAAgB,sBAAsB,CAAC,MAAoB;IACzD,MAAM,KAAK,GAAG,sBAAsB,CAAC,MAAM,CAAC,CAAC;IAC7C,OAAO,IAAI,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC;AAC1C,CAAC;AAED,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;AAElC,mEAAmE;AACnE,SAAgB,cAAc;IAC5B,IAAI,QAAQ,KAAK,QAAQ;QAAE,OAAO,CAAC,8DAA8D,CAAC,CAAC;IACnG,IAAI,QAAQ,KAAK,OAAO;QAAE,OAAO,CAAC,wBAAwB,EAAE,+BAA+B,EAAE,mBAAmB,EAAE,2BAA2B,CAAC,CAAC;IAC/I,OAAO;QACL,4DAA4D;QAC5D,kEAAkE;KACnE,CAAC;AACJ,CAAC;AAED,iEAAiE;AACjE,SAAgB,YAAY;IAC1B,IAAI,QAAQ,KAAK,QAAQ;QAAE,OAAO,CAAC,gEAAgE,CAAC,CAAC;IACrG,IAAI,QAAQ,KAAK,OAAO;QAAE,OAAO,CAAC,yBAAyB,CAAC,CAAC;IAC7D,OAAO;QACL,mEAAmE;QACnE,6DAA6D;KAC9D,CAAC;AACJ,CAAC;AAED,yGAAyG;AACzG,SAAgB,eAAe,CAAC,OAA0B,EAAE,MAAoB;IAC9E,MAAM,SAAS,GAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC;IAC5C,IAAI,SAAS;QAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IAClC,OAAO,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,cAAc,EAAE,CAAC,CAAC,CAAC,YAAY,EAAE,CAAC;AAClE,CAAC"}

package/dist/llm/client.d.ts

@@ -0,0 +1,268 @@
+/**
+ * Shared LLM calling module — text AND vision.
+ *
+ * Text entry points:
+ *   callTextLLM()       — accepts PipelineConfig (used by pipeline reasoners)
+ *   callTextLLMDirect() — accepts explicit provider params (used by pipeline preprocessor)
+ *
+ * Vision entry points:
+ *   callVisionLLM()       — accepts PipelineConfig
+ *   callVisionLLMDirect() — accepts explicit provider params
+ *
+ * Image normalization: callers pass images in ANY format (OpenAI or Anthropic),
+ * and the client auto-converts to the correct format for the target provider.
+ */
+import { type PipelineConfig } from './providers';
+export declare class LLMError extends Error {
+    constructor(msg: string);
+}
+export declare class LLMAuthError extends LLMError {
+    constructor(msg: string);
+}
+export declare class LLMBillingError extends LLMError {
+    constructor(msg: string);
+}
+export declare class LLMRateLimitError extends LLMError {
+    constructor(msg: string);
+}
+export declare class LLMModelNotFoundError extends LLMError {
+    constructor(msg: string);
+}
+export declare class LLMServerError extends LLMError {
+    constructor(msg: string);
+}
+/**
+ * Apply any model-specific quirks to a request body in place.
+ *
+ * Lookup is by lowercase substring match on the model id. Every matching
+ * quirk runs (multiple rules can apply to the same model). Safe to call
+ * with any model id; unknown models pass through unchanged.
+ */
+export declare function applyModelQuirks(model: string, body: Record<string, unknown>): void;
+export interface TextLLMOptions {
+    /** System prompt (used for single-turn, or ignored when `messages` is set) */
+    system?: string;
+    /** User message (used for single-turn, or ignored when `messages` is set) */
+    user?: string;
+    /** Full multi-turn messages array — overrides system/user when provided */
+    messages?: Array<{
+        role: string;
+        content: string;
+    }>;
+    /** Force JSON response (OpenAI: response_format, Anthropic: prefill '{') */
+    forceJson?: boolean;
+    /** Max tokens to generate (default 500) */
+    maxTokens?: number;
+    /** Request timeout in milliseconds (default: none) */
+    timeoutMs?: number;
+    /** Number of retries with exponential backoff (default 0) */
+    retries?: number;
+}
+export interface DirectLLMOptions extends TextLLMOptions {
+    baseUrl: string;
+    model: string;
+    apiKey: string;
+    isAnthropic: boolean;
+}
+/**
+ * Call a text LLM using PipelineConfig (used by reasoners).
+ */
+export declare function callTextLLM(config: PipelineConfig, options: TextLLMOptions): Promise<string>;
+/**
+ * Call a text LLM using explicit provider params (used by pipeline preprocessor).
+ */
+export declare function callTextLLMDirect(opts: DirectLLMOptions): Promise<string>;
+/** Content block that can contain text or images in either OpenAI or Anthropic format. */
+export type VisionContentBlock = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'image_url';
+    image_url: {
+        url: string;
+        detail?: string;
+    };
+} | {
+    type: 'image';
+    source: {
+        type: 'base64';
+        media_type: string;
+        data: string;
+    };
+};
+export interface VisionLLMOptions {
+    system?: string;
+    /** Messages with mixed text/image content blocks */
+    messages: Array<{
+        role: string;
+        content: string | VisionContentBlock[];
+    }>;
+    /** Force JSON response */
+    forceJson?: boolean;
+    /** Anthropic JSON prefill (e.g. '{"x":' for coordinate responses) */
+    jsonPrefill?: string;
+    maxTokens?: number;
+    timeoutMs?: number;
+    retries?: number;
+    /** Use SSE streaming with early JSON return (Anthropic only) */
+    stream?: boolean;
+}
+export interface DirectVisionLLMOptions extends VisionLLMOptions {
+    baseUrl: string;
+    model: string;
+    apiKey: string;
+    isAnthropic: boolean;
+    providerProfile?: PipelineConfig['provider'];
+}
+/**
+ * Normalize an image content block to the target provider format.
+ * Callers can pass images in either OpenAI or Anthropic format.
+ */
+export declare function normalizeImageBlock(block: VisionContentBlock, isAnthropic: boolean): any;
+/**
+ * Call a vision LLM using PipelineConfig.
+ * Uses layer3 config (vision model) with layer2 as fallback.
+ */
+export declare function callVisionLLM(config: PipelineConfig, options: VisionLLMOptions): Promise<string>;
+/**
+ * Call a vision LLM with explicit provider params.
+ */
+export declare function callVisionLLMDirect(opts: DirectVisionLLMOptions): Promise<string>;
+/**
+ * A tool the model can call. Mirrors Anthropic's `tools` schema and
+ * OpenAI's `tools[].function` schema — both accept JSON-Schema input.
+ */
+export interface LLMTool {
+    name: string;
+    description: string;
+    /** JSON Schema for the tool's arguments. */
+    inputSchema: {
+        type: 'object';
+        properties: Record<string, unknown>;
+        required?: string[];
+        additionalProperties?: boolean;
+    };
+}
+/**
+ * One structured tool call extracted from the model response. The agent
+ * runs this and feeds the result back on the next turn as a
+ * `tool_result` content block.
+ */
+export interface LLMToolCall {
+    /** Provider-assigned ID, used to associate the subsequent tool_result block. */
+    id: string;
+    name: string;
+    /** Already-parsed JSON args (never a JSON string). */
+    args: Record<string, unknown>;
+}
+/** Content blocks the agent's assistant turn can produce. */
+export type LLMAssistantBlock = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+};
+/** Content blocks a user turn can carry. */
+export type LLMUserBlock = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'image';
+    source: {
+        type: 'base64';
+        media_type: string;
+        data: string;
+    };
+} | {
+    type: 'image_url';
+    image_url: {
+        url: string;
+        detail?: string;
+    };
+} | {
+    type: 'tool_result';
+    tool_use_id: string;
+    content: Array<{
+        type: 'text';
+        text: string;
+    } | {
+        type: 'image';
+        source: {
+            type: 'base64';
+            media_type: string;
+            data: string;
+        };
+    }>;
+    is_error?: boolean;
+};
+/** Conversation turn for the tool-use API. */
+export interface LLMToolTurn {
+    role: 'user' | 'assistant';
+    content: string | LLMUserBlock[] | LLMAssistantBlock[];
+}
+export interface ToolUseResult {
+    /** Free-text prose the model emitted alongside tool calls (if any). */
+    text: string;
+    /** Zero or more tool calls in the order the model emitted them. */
+    toolCalls: LLMToolCall[];
+    /** Provider reason the turn ended — `tool_use` / `end_turn` / `stop` / `length`. */
+    stopReason: string;
+    /** Raw assistant content — forward verbatim on the next turn as `{role:'assistant', content: raw}`. */
+    raw: LLMAssistantBlock[];
+}
+export interface DirectToolUseOptions {
+    baseUrl: string;
+    model: string;
+    apiKey: string;
+    isAnthropic: boolean;
+    system: string;
+    tools: LLMTool[];
+    messages: LLMToolTurn[];
+    /** "auto" (default) | "any" | "none" | specific tool name */
+    toolChoice?: 'auto' | 'any' | 'none' | {
+        name: string;
+    };
+    maxTokens?: number;
+    timeoutMs?: number;
+    /** External abort (user stop) — combined with the per-call timeout. */
+    signal?: AbortSignal;
+}
+/**
+ * Invoke an LLM with a tool catalog. Prefers native tool_use (Anthropic)
+ * or tool_calls (OpenAI) and falls back to JSON-in-prose parsing for
+ * providers that lack native support (Ollama text-only models, etc.).
+ *
+ * The caller supplies the tool catalog + multi-turn messages; the function
+ * returns a structured ToolUseResult with parsed tool calls. The agent runs
+ * each tool and feeds results back as `tool_result` blocks on the next turn.
+ */
+export declare function callLLMWithTools(opts: DirectToolUseOptions): Promise<ToolUseResult>;
+/**
+ * Fallback prose→tool-call parser for providers that don't emit native tool_calls.
+ *
+ * Recognizes three families:
+ *
+ *   1. **Prefix-style** (Kimi `moonshot-v1-*`, some DeepSeek / Qwen text models):
+ *      `functions.<TOOL>:<id>$\n{ "arg": "value" }`
+ *      The function NAME lives in the prefix; the JSON body is the args.
+ *
+ *   2. **Llama-style** (some Llama/Mistral fine-tunes):
+ *      `<function=NAME>{...args JSON...}</function>`
+ *      Or: `<|tool_call|>NAME\n{...}`
+ *
+ *   3. **JSON-only** (older Ollama, generic text fallbacks):
+ *      A bare JSON object with `tool|name|action` + `args|input|parameters` keys.
+ *
+ * The parser tries each in order and returns the first match. Returns null
+ * when nothing parses — the caller treats that as a legitimate text-only reply.
+ *
+ * Pattern-matched, NOT model-name-matched, so any provider that emits one
+ * of these formats works without an explicit allowlist entry.
+ */
+export declare function tryParseProseToolCall(prose: string): {
+    name: string;
+    args: Record<string, unknown>;
+} | null;