@leg3ndy/otto-bridge 0.8.5 → 0.9.1

package/README.md

@@ -13,6 +13,10 @@ Para um passo a passo de instalacao, pareamento, uso, desconexao e desinstalacao
 
 Para o estado atual da arquitetura, capacidades entregues, limitacoes e roadmap do Otto Bridge, veja [`leg3ndy-ai-backend/docs/OTTO_BRIDGE_ARCHITECTURE.md`](../leg3ndy-ai-backend/docs/OTTO_BRIDGE_ARCHITECTURE.md).
 
+Para o corte de arquitetura do `0.9.0`, veja [`leg3ndy-ai-backend/docs/OTTO_BRIDGE_0_9_0_RELEASE.md`](../leg3ndy-ai-backend/docs/OTTO_BRIDGE_0_9_0_RELEASE.md).
+
+Para o patch atual `0.9.1`, com hotfixes de stream/renderizacao e completude das filesystem tools, veja [`leg3ndy-ai-backend/docs/OTTO_BRIDGE_0_9_1_PATCH.md`](../leg3ndy-ai-backend/docs/OTTO_BRIDGE_0_9_1_PATCH.md).
+
 ## Distribuicao
 
 Fluxo recomendado agora:
@@ -33,12 +37,14 @@ Enquanto o pacote nao estiver publicado, voce pode gerar um tarball local:
 
 ```bash
 npm pack
-npm install -g ./leg3ndy-otto-bridge-0.7.4.tgz
+npm install -g ./leg3ndy-otto-bridge-0.9.1.tgz
 ```
 
-No `0.7.4`, `playwright` segue como dependencia obrigatoria no `otto-bridge`. O primeiro `npm install -g @leg3ndy/otto-bridge` pode demorar mais porque instala o browser persistente usado pelo WhatsApp Web e pelos fluxos web em background do bridge.
+Na linha `0.9.1`, `playwright` segue como dependencia obrigatoria no `otto-bridge`. O primeiro `npm install -g @leg3ndy/otto-bridge` pode demorar mais porque instala o browser persistente usado pelo WhatsApp Web e pelos fluxos web em background do bridge.
+
+No macOS, a linha `0.9.1` usa o provider `macos-helper`, um helper `WKWebView` sem Dock para o WhatsApp Web. O helper sobe com user-agent de Chrome moderno para evitar o bloqueio do WhatsApp ao detectar Safari/WebKit. O runtime antigo com Chromium/Playwright fica disponivel apenas como override explicito via `OTTO_BRIDGE_WHATSAPP_RUNTIME_PROVIDER=embedded-playwright`.
 
-No macOS, o `0.7.4` usa o provider `macos-helper`, um helper `WKWebView` sem Dock para o WhatsApp Web. O helper sobe com user-agent de Chrome moderno para evitar o bloqueio do WhatsApp ao detectar Safari/WebKit. O runtime antigo com Chromium/Playwright fica disponivel apenas como override explicito via `OTTO_BRIDGE_WHATSAPP_RUNTIME_PROVIDER=embedded-playwright`.
+No nivel arquitetural, o `0.9.0` marcou a mudanca de papel do bridge: ele publica tools e resultados estruturados para o Otto, em vez de injetar resposta pronta como caminho principal do chat. O `0.9.1` consolida esse caminho com hotfixes de stream visivel, planner LLM-first e leitura/listagem local sem truncamento silencioso.
 
 ## Publicacao
 
@@ -108,7 +114,7 @@ otto-bridge run --executor clawd-cursor --clawd-url http://127.0.0.1:3847
 
 ### WhatsApp Web em background
 
-Fluxo recomendado no `0.7.4`:
+Fluxo recomendado na linha `0.9.1`:
 
 ```bash
 otto-bridge extensions --install whatsappweb
@@ -118,13 +124,13 @@ otto-bridge extensions --status whatsappweb
 
 O setup agora abre o login do WhatsApp Web no helper/background browser do proprio bridge. Depois do QR code, o Otto usa a sessao local em background, sem depender de aba visivel no Safari.
 
-Contrato do `0.7.4`:
+Contrato da linha `0.9.1`:
 
 - `otto-bridge extensions --setup whatsappweb`: autentica a sessao uma vez
 - `otto-bridge run`: mantem o browser persistente do WhatsApp vivo em background enquanto o runtime estiver ativo, sem depender de uma aba aberta no Safari
 - ao parar o `otto-bridge run`: o browser em background e desligado, mas a sessao local fica lembrada para o proximo boot
 
-## Handoff rapido do 0.7.4
+## Handoff rapido da linha 0.9.1
 
 Ja fechado no codigo:
 
@@ -132,6 +138,11 @@ Ja fechado no codigo:
 - user-agent do helper ajustado para evitar bloqueio do WhatsApp por detecao de Safari/WebKit
 - resultado final dos `device_job` agora e persistido como contexto mais forte para o proximo turno do Otto
 - prompt bridge-aware no chat normal para ajudar o Otto a responder com base no que realmente aconteceu no device
+- runtime local agora publica `local_tools` para o Otto/backend saberem exatamente o que o device consegue fazer
+- o caminho principal do bridge usa `summary`/`narration_context` no lugar de resposta automatica pronta
+- `read_file` agora entrega conteudo completo segmentado em `content_chunks` para o Otto
+- `list_files` sem `limit` agora lista o diretorio inteiro, sem fallback silencioso para 40 itens
+- o planner do bridge prioriza o modelo para escolher a tool certa pelo contexto; regex fica como fallback
 
 Ainda precisa reteste em campo:
 

package/dist/executors/native_macos.js

@@ -702,6 +702,35 @@ function clipTextPreview(value, maxLength) {
     }
     return `${value.slice(0, maxLength)}\n\n[conteudo truncado: mostrando ${maxLength} de ${value.length} caracteres. Peca um trecho mais especifico se quiser continuar.]`;
 }
+function chunkTextForTransport(value, chunkSize) {
+    const normalized = String(value || "");
+    if (!normalized) {
+        return [];
+    }
+    const safeChunkSize = Math.max(400, Math.min(Math.round(chunkSize || 4000), 32_000));
+    const chunks = [];
+    let cursor = 0;
+    let index = 0;
+    while (cursor < normalized.length) {
+        let nextCursor = Math.min(normalized.length, cursor + safeChunkSize);
+        if (nextCursor < normalized.length) {
+            const lastLineBreak = normalized.lastIndexOf("\n", nextCursor);
+            if (lastLineBreak > cursor + Math.floor(safeChunkSize * 0.35)) {
+                nextCursor = lastLineBreak + 1;
+            }
+        }
+        const text = normalized.slice(cursor, nextCursor);
+        chunks.push({
+            index,
+            start_char: cursor,
+            end_char: nextCursor,
+            text,
+        });
+        cursor = nextCursor;
+        index += 1;
+    }
+    return chunks;
+}
 const TEXTUTIL_READABLE_EXTENSIONS = new Set([
     ".doc",
     ".docx",
@@ -975,14 +1004,14 @@ function parseStructuredActions(job) {
         if (type === "read_file" || type === "read_local_file") {
             const filePath = asString(action.path);
             if (filePath) {
-                const maxChars = typeof action.max_chars === "number" ? Math.max(200, Math.min(12000, action.max_chars)) : undefined;
+                const maxChars = typeof action.max_chars === "number" ? Math.max(400, Math.min(32_000, action.max_chars)) : undefined;
                 actions.push({ type: "read_file", path: filePath, max_chars: maxChars });
             }
             continue;
         }
         if (type === "list_files" || type === "ls") {
             const filePath = asString(action.path) || "~";
-            const limit = typeof action.limit === "number" ? Math.max(1, Math.min(200, action.limit)) : undefined;
+            const limit = typeof action.limit === "number" ? Math.max(1, Math.min(5_000, action.limit)) : undefined;
             actions.push({ type: "list_files", path: filePath, limit });
             continue;
         }
@@ -1389,14 +1418,18 @@ export class NativeMacOSJobExecutor {
                 }
                 if (action.type === "read_file") {
                     await reporter.progress(progressPercent, `Lendo ${action.path}`);
-                    const fileContent = await this.readLocalFile(action.path, action.max_chars);
-                    completionNotes.push(`Conteudo de ${action.path}:\n${fileContent}`);
+                    const fileContent = await this.readLocalFileSnapshot(action.path, action.max_chars);
+                    resultPayload.read_file = fileContent;
+                    resultPayload.summary = fileContent.summary;
+                    completionNotes.push(fileContent.summary);
                     continue;
                 }
                 if (action.type === "list_files") {
                     await reporter.progress(progressPercent, `Listando arquivos em ${action.path}`);
-                    const listing = await this.listLocalFiles(action.path, action.limit);
-                    completionNotes.push(`Arquivos em ${action.path}:\n${listing}`);
+                    const listing = await this.listLocalFilesSnapshot(action.path, action.limit);
+                    resultPayload.file_listing = listing;
+                    resultPayload.summary = listing.summary;
+                    completionNotes.push(listing.summary);
                     continue;
                 }
                 if (action.type === "count_files") {
@@ -2364,7 +2397,7 @@ return appNames as text
             snapshot.summary = `A pasta ${targetPath} tem ${entries.length} item${entries.length === 1 ? "" : "s"} e ocupa ${formatBytesCompact(totalSize)}.${childPreview ? ` Itens visiveis agora: ${childPreview}.` : ""}`;
             return snapshot;
         }
-        const preview = includePreview ? await this.readLocalFile(resolved, 1200) : undefined;
+        const preview = includePreview ? await this.readLocalFilePreview(resolved, 1200) : undefined;
         const snapshot = {
             captured_at: new Date().toISOString(),
             path: targetPath,
@@ -4961,9 +4994,9 @@ if let output = String(data: data, encoding: .utf8) {
             resized,
         };
     }
-    async readLocalFile(filePath, maxChars = 4000) {
-        const resolved = await this.resolveReadableFilePath(filePath);
+    async loadReadableFileContent(resolved) {
         const extension = path.extname(resolved).toLowerCase();
+        const mimeType = mimeTypeFromPath(resolved);
         if (TEXTUTIL_READABLE_EXTENSIONS.has(extension)) {
             const { stdout } = await this.runCommandCapture("textutil", [
                 "-convert",
@@ -4971,17 +5004,76 @@ if let output = String(data: data, encoding: .utf8) {
                 "-stdout",
                 resolved,
             ]);
-            const content = sanitizeTextForJsonTransport(stdout);
-            return clipTextPreview(content || "(arquivo sem texto legivel)", maxChars);
+            return {
+                mimeType,
+                encoding: "utf-8",
+                isBinary: false,
+                content: sanitizeTextForJsonTransport(stdout) || "(arquivo sem texto legivel)",
+            };
         }
         const raw = await readFile(resolved);
         if (isLikelyBinaryBuffer(raw)) {
             const filename = path.basename(resolved);
             const detectedType = extension || "binario";
-            return clipText(`O arquivo ${filename} parece ser binario (${detectedType}) e nao pode ser lido como texto puro pelo Otto Bridge ainda.`, maxChars);
+            return {
+                mimeType,
+                isBinary: true,
+                binaryNotice: `O arquivo ${filename} parece ser binario (${detectedType}) e nao pode ser lido como texto puro pelo Otto Bridge ainda.`,
+            };
+        }
+        return {
+            mimeType,
+            encoding: "utf-8",
+            isBinary: false,
+            content: sanitizeTextForJsonTransport(raw.toString("utf8")) || "(arquivo vazio)",
+        };
+    }
+    async readLocalFilePreview(filePath, maxChars = 1200) {
+        const resolved = await this.resolveReadableFilePath(filePath);
+        const loaded = await this.loadReadableFileContent(resolved);
+        if (loaded.isBinary) {
+            return clipText(loaded.binaryNotice || "O arquivo parece ser binario e nao pode ser lido como texto puro.", maxChars);
+        }
+        return clipTextPreview(loaded.content || "(arquivo vazio)", maxChars);
+    }
+    async readLocalFileSnapshot(filePath, chunkSizeChars = 4000) {
+        const resolved = await this.resolveReadableFilePath(filePath);
+        const entryStat = await stat(resolved);
+        const loaded = await this.loadReadableFileContent(resolved);
+        const fileName = path.basename(resolved) || resolved;
+        if (loaded.isBinary) {
+            return {
+                captured_at: new Date().toISOString(),
+                path: filePath,
+                resolved_path: resolved,
+                name: fileName,
+                mime_type: loaded.mimeType,
+                size_bytes: entryStat.size,
+                modified_at: entryStat.mtime.toISOString(),
+                is_binary: true,
+                binary_notice: loaded.binaryNotice,
+                summary: loaded.binaryNotice || `O arquivo ${filePath} parece ser binario e nao pode ser lido como texto puro.`,
+            };
         }
-        const content = sanitizeTextForJsonTransport(raw.toString("utf8"));
-        return clipTextPreview(content || "(arquivo vazio)", maxChars);
+        const content = loaded.content || "(arquivo vazio)";
+        const chunks = chunkTextForTransport(content, chunkSizeChars);
+        return {
+            captured_at: new Date().toISOString(),
+            path: filePath,
+            resolved_path: resolved,
+            name: fileName,
+            mime_type: loaded.mimeType,
+            size_bytes: entryStat.size,
+            modified_at: entryStat.mtime.toISOString(),
+            is_binary: false,
+            encoding: loaded.encoding || "utf-8",
+            content: chunks.length <= 1 ? content : undefined,
+            content_char_count: content.length,
+            chunk_size_chars: Math.max(400, Math.min(Math.round(chunkSizeChars || 4000), 32_000)),
+            chunk_count: chunks.length,
+            chunks,
+            summary: `Li ${filePath} por completo (${content.length} caracteres em ${chunks.length} bloco${chunks.length === 1 ? "" : "s"}).`,
+        };
     }
     async resolveReadableFilePath(filePath) {
         const resolved = expandUserPath(filePath);
@@ -5052,22 +5144,55 @@ if let output = String(data: data, encoding: .utf8) {
         }
         return null;
     }
-    async listLocalFiles(directoryPath, limit = 40) {
+    async listLocalFilesSnapshot(directoryPath, limit) {
         const resolved = expandUserPath(directoryPath);
-        const entries = await readdir(resolved, { withFileTypes: true });
-        const items = await Promise.all(entries.slice(0, limit).map(async (entry) => {
+        const allEntries = await readdir(resolved, { withFileTypes: true });
+        const sortedEntries = allEntries.sort((left, right) => {
+            if (left.isDirectory() !== right.isDirectory()) {
+                return left.isDirectory() ? -1 : 1;
+            }
+            return left.name.localeCompare(right.name);
+        });
+        const effectiveLimit = typeof limit === "number" && Number.isFinite(limit) ? Math.max(1, Math.min(Math.round(limit), 5_000)) : null;
+        const selectedEntries = effectiveLimit ? sortedEntries.slice(0, effectiveLimit) : sortedEntries;
+        const items = await Promise.all(selectedEntries.map(async (entry) => {
             const entryPath = path.join(resolved, entry.name);
-            let suffix = "";
+            let sizeBytes;
+            let modifiedAt;
             try {
                 const entryStat = await stat(entryPath);
-                suffix = entry.isDirectory() ? "/" : ` (${entryStat.size} bytes)`;
+                if (!entry.isDirectory()) {
+                    sizeBytes = entryStat.size;
+                }
+                modifiedAt = entryStat.mtime.toISOString();
             }
             catch {
-                suffix = entry.isDirectory() ? "/" : "";
+                // Ignore stat failures and return the visible entry metadata we have.
             }
-            return `${entry.name}${suffix}`;
+            return {
+                name: entry.name,
+                path: entryPath,
+                kind: entry.isDirectory() ? "directory" : (entry.isFile() ? "file" : "other"),
+                size_bytes: sizeBytes,
+                modified_at: modifiedAt,
+            };
         }));
-        return items.length > 0 ? items.join("\n") : "(pasta vazia)";
+        const summary = items.length === 0
+            ? `A pasta ${directoryPath} esta vazia.`
+            : effectiveLimit && allEntries.length > items.length
+                ? `Listei ${items.length} itens visiveis em ${directoryPath} agora. A pasta tem ${allEntries.length} itens no total.`
+                : `Listei ${items.length} itens de ${directoryPath} por completo.`;
+        return {
+            captured_at: new Date().toISOString(),
+            path: directoryPath,
+            resolved_path: resolved,
+            name: path.basename(resolved) || resolved,
+            item_count: items.length,
+            total_item_count: allEntries.length,
+            limit_applied: effectiveLimit || undefined,
+            entries: items,
+            summary,
+        };
     }
     async countLocalFiles(directoryPath, extensions, recursive = true) {
         const resolved = expandUserPath(directoryPath);

package/dist/runtime.js

@@ -5,6 +5,7 @@ import { NativeMacOSJobExecutor } from "./executors/native_macos.js";
 import { JobCancelledError } from "./executors/shared.js";
 import { isManagedBridgeExtensionSlug, loadManagedBridgeExtensionState, } from "./extensions.js";
 import { LocalAutomationRuntime } from "./local_automations.js";
+import { buildLocalToolCatalog } from "./tool_catalog.js";
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -89,6 +90,7 @@ export class BridgeRuntime {
         const metadata = {
             ...(this.config.metadata || {}),
             installed_extensions: this.config.installedExtensions,
+            executor_type: this.config.executor.type,
         };
         const managedExtensions = {};
         const connectedMessageApps = new Set();
@@ -125,9 +127,21 @@ export class BridgeRuntime {
         if (Object.keys(managedExtensions).length > 0) {
             metadata.managed_extensions = managedExtensions;
         }
+        else {
+            delete metadata.managed_extensions;
+        }
         if (connectedMessageApps.size > 0) {
             metadata.connected_message_apps = Array.from(connectedMessageApps);
         }
+        else {
+            delete metadata.connected_message_apps;
+        }
+        const toolCatalog = buildLocalToolCatalog({
+            executorType: this.config.executor.type,
+            connectedMessageApps: metadata.connected_message_apps,
+        });
+        metadata.local_tools_version = toolCatalog.version;
+        metadata.local_tools = toolCatalog.tools;
         return metadata;
     }
     async sendHello(socket) {

package/dist/tool_catalog.js

@@ -0,0 +1,193 @@
+import { BRIDGE_LOCAL_TOOLS_VERSION, } from "./types.js";
+const NATIVE_MACOS_BASE_TOOLS = [
+    {
+        id: "desktop.apps",
+        title: "Abrir e focar apps",
+        description: "Abre aplicativos locais e traz uma janela para frente no macOS.",
+        category: "desktop",
+        mode: "control",
+        action_types: ["open_app", "focus_app"],
+    },
+    {
+        id: "browser.navigation",
+        title: "Abrir links e destinos web",
+        description: "Abre URLs e pesquisas locais no navegador.",
+        category: "browser",
+        mode: "control",
+        action_types: ["open_url"],
+    },
+    {
+        id: "content.notes",
+        title: "Criar notas e texto",
+        description: "Cria notas, digita texto e executa atalhos locais de escrita.",
+        category: "content",
+        mode: "write",
+        action_types: ["create_note", "type_text", "press_shortcut"],
+        requires_confirmation: true,
+    },
+    {
+        id: "desktop.capture",
+        title: "Captura de tela",
+        description: "Tira screenshot local do macOS.",
+        category: "desktop",
+        mode: "observe",
+        action_types: ["take_screenshot"],
+    },
+    {
+        id: "browser.context",
+        title: "Leitura do navegador",
+        description: "Le a pagina frontal e coleta contexto da aba atual do navegador.",
+        category: "browser",
+        mode: "observe",
+        action_types: ["read_frontmost_page", "browser_context"],
+    },
+    {
+        id: "system.apps",
+        title: "Status de apps",
+        description: "Checa app em foco, apps abertos e processos pesados.",
+        category: "system",
+        mode: "observe",
+        action_types: ["app_status"],
+    },
+    {
+        id: "filesystem.overview",
+        title: "Inspecao de arquivos e pastas",
+        description: "Inspeciona caminhos locais, lista itens e conta arquivos.",
+        category: "filesystem",
+        mode: "observe",
+        action_types: ["filesystem_inspect", "list_files", "count_files"],
+    },
+    {
+        id: "filesystem.read",
+        title: "Leitura de arquivo",
+        description: "Le arquivos de texto quando o caminho esta claro.",
+        category: "filesystem",
+        mode: "observe",
+        action_types: ["read_file"],
+    },
+    {
+        id: "system.health",
+        title: "Status do Mac",
+        description: "Coleta CPU, memoria, disco, bateria e processos de topo.",
+        category: "system",
+        mode: "observe",
+        action_types: ["system_status"],
+    },
+    {
+        id: "shell.inspect",
+        title: "Shell local",
+        description: "Roda comandos locais de consulta e diagnostico.",
+        category: "shell",
+        mode: "control",
+        action_types: ["run_shell"],
+        requires_confirmation: true,
+    },
+    {
+        id: "desktop.audio",
+        title: "Controle de volume",
+        description: "Ajusta o volume do macOS.",
+        category: "desktop",
+        mode: "control",
+        action_types: ["set_volume"],
+    },
+    {
+        id: "desktop.scroll",
+        title: "Scroll da tela",
+        description: "Rola a view ativa para cima ou para baixo.",
+        category: "desktop",
+        mode: "control",
+        action_types: ["scroll_view"],
+    },
+    {
+        id: "visual.click",
+        title: "Clique visual guiado",
+        description: "Procura um alvo simples na tela e clica nele.",
+        category: "visual",
+        mode: "control",
+        action_types: ["click_visual_target"],
+        requires_confirmation: true,
+    },
+    {
+        id: "visual.drag",
+        title: "Arraste visual guiado",
+        description: "Arrasta um alvo visivel para outro alvo visivel.",
+        category: "visual",
+        mode: "control",
+        action_types: ["drag_visual_target"],
+        requires_confirmation: true,
+    },
+];
+const MOCK_TOOLS = [
+    {
+        id: "mock.runtime",
+        title: "Execucao mock",
+        description: "Simula a execucao local para testes sem efeitos reais no dispositivo.",
+        category: "desktop",
+        mode: "control",
+        action_types: [],
+        notes: "Os resultados sao sinteticos e servem apenas para desenvolvimento.",
+    },
+];
+const CLAWD_CURSOR_TOOLS = [
+    {
+        id: "clawd.cursor.task",
+        title: "Tarefa aberta no executor",
+        description: "Delegacao geral para o runtime Clawd Cursor executar uma tarefa no computador.",
+        category: "desktop",
+        mode: "control",
+        action_types: [],
+        requires_confirmation: true,
+    },
+];
+function hasConnectedMessageApp(apps, target) {
+    return apps.some((item) => item === target);
+}
+function buildNativeMessagingTools(connectedMessageApps) {
+    const tools = [];
+    if (hasConnectedMessageApp(connectedMessageApps, "whatsapp")) {
+        tools.push({
+            id: "messaging.whatsapp.read",
+            title: "Leitura de WhatsApp",
+            description: "Abre uma conversa no WhatsApp Web e le as mensagens visiveis.",
+            category: "messaging",
+            mode: "observe",
+            action_types: ["whatsapp_read_chat"],
+        }, {
+            id: "messaging.whatsapp.send",
+            title: "Envio de WhatsApp",
+            description: "Abre a conversa certa e envia mensagem no WhatsApp Web.",
+            category: "messaging",
+            mode: "write",
+            action_types: ["whatsapp_send_message"],
+            requires_confirmation: true,
+        });
+    }
+    return tools;
+}
+export function buildLocalToolCatalog(context) {
+    const connectedMessageApps = Array.from(new Set((context.connectedMessageApps || [])
+        .map((item) => String(item || "").trim().toLowerCase())
+        .filter(Boolean)));
+    if (context.executorType === "native-macos") {
+        return {
+            version: BRIDGE_LOCAL_TOOLS_VERSION,
+            executor_type: context.executorType,
+            tools: [
+                ...NATIVE_MACOS_BASE_TOOLS,
+                ...buildNativeMessagingTools(connectedMessageApps),
+            ],
+        };
+    }
+    if (context.executorType === "clawd-cursor") {
+        return {
+            version: BRIDGE_LOCAL_TOOLS_VERSION,
+            executor_type: context.executorType,
+            tools: CLAWD_CURSOR_TOOLS,
+        };
+    }
+    return {
+        version: BRIDGE_LOCAL_TOOLS_VERSION,
+        executor_type: context.executorType,
+        tools: MOCK_TOOLS,
+    };
+}

package/dist/types.js

@@ -1,5 +1,5 @@
 export const BRIDGE_CONFIG_VERSION = 1;
-export const BRIDGE_VERSION = "0.8.5";
+export const BRIDGE_VERSION = "0.9.1";
 export const BRIDGE_PACKAGE_NAME = "@leg3ndy/otto-bridge";
 export const DEFAULT_API_BASE_URL = "http://localhost:8000";
 export const DEFAULT_POLL_INTERVAL_MS = 3000;
@@ -10,3 +10,4 @@ export const DEFAULT_RECONNECT_MAX_DELAY_MS = 15000;
 export const DEFAULT_EXECUTOR_TYPE = "mock";
 export const DEFAULT_CLAWD_CURSOR_BASE_URL = "http://127.0.0.1:3847";
 export const DEFAULT_CLAWD_CURSOR_POLL_INTERVAL_MS = 1500;
+export const BRIDGE_LOCAL_TOOLS_VERSION = 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leg3ndy/otto-bridge",
-  "version": "0.8.5",
+  "version": "0.9.1",
   "private": false,
   "type": "module",
   "description": "Local companion for Otto Bridge device pairing and WebSocket runtime.",