@asm-agent/coding-agent 0.9.2 → 0.9.4

package/bundled-extensions/OLLAMA-TOOL-FORCING.md

@@ -0,0 +1,155 @@
+# Ollama Tool-Forcing Extension
+
+Esta extensão resolve um problema comum ao usar modelos abertos menores (Qwen 27b, Llama, etc) rodando via Ollama com o ASM Agent.
+
+## Problema
+
+Quando você roda um modelo menor localmente via Ollama, o seguinte comportamento pode ocorrer:
+
+1. O modelo começa a **gerar seu raciocínio** (thinking/internal reasoning)
+2. **Após pensar**, o modelo **não chama nenhuma ferramenta**
+3. O modelo **não gera nenhum texto final** para o usuário
+4. O modelo simplesmente **emite um "token de parada"** e encerra
+5. O ASM Agent fica **parado esperando você falar**
+
+Isso não é um "bug" — é um comportamento comum de modelos menores quando não há instrução explícita.
+
+## Solução
+
+Esta extensão **injeta automaticamente** uma instrução forte no system prompt que:
+
+- ✅ **Força o modelo a chamar ferramentas** antes de parar
+- ✅ **Proíbe gerações vazias** (só thinking sem ação)
+- ✅ **Mantém o loop autônomo** funcionando continuamente
+- ✅ **Funciona automaticamente** — sem precisar de comandos especiais
+
+## Como Usar
+
+### 1. Ativar a Extensão
+
+A extensão já foi colocada em:
+```
+~/.asm-agent/extensions/ollama-tool-forcing.ts
+```
+
+Ela é **auto-descoberta** — não precisa fazer nada especial. Será carregada automaticamente na próxima vez que você iniciar o ASM Agent.
+
+### 2. Recarregar em Tempo Real
+
+Se o ASM Agent já está rodando, use o comando:
+```
+/reload
+```
+
+Isso recarrega todas as extensões sem precisar reiniciar.
+
+### 3. Verificar Status
+
+Use o comando:
+```
+/ollama-tools-info
+```
+
+Ele mostra se a extensão está ativa (✅) e permite fazer toggle (ligar/desligar).
+
+## O Que a Extensão Faz
+
+Quando você envia uma tarefa, a extensão adiciona isto ao final do system prompt:
+
+```
+## ⚠️ REGRA CRÍTICA: TOOL-FORCING PARA MODELOS LOCAIS
+
+Você está rodando num modelo aberto (Ollama/local). Para garantir que trabalhe autonomamente:
+
+1. **NUNCA pare sem chamar uma ferramenta**: Depois de pensar/raciocinar, você DEVE chamar
+   uma ferramenta (bash, edit, ipython, etc) para continuar o trabalho.
+
+2. **Sem gerações vazias**: Não é permitido apenas gerar um "thinking" e depois parar.
+
+3. **Ferramentas = Continuidade**: Use-as para:
+   - Verificar status (bash, ipython)
+   - Fazer alterações (edit, bash)
+   - Validar resultados (bash com testes)
+   - Avançar a tarefa passo a passo
+
+4. **Padrão de turno correto**:
+   a) Receber tarefa e pensar (thinking)
+   b) Chamar uma ferramenta para agir
+   c) Observar resultado
+   d) Voltar ao passo (a) se precisar avançar
+
+5. **Proibido**: Terminar turno com apenas uma seção vazia de thinking.
+```
+
+## Quando Usar
+
+- ✅ Rodando **Qwen 27b/32b** via Ollama
+- ✅ Rodando **Llama** via Ollama
+- ✅ Rodando qualquer **modelo aberto local**
+- ✅ Modelo que às vezes **congela ou gera vazio**
+
+## Quando Pode Desativar
+
+- Se rodando **Claude/GPT** (APIs online)
+- Se o modelo está **funcionando bem** sem a regra
+- Quando quer testar comportamento natural
+
+Use `/ollama-tools-info` para toggle sem reiniciar.
+
+## Dicas Adicionais
+
+### Para melhor desempenho com Qwen:
+
+```bash
+# Use a versão Coder (superior para tool-calling)
+ollama pull qwen2.5-coder:32b
+
+# Rode com mais contexto
+ollama run qwen2.5-coder:32b
+```
+
+### Atualize o Ollama:
+
+Versões antigas do Ollama podem engolir chamadas de ferramenta do Qwen. Mantenha atualizado:
+
+```bash
+ollama --version
+# Se antigo, atualize
+```
+
+### Use a extensão + instruções diretas:
+
+Se o modelo ainda ficar preso, você pode também dar um empurrãozinho manualmente:
+
+```
+"Como está o andamento? Use a ferramenta de bash para verificar e continue o trabalho imediatamente."
+```
+
+## Removendo a Extensão
+
+Se quiser remover a regra permanentemente:
+
+```bash
+rm ~/.asm-agent/extensions/ollama-tool-forcing.ts
+/reload
+```
+
+## Arquivos Relacionados
+
+- **Extensão**: `~/.asm-agent/extensions/ollama-tool-forcing.ts`
+- **Documentação**: Este arquivo
+- **Comando**: `/ollama-tools-info` (dentro do ASM Agent)
+- **Reload**: `/reload` (para recarregar extensões)
+
+## Suporte
+
+Se a extensão não funcionar:
+
+1. Verifique se o arquivo está em `~/.asm-agent/extensions/`
+2. Use `/reload` para recarregar
+3. Use `/ollama-tools-info` para verificar status
+4. Verifique logs do ASM Agent para erros de compilação TypeScript
+
+---
+
+**Criado para resolver o problema de modelos abertos gerando vazios com ASM Agent.**

package/bundled-extensions/README.txt

@@ -0,0 +1,178 @@
+
+╔════════════════════════════════════════════════════════════════════════════════╗
+║                    🎉 CUSTOM RULE CRIADA E PRONTA!                            ║
+║                  Ollama Tool-Forcing Extension v1.0                            ║
+╚════════════════════════════════════════════════════════════════════════════════╝
+
+📂 LOCALIZAÇÃO:
+   ~/.asm-agent/extensions/
+
+📦 ARQUIVOS CRIADOS (5 arquivos, ~18 KB total):
+
+   1. ollama-tool-forcing.ts (3.2 KB)
+      → Extensão principal (TypeScript)
+      → Auto-descoberta pelo ASM Agent
+      → Sem dependências externas
+
+   2. OLLAMA-TOOL-FORCING.md (4.4 KB)
+      → Manual completo
+      → Explicação detalhada do problema
+      → Quando usar/não usar
+      → Dicas de otimização
+
+   3. OLLAMA-TOOL-FORCING-QUICK-START.txt (5.8 KB)
+      → Referência rápida visual
+      → Instruções em poucas linhas
+      → Próximos passos
+
+   4. OLLAMA-TOOL-FORCING-TESTS.md (4.5 KB)
+      → 5 exemplos de teste
+      → Como verificar se funciona
+      → Troubleshooting
+
+   5. OLLAMA-TOOL-FORCING-IMPLEMENTATION.md (6.5 KB)
+      → Guia de implementação
+      → Como funciona internamente
+      → Personalização avançada
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+✨ O QUE ESSA CUSTOM RULE FAZ:
+
+┌─ PROBLEMA ORIGINAL ────────────────────────────────────────────────────────┐
+│                                                                              │
+│  Você roda Qwen/Llama via Ollama com ASM Agent:                             │
+│  ❌ Modelo pensa um pouco                                                   │
+│  ❌ Modelo para (emit stop token)                                           │
+│  ❌ Modelo não chama ferramenta                                             │
+│  ❌ ASM Agent fica esperando "e aí?"                                        │
+│  ❌ Loop autônomo quebrado                                                  │
+│                                                                              │
+└────────────────────────────────────────────────────────────────────────────┘
+
+                                    ↓ SOLUÇÃO ↓
+
+┌─ COM A EXTENSÃO ──────────────────────────────────────────────────────────┐
+│                                                                             │
+│  ✅ Extensão intercepta requisição (before_agent_start)                   │
+│  ✅ Injeta regra CRÍTICA no system prompt                                 │
+│  ✅ Modelo recebe instrução forte: "NUNCA PARE SEM CHAMAR FERRAMENTA"     │
+│  ✅ Modelo é forçado a chamar bash/edit/ipython                          │
+│  ✅ Loop autônomo continua funcionando                                    │
+│  ✅ Tarefa completada sem intervenção                                     │
+│                                                                             │
+└────────────────────────────────────────────────────────────────────────────┘
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+🚀 USAR AGORA (3 PASSOS):
+
+1️⃣  NADA! A extensão já está em ~/.asm-agent/extensions/
+
+2️⃣  Próxima vez que iniciar ASM Agent:
+    - Extensão será auto-descoberta
+    - Regra será injetada automaticamente
+    - Funcionará em TODAS as requisições
+
+3️⃣  Se ASM Agent já está rodando:
+    /reload        (recarrega extensões)
+    /ollama-tools-info  (verifica status)
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+📋 REGRA INJETADA NO SYSTEM PROMPT:
+
+    ## ⚠️ REGRA CRÍTICA: TOOL-FORCING PARA MODELOS LOCAIS
+
+    1. NUNCA pare sem chamar uma ferramenta
+    2. Sem gerações vazias (só thinking não é permitido)
+    3. Ferramentas = continuidade (use bash, edit, ipython constantemente)
+    4. Padrão correto: pensar → agir → observar → repetir
+    5. Proibido: terminar turno sem chamar ferramenta
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+💻 TESTE AGORA:
+
+Cole isso no ASM Agent com seu Qwen/Llama rodando:
+
+    "Crie um arquivo 'test.txt' com conteúdo 'Olá Ollama!' e use bash 
+    para verificar que foi criado corretamente."
+
+Resultado esperado:
+    ✅ Modelo chama edit (criar arquivo)
+    ✅ Modelo chama bash (verificar)
+    ✅ Tarefa completa, sem ele ficar preso
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+📚 DOCUMENTAÇÃO:
+
+Arquivo               │ Objetivo                        │ Leia quando...
+──────────────────────┼─────────────────────────────────┼──────────────────
+OLLAMA-TOOL-FORCING.md │ Manual completo                 │ Quer detalhes
+QUICK-START.txt       │ Referência rápida               │ Quer começar logo
+TESTS.md              │ 5 exemplos de teste             │ Quer testar agora
+IMPLEMENTATION.md     │ Como funciona internamente      │ Quer customizar
+
+Todos em ~/.asm-agent/extensions/
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+⚙️  PERSONALIZAÇÃO:
+
+Quer mudar o comportamento?
+
+    Edite: ~/.asm-agent/extensions/ollama-tool-forcing.ts
+    Depois: /reload
+
+Quer desativar temporariamente?
+
+    /ollama-tools-info   (faz toggle)
+
+Quer remover permanentemente?
+
+    rm ~/.asm-agent/extensions/ollama-tool-forcing.ts
+    /reload
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+🎯 RESUMO TÉCNICO:
+
+• TYPE: Custom Rule (Extensão ASM Agent)
+• LINGUAGEM: TypeScript (compilado automaticamente)
+• TAMANHO: ~3 KB executável, impacto ZERO em performance
+• COMPATIBILIDADE: Qualquer modelo aberto (Qwen, Llama, Mistral, etc)
+• DEPENDÊNCIAS: Nenhuma (usa API nativa do ASM Agent)
+• ATIVAÇÃO: Auto-descoberta (~/.asm-agent/extensions/)
+• SCOPO: Injeta regra no system prompt (antes do modelo pensar)
+• REVERT: Pode ser desativado ou removido a qualquer hora
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+✅ CHECKLIST DE IMPLEMENTAÇÃO:
+
+☑ Extensão criada: ~/.asm-agent/extensions/ollama-tool-forcing.ts
+☑ Documentação escrita: 4 arquivos .md/.txt
+☑ Comando registrado: /ollama-tools-info
+☑ Auto-descoberta: Funcionará na próxima sessão
+☑ Exemplos de teste: OLLAMA-TOOL-FORCING-TESTS.md
+☑ Troubleshooting: Incluído em OLLAMA-TOOL-FORCING.md
+☑ Sem dependencies: 100% nativo do ASM Agent
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+🎬 PRÓXIMA AÇÃO:
+
+1. Reinicie ASM Agent (ou use /reload se já estiver rodando)
+2. Teste com uma tarefa simples
+3. Observe o modelo chamar ferramentas continuamente
+4. Aproveite o loop autônomo sem interrupções!
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+╔════════════════════════════════════════════════════════════════════════════════╗
+║                🎊 Configuração completa! Bom trabalho! 🎊                       ║
+║                   Seus modelos Ollama agora trabalham melhor                    ║
+║                         com o ASM Agent autonomamente.                          ║
+╚════════════════════════════════════════════════════════════════════════════════╝

package/bundled-extensions/ollama-tool-forcing.ts

@@ -0,0 +1,90 @@
+/**
+ * Ollama Tool-Forcing Extension
+ *
+ * Força modelos open-weights rodando via Ollama a sempre chamar uma ferramenta
+ * antes de parar, evitando que gerem apenas tokens de parada sem completar tarefas.
+ *
+ * Problema: Modelos menores (Qwen 27b, Llama, etc) às vezes apenas pensam
+ * e depois emitem um stop token sem chamar ferramentas ou gerar texto.
+ *
+ * Solução: Injeta no system prompt uma instrução forte que força o modelo a:
+ * 1. Nunca parar sem chamar uma ferramenta
+ * 2. Usar ferramentas para continuar o trabalho
+ * 3. Sempre completar o ciclo de tarefas
+ *
+ * Uso:
+ * 1. Copie este arquivo para ~/.asm-agent/extensions/ (global)
+ *    ou .asm-agent/extensions/ (projeto-local)
+ * 2. Use /reload para ativar (se em modo interativo)
+ * 3. A extensão funciona automaticamente em todas as requisições
+ *
+ * Opcional: Use /ollama-tools-info para ver o status
+ */
+
+import type { ExtensionAPI } from "@asm-agent/coding-agent";
+
+export default function ollamaToolForcingExtension(pi: ExtensionAPI) {
+	let enabled = true;
+
+	// Comando para ver status e toggle
+	pi.registerCommand("ollama-tools-info", {
+		description: "Mostra status do Ollama Tool-Forcing e permite toggle",
+		handler: async (_args, ctx) => {
+			enabled = !enabled;
+			const status = enabled ? "✅ ATIVADO" : "❌ DESATIVADO";
+			ctx.ui.notify(
+				`Ollama Tool-Forcing: ${status}\n\n` +
+				`Este modo força modelos abertos a chamar ferramentas antes de parar, ` +
+				`evitando gerações vazias que interrompem o loop autônomo do ASM Agent.`,
+				"info"
+			);
+		},
+	});
+
+	// Injetar instrução no system prompt antes de cada turno
+	pi.on("before_agent_start", async (event) => {
+		if (!enabled) {
+			return undefined;
+		}
+
+		// Instrução forte para forçar uso de ferramentas
+		const toolForceRule = \`
+
+## ⚠️ REGRA CRÍTICA: TOOL-FORCING PARA MODELOS LOCAIS
+
+Você está rodando num modelo aberto (Ollama/local). Para garantir que trabalhe autonomamente:
+
+1. **NUNCA pare sem chamar uma ferramenta**: Depois de pensar/raciocinar, você DEVE chamar
+   uma ferramenta (bash, edit, ipython, etc) para continuar o trabalho.
+
+2. **Sem gerações vazias**: Não é permitido apenas gerar um "thinking" e depois parar.
+   Se terminou um ciclo, chame uma ferramenta para validar ou avançar.
+
+3. **Ferramentas = Continuidade**: As ferramentas são como seus "pulmões". Use-as para:
+   - Verificar status (bash, ipython)
+   - Fazer alterações (edit, bash)
+   - Validar resultados (bash com testes)
+   - Avançar a tarefa passo a passo
+
+4. **Padrão de turno correto**:
+   a) Receber tarefa e pensar (thinking)
+   b) Chamar uma ferramenta para agir
+   c) Observar resultado
+   d) Voltar ao passo (a) se precisar avançar
+
+5. **Proibido**: Terminar turno com apenas:
+   - Uma seção de "thinking" vazia
+   - Sem nenhuma tool call
+   - Sem texto de resposta
+   
+   Se não tiver nada para fazer, ainda assim chame bash ou ipython para verificar status.
+
+ESSA REGRA SE APLICA SEMPRE. Sem exceções. Modelos menores têm tendência de "congelar"
+se deixados livres — use ferramentas constantemente para manter-se "vivo".
+\`;
+
+		return {
+			systemPrompt: event.systemPrompt + toolForceRule,
+		};
+	});
+}

package/dist/asm-agent-runtime/run_test.py

@@ -0,0 +1,19 @@
+import asyncio
+import os
+import sys
+import unittest
+import logging
+from test.test_bash import BashTest
+
+class CustomTestResult(unittest.TextTestResult):
+    def addFailure(self, test, err):
+        super().addFailure(test, err)
+        print("\n=== FAILURE DETAILS ===")
+        print(f"Failed test: {test.id()}")
+        print(f"Error: {err}")
+
+if __name__ == '__main__':
+    suite = unittest.TestSuite()
+    suite.addTest(BashTest("test_undelivered_kill_leaves_journal_record_active"))
+    runner = unittest.TextTestRunner(resultclass=CustomTestResult)
+    runner.run(suite)

package/dist/asm-agent-runtime/test/test_bash.py

@@ -1121,12 +1121,12 @@ class BashTest(unittest.IsolatedAsyncioTestCase):
             ):
                 handle = bash("sleep 30")
                 try:
-                    records = await _poll_journal(journal, count=1)
+                    records = await _poll_journal(journal, count=1, pid=handle.pid)
                     self.assertTrue(records[-1]["active"])
                     with mock.patch.object(bash_module, "_signal_group", return_value=False):
                         bash_module._kill_live_handles()
                     await asyncio.sleep(0.2)  # give any (wrong) inactive write time to land
-                    records = await _poll_journal(journal, count=1)
+                    records = await _poll_journal(journal, count=1, pid=handle.pid)
                     self.assertEqual(len(records), 1)
                     self.assertTrue(records[-1]["active"])
                 finally:
@@ -1260,12 +1260,14 @@ async def _poll_group_dead(pgid: int, timeout: float = 5.0) -> None:
     raise AssertionError(f"process group {pgid} still alive after {timeout}s")
 
 
-async def _poll_journal(path: str, count: int, timeout: float = 2.0) -> list[dict]:
+async def _poll_journal(path: str, count: int, timeout: float = 2.0, pid: int | None = None) -> list[dict]:
     deadline = asyncio.get_running_loop().time() + timeout
     records: list[dict] = []
     while asyncio.get_running_loop().time() < deadline:
         with open(path) as f:
             records = [json.loads(line) for line in f if line.strip()]
+        if pid is not None:
+            records = [r for r in records if r.get("pid") == pid]
         if len(records) >= count:
             return records
         await asyncio.sleep(0.05)

package/dist/bundle/{anthropic-2VRH36LG.js → anthropic-MHZBPOI3.js}

@@ -17,7 +17,7 @@ import {
 } from "./chunk-2T7M7VJ4.js";
 import {
   getEnvApiKey
-} from "./chunk-6GUVYK6P.js";
+} from "./chunk-EBIKTZ7C.js";
 import {
   StreamFailureError,
   classifyStreamFailure,

package/dist/bundle/{azure-openai-responses-COYWHJPT.js → azure-openai-responses-STVL56NS.js}

@@ -14,7 +14,7 @@ import {
 import "./chunk-2T7M7VJ4.js";
 import {
   getEnvApiKey
-} from "./chunk-6GUVYK6P.js";
+} from "./chunk-EBIKTZ7C.js";
 import {
   formatStreamFailureMessage,
   recordStreamFailure,

package/dist/bundle/{bundled-modules-N3FE2F3V.js → bundled-modules-ABB56VC3.js}

@@ -52,7 +52,7 @@ import {
   oauth_exports,
   runPrintMode,
   runRpcMode
-} from "./chunk-ZFAQZSZL.js";
+} from "./chunk-GUPU2EEK.js";
 import {
   AgentSession,
   CURRENT_SESSION_VERSION,
@@ -136,7 +136,7 @@ import {
   withFileMutationQueue,
   wrapRegisteredTool,
   wrapRegisteredTools
-} from "./chunk-LRHUL5TM.js";
+} from "./chunk-NESKY6T7.js";
 import "./chunk-VWR3YFK5.js";
 import "./chunk-N2CSAETN.js";
 import "./chunk-5QCJ5DQU.js";
@@ -147,7 +147,7 @@ import {
 import "./chunk-2T7M7VJ4.js";
 import "./chunk-UIRUOAIQ.js";
 import "./chunk-HXOBFFJX.js";
-import "./chunk-6GUVYK6P.js";
+import "./chunk-EBIKTZ7C.js";
 import "./chunk-UPDAFKL5.js";
 import "./chunk-US4QGESM.js";
 import {

package/dist/bundle/{chunk-6GUVYK6P.js → chunk-EBIKTZ7C.js}

@@ -78,6 +78,7 @@ function getApiKeyEnvVars(provider) {
     "prime-inference": "PRIME_API_KEY",
     deepseek: "DEEPSEEK_API_KEY",
     google: "GEMINI_API_KEY",
+    gemini: "GEMINI_API_KEY",
     "google-vertex": "GOOGLE_CLOUD_API_KEY",
     groq: "GROQ_API_KEY",
     cerebras: "CEREBRAS_API_KEY",