@dotrino/ia-agent 0.2.0 → 0.3.1

package/drivers/claude.js

@@ -1,13 +1,13 @@
 /**
- * drivers/claude.js — invoca la CLI `claude` (Claude Code) en modo headless.
+ * drivers/claude.js — invoca la CLI `claude` (Claude Code) con STREAMING real.
  *
- * F1: NO streaming. Lanza `claude -p "<texto>" --output-format json [--resume <sid>]`
- * y devuelve el resultado completo cuando termina (igual que dotrino-telegram-claude-bot).
- * F2 migrará esto al SDK (@anthropic-ai/claude-code) con onToken para streaming real.
+ * F2: usa `--output-format stream-json --verbose` y parsea los eventos NDJSON que
+ * Claude re-emite del streaming de Anthropic. Los `content_block_delta` /
+ * `text_delta` son los tokens ⇒ los pasamos a `onToken` conforme se generan.
+ * El evento `result` final da `session_id`, `usage` y el texto completo (fallback).
  *
- * Memoria de sesión: guarda el `session_id` que devuelve Claude y lo pasa como
- * `--resume` en la siguiente vuelta (hilo continuo). Si la sesión se invalida,
- * arranca una nueva.
+ * Memoria de sesión: `--resume <sid>` con el `session_id` del `result`. Si la sesión
+ * se invalida, arranca una nueva. Mismo patrón que dotrino-telegram-claude-bot.
  */
 import { spawn } from 'node:child_process'
 import { dirname } from 'node:path'
@@ -18,10 +18,10 @@ const EXTRA_PATH = [dirname(process.execPath), `${process.env.HOME || ''}/.local
 export class ClaudeDriver {
   /**
    * @param {object} opts
-   * @param {string} [opts.cwd]      directorio donde opera Claude (el proyecto). Default process.cwd().
-   * @param {string} [opts.bin='claude']  binario a invocar.
-   * @param {string[]} [opts.flags=[]]    flags extra (p. ej. ['--dangerously-skip-permissions'] para yolo).
-   * @param {number} [opts.timeoutMs=0]   0 = sin límite.
+   * @param {string} [opts.cwd]         directorio donde opera Claude (el proyecto).
+   * @param {string} [opts.bin='claude']
+   * @param {string[]} [opts.flags=[]]  flags extra (p. ej. '--dangerously-skip-permissions').
+   * @param {number} [opts.timeoutMs=0] 0 = sin límite.
    */
   constructor ({ cwd, bin = 'claude', flags = [], timeoutMs = 0 } = {}) {
     this.cwd = cwd || process.cwd()
@@ -31,62 +31,98 @@ export class ClaudeDriver {
     this.sessionId = null
   }
 
-  /** Envía un mensaje y devuelve { text, sessionId, tokens } cuando termina. */
-  async send (text) {
-    let out
+  /**
+   * Envía un mensaje. `onToken(text)` recibe los tokens conforme se generan.
+   * Devuelve { text, sessionId, tokens } al terminar.
+   */
+  async send (text, { onToken } = {}) {
     try {
-      out = await this._run(this._args(text, this.sessionId))
+      return await this._send(text, this.sessionId, onToken)
     } catch (e) {
       // Sesión inválida/inexistente → empezar una nueva en vez de fallar.
       if (this.sessionId && /no conversation found|session/i.test(e.message || '')) {
         this.sessionId = null
-        out = await this._run(this._args(text, null))
-      } else throw e
+        return this._send(text, null, onToken)
+      }
+      throw e
     }
-    let result = out, sid = this.sessionId, tokens = 0
-    try {
-      const j = JSON.parse(out)
-      result = (j.result ?? out)
-      sid = j.session_id || sid
-      tokens = contextTokens(j)
-    } catch {}
-    if (sid) this.sessionId = sid
-    return { text: String(result || '(sin respuesta)'), sessionId: sid, tokens }
   }
 
-  _args (text, sid) {
-    const args = ['-p', text, '--output-format', 'json', ...this.flags]
+  async _send (text, sid, onToken) {
+    const args = ['-p', text, '--output-format', 'stream-json', '--verbose', ...this.flags]
     if (sid) args.push('--resume', sid)
-    return args
+
+    let streamed = ''
+    let finalEv = null
+    let stderrText = ''
+
+    await this._runStream(args, {
+      onLine (line) {
+        let ev
+        try { ev = JSON.parse(line) } catch { return }
+        // Streaming real: deltas de texto del modelo (Anthropic content_block_delta).
+        const se = ev.event
+        if (ev.type === 'stream_event' && se?.type === 'content_block_delta' && se.delta?.type === 'text_delta' && se.delta.text) {
+          streamed += se.delta.text
+          onToken?.(se.delta.text)
+          return
+        }
+        // Resultado final: session_id + usage (+ result como fallback de texto).
+        if (ev.type === 'result') finalEv = ev
+      },
+      onStderr (d) { stderrText += d }
+    })
+
+    let out = streamed
+    let nextSid = sid
+    let tokens = 0
+    if (finalEv) {
+      if (!out && finalEv.result) out = String(finalEv.result)          // fallback: respuesta completa
+      if (finalEv.session_id) nextSid = finalEv.session_id
+      tokens = contextTokens(finalEv)
+    }
+    if (!out) {
+      if (finalEv?.is_error) throw new Error(String(finalEv.result || 'claude reportó un error'))
+      if (stderrText) throw new Error(stderrText.slice(0, 500))
+      throw new Error('claude no devolvió respuesta')
+    }
+    if (nextSid) this.sessionId = nextSid
+    return { text: out, sessionId: nextSid, tokens }
   }
 
-  _run (args) {
+  _runStream (args, { onLine, onStderr }) {
     return new Promise((resolve, reject) => {
-      // stdin cerrado para que `claude -p` no espere por él.
       const p = spawn(this.bin, args, {
         cwd: this.cwd,
         stdio: ['ignore', 'pipe', 'pipe'],
         env: { ...process.env, PATH: `${process.env.PATH || ''}:${EXTRA_PATH}` }
       })
-      let out = '', err = ''
-      p.stdout.on('data', (d) => { out += d })
-      p.stderr.on('data', (d) => { err += d })
+      let buf = ''
+      p.stdout.setEncoding('utf8')
+      p.stdout.on('data', (d) => {
+        buf += d
+        const lines = buf.split('\n')
+        buf = lines.pop()                         // último fragmento (posiblemente incompleto)
+        for (const ln of lines) if (ln.trim()) onLine(ln)
+      })
+      let errBuf = ''
+      p.stderr.on('data', (d) => { errBuf += d; onStderr?.(d) })
       const to = this.timeoutMs > 0
         ? setTimeout(() => { try { p.kill('SIGKILL') } catch {}; reject(new Error('timeout')) }, this.timeoutMs)
         : null
       p.on('error', (e) => { if (to) clearTimeout(to); reject(new Error(`no se pudo ejecutar '${this.bin}' (¿instalado y en PATH?): ${e.message}`)) })
       p.on('close', (code) => {
         if (to) clearTimeout(to)
-        if (code === 0) resolve(out)
-        else reject(new Error(err.slice(0, 500) || `claude salió con código ${code}`))
+        // stream-json puede escribir su 'result' final y salir 0; errores no cero ⇒ rechazar.
+        if (code === 0 || code === null) resolve()
+        else reject(new Error(errBuf.slice(0, 500) || `claude salió con código ${code}`))
       })
     })
   }
 }
 
-/** Tamaño aproximado del contexto de la última vuelta (tokens enviados). */
-function contextTokens (j) {
-  const u = j && j.usage
+function contextTokens (ev) {
+  const u = ev && ev.usage
   if (!u) return 0
   return (u.input_tokens || 0) + (u.cache_read_input_tokens || 0) + (u.cache_creation_input_tokens || 0)
 }

package/index.js

@@ -4,8 +4,9 @@
  * Expone tus CLIs de IA (Claude, OpenCode…) al chat remoto, sobre
  * `@dotrino/remote-agent` (handshake E2E, emparejamiento con vault, revocación).
  *
- * F1: driver Claude (no-streaming) — `claude -p --output-format json --resume`.
- * F2: migrar a SDK con streaming de tokens. F4: driver OpenCode.
+ * F2: driver Claude con STREAMING real (stream-json). Los tokens del modelo se
+ * reenvían al cliente como mensajes `ia.tok` (batcheados ~60 ms para no saturar el
+ * proxy) y el cierre como `ia.done`. F4: driver OpenCode.
  *
  * Configuración (env):
  *   IA_CWD         directorio donde opera Claude (default: el cwd al lanzar).
@@ -34,11 +35,26 @@ export async function startIaAgent (opts = {}) {
       const driver = new ClaudeDriver({ cwd: CWD, bin: CLAUDE_BIN, flags: CLAUDE_FLAGS, timeoutMs: CLAUDE_TIMEOUT })
       session.on('message', async (msg) => {
         if (msg?.type !== 'msg' || typeof msg.text !== 'string') return
+
+        // Batch de tokens (~60 ms): el rate-limit del proxy es discreto; sin batch,
+        // una ráfaga de deltas saturaría. Flush al final siempre.
+        let buf = ''
+        let timer = null
+        const flush = () => { timer = null; if (buf) { const t = buf; buf = ''; session.send({ type: 'tok', text: t }).catch(() => {}) } }
+
         try {
-          const r = await driver.send(msg.text)
-          await session.send({ type: 'done', text: r.text, sessionId: r.sessionId, tokens: r.tokens })
+          const r = await driver.send(msg.text, {
+            onToken: (tok) => {
+              buf += tok
+              if (!timer) timer = setTimeout(flush, 60)
+            }
+          })
+          if (timer) { clearTimeout(timer); timer = null }
+          if (buf) { const t = buf; buf = ''; await session.send({ type: 'tok', text: t }) }
+          await session.send({ type: 'done', sessionId: r.sessionId, tokens: r.tokens })
         } catch (e) {
-          await session.send({ type: 'error', message: e.message })
+          if (timer) clearTimeout(timer)
+          await session.send({ type: 'error', message: e.message }).catch(() => {})
         }
       })
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/ia-agent",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Agente de Dotrino IA: expone tus CLIs de IA (Claude, OpenCode) al chat remoto de ia.dotrino.com, vía @dotrino/remote-agent.",
   "type": "module",
   "bin": {
@@ -18,7 +18,7 @@
     "start": "node bin/cli.js run"
   },
   "dependencies": {
-    "@dotrino/remote-agent": "^0.1.0"
+    "@dotrino/remote-agent": "^0.2.0"
   },
   "engines": {
     "node": ">=18"