beast-agent 0.25.6 → 0.25.8

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "beast-agent",
     "productName": "Beast Agent",
-    "version": "0.25.6",
+    "version": "0.25.8",
     "description": "Ultra-fast local agent shell for Windows.",
     "author": "algokodcom (AlgoKod)",
     "license": "MIT",

package/src/agent/bots.js

@@ -327,6 +327,14 @@ function update(id, patch) {
       changes.push('dış tarayıcı komutu güncellendi');
       b.extCommand = String(patch.extCommand).slice(0, 200);
     }
+    if (typeof patch.model === 'string') {
+      /* bot bazlı model override — boş string = global seçim */
+      const next = patch.model.trim().slice(0, 160);
+      if (next !== (b.model || '')) {
+        changes.push('model güncellendi');
+        b.model = next;
+      }
+    }
     if (Array.isArray(patch.plugins)) {
       const next = [...new Set(patch.plugins.map((p) => String(p).slice(0, 40)).filter((p) => PLUGIN_LIST.includes(p)))];
       if (JSON.stringify(next) !== JSON.stringify(b.plugins || [])) {

package/src/agent/discord.js

@@ -0,0 +1,234 @@
+'use strict';
+
+/* DISCORD KÖPRÜSÜ — Telegram köprüsünün Discord hali.
+   Bağımlılık: yalnızca `ws` (paket zaten kurulu — baileys ile geliyor).
+   - Gateway WebSocket: Identify → READY → MESSAGE_CREATE dispatch
+   - REST (api/v10): mesaj gönderme (2000 karakter sınırında bölerek)
+   - Sunucu (guild) mesajlarında yalnız @mention'a cevap verilir (spam koruması);
+     DM'de her izinli kullanıcıya cevap verilir.
+   - Bağlantı koparsa backoff ile yeniden bağlanır (yeniden Identify;
+     çevrimdışıyken gelen mesajlar backfill edilmez — Telegram long-poll'un aksine).
+   ÖNEMLİ: Discord Developer Portal'da bot için "MESSAGE CONTENT INTENT"
+   açılmalıdır — yoksa mesaj içerikleri boş gelir. */
+
+const WebSocket = require('ws');
+const https = require('https');
+
+const API_BASE = 'https://discord.com/api/v10';
+const GATEWAY_URL = 'wss://gateway.discord.gg/?v=10&encoding=json';
+const SEND_CHUNK = 1900; // Discord mesaj sınırı 2000 — güvenli pay
+/* GUILDS(1) | GUILD_MESSAGES(512) | DIRECT_MESSAGES(4096) | MESSAGE_CONTENT(32768) */
+const INTENTS = 1 | 512 | 4096 | 32768;
+
+class DiscordBridge {
+  constructor({ token, emit, onIncoming }) {
+    this.token = String(token || '').trim();
+    this.emit = emit || (() => {});
+    this.onIncoming = onIncoming || null;
+    this.connected = false;
+    this.stopping = false;
+    this.status = 'disconnected';
+    this.user = null; // { id, username, ... }
+    this._ws = null;
+    this._hbTimer = null;
+    this._seq = null;
+    this._backoff = 2000;
+  }
+
+  _setStatus(status, user) {
+    this.status = status;
+    this.connected = status === 'connected';
+    this.emit({ type: 'status', status, user: user || null });
+  }
+
+  /* REST çağrısı — JSON (token: "Bot <token>") */
+  api(method, path, body) {
+    return new Promise((resolve, reject) => {
+      const payload = body ? JSON.stringify(body) : null;
+      const req = https.request(
+        `${API_BASE}${path}`,
+        {
+          method,
+          headers: {
+            'Content-Type': 'application/json',
+            Authorization: 'Bot ' + this.token,
+            ...(payload ? { 'Content-Length': Buffer.byteLength(payload) } : {}),
+          },
+          timeout: 15000,
+        },
+        (res) => {
+          let data = '';
+          res.setEncoding('utf8');
+          res.on('data', (c) => (data += c));
+          res.on('end', () => {
+            try {
+              const j = data ? JSON.parse(data) : null;
+              if (res.statusCode >= 200 && res.statusCode < 300) resolve(j);
+              else reject(new Error(`discord ${path}: HTTP ${res.statusCode} ${(j && j.message) || ''}`.trim()));
+            } catch {
+              reject(new Error(`discord ${path}: bozuk yanıt`));
+            }
+          });
+        }
+      );
+      req.on('timeout', () => req.destroy(new Error('zaman aşımı')));
+      req.on('error', reject);
+      if (payload) req.write(payload);
+      req.end();
+    });
+  }
+
+  async start() {
+    if (!this.token) {
+      this._setStatus('error');
+      return false;
+    }
+    this.stopping = false;
+    this._setStatus('connecting');
+    try {
+      const me = await this.api('GET', '/users/@me');
+      this.user = me; // { id, username, ... }
+      this._setStatus('connected', '@' + (me.username || 'bot'));
+    } catch (e) {
+      this._setStatus('error');
+      throw e;
+    }
+    this._connect();
+    return true;
+  }
+
+  _connect() {
+    if (this.stopping) return;
+    clearInterval(this._hbTimer);
+    this._hbTimer = null;
+    let identified = false;
+    const ws = new WebSocket(GATEWAY_URL);
+    this._ws = ws;
+
+    ws.on('message', (raw) => {
+      let p = null;
+      try { p = JSON.parse(String(raw)); } catch { return; }
+      const op = p.op;
+      const d = p.d;
+      const t = p.t;
+      if (typeof p.s === 'number') this._seq = p.s;
+
+      if (op === 10) {
+        /* Hello: heartbeat aralığı gelıyor → hafif erken at (güvenli pay) */
+        const iv = (d && d.heartbeat_interval) || 41250;
+        clearInterval(this._hbTimer);
+        this._hbTimer = setInterval(() => {
+          try {
+            if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({ op: 1, d: this._seq }));
+          } catch {}
+        }, Math.max(5000, Math.floor(iv * 0.8)));
+        if (!identified) {
+          identified = true;
+          try {
+            ws.send(
+              JSON.stringify({
+                op: 2,
+                d: {
+                  token: this.token,
+                  intents: INTENTS,
+                  properties: { os: 'windows', browser: 'beast-agent', device: 'beast-agent' },
+                },
+              })
+            );
+          } catch {}
+        }
+        return;
+      }
+      if (op === 1) {
+        /* sunucu heartbeat istedi — hemen at */
+        try {
+          if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({ op: 1, d: this._seq }));
+        } catch {}
+        return;
+      }
+      if (op === 9 || op === 7) {
+        /* invalid session / reconnect isteği — kapat, close handler yeniden bağlanır */
+        try { ws.close(); } catch {}
+        return;
+      }
+      if (op === 0 && t === 'READY') {
+        this._backoff = 2000;
+        this._setStatus('connected', '@' + ((d && d.user && d.user.username) || 'bot'));
+        return;
+      }
+      if (op === 0 && t === 'MESSAGE_CREATE' && this.onIncoming) {
+        try {
+          const m = d || {};
+          if (!m.author || m.author.bot || m.webhook_id) return;
+          let text = String(m.content || '').trim();
+          if (!text) return;
+          const botId = this.user && this.user.id;
+          const mentioned = !!(botId && text.includes('<@' + botId + '>'));
+          if (botId) text = text.split('<@' + botId + '>').join(' ').replace(/\s+/g, ' ').trim();
+          const payload = {
+            text: text.slice(0, 6000),
+            senderId: String((m.author && m.author.id) || ''),
+            username: String((m.author && m.author.username) || ''),
+            senderName: String((m.author && (m.author.global_name || m.author.username)) || ''),
+            isGroup: !!m.guild_id,
+            mentioned,
+            channelId: String(m.channel_id || ''),
+          };
+          if (!payload.channelId) return;
+          /* Sunucu mesajlarında yalnız @mention (spam koruması); DM'de hepsi */
+          if (payload.isGroup && !mentioned) return;
+          this.onIncoming(payload.channelId, payload);
+        } catch {}
+        return;
+      }
+    });
+
+    ws.on('close', () => {
+      clearInterval(this._hbTimer);
+      this._hbTimer = null;
+      if (this.stopping) return;
+      this._setStatus('connecting');
+      const wait = this._backoff;
+      this._backoff = Math.min(30000, this._backoff * 2);
+      setTimeout(() => this._connect(), wait);
+    });
+
+    ws.on('error', () => {
+      /* close tetiklenir — yeniden bağlanma orada */
+    });
+  }
+
+  async stop() {
+    this.stopping = true;
+    clearInterval(this._hbTimer);
+    this._hbTimer = null;
+    try {
+      if (this._ws) this._ws.close();
+    } catch {}
+    this._ws = null;
+    this.connected = false;
+    this.status = 'disconnected';
+  }
+
+  snapshot() {
+    return {
+      status: this.status,
+      user: this.user ? '@' + (this.user.username || 'bot') : null,
+      connected: this.connected,
+    };
+  }
+
+  /* Metin gönder — 2000 karakter sınırı için parçalara böl */
+  async send(channelId, text) {
+    const t = String(text || '');
+    if (!t.trim() || !channelId) return false;
+    const chunks = [];
+    for (let i = 0; i < t.length; i += SEND_CHUNK) chunks.push(t.slice(i, i + SEND_CHUNK));
+    for (const part of chunks) {
+      await this.api('POST', `/channels/${channelId}/messages`, { content: part });
+    }
+    return true;
+  }
+}
+
+module.exports = { DiscordBridge };

package/src/agent/engine.js

@@ -35,9 +35,10 @@ const SUP_IDLE_MIN = 2; // ...bu kadar süredir hiç aktivite yoksa TAKILDI
 const SUP_LONG_MIN = 6; // bu kadar süredir koşuyorsa ara kontrol nödü
 const SUP_NUDGE_COOLDOWN_MIN = 4; // aynı iş için iki uyarı arası min süre
 const BG_FIX_MAX = 2; // paralel ajanın otomatik öz-kurtarma hakkı (bitince CEO devreye girer)
-/* Zarif bitirme: iş BU sürede bitmezse ajan artık yeni araştırma yapmaz,
-   elindekiyle SON RAPORU yazar ve düzgün biter — "görev bitmeden patlama" yok */
-const BG_WRAP_MIN = 4;
+/* SÜRE SINIRI YOK: bg ajanlar dakika bazında kesilmez. Sonsuz döngü koruması
+   üç katmanla sağlanır: 1) aktivite yoksa öz-kurtarma + CEO (stuck denetimi),
+   2) MAX_TURNS sert tur tavanı, 3) tur limitine yaklaşınca zarif "raporu yaz"
+   uyarısı (_run içinde). Dakika bazlı wrap-up KALDIRILDI (BG_WRAP_MIN). */
 /* #5 hız: eşzamanlı arka plan LLM turu sınırı — rate-limit yemeden maksimum paralellik */
 const BG_MAX_CONCURRENT_DEFAULT = 4;
 /* #17 kalıcı başarısızlıkta owner'a anlık uyarı */
@@ -203,6 +204,7 @@ class Engine {
     this.lockdown = !!opts.lockdown; // varsayılan kısıt (oturum bazlı override edilmezse)
     this.sessionPerm = new Map(); // sessionId -> ['web'] | ['web','read'] | ['chat'] (kişi/bot bazlı izin)
     this.sessionTools = new Map(); // sessionId -> Set(araç adları) — bot skill kısıtı
+    this.sessionModel = new Map(); // sessionId -> chain entry — bot bazlı model override (setSessionModel)
     this.resolveBot = opts.resolveBot || null; // botId -> bot bilgisi (main enjekte eder)
     /* bot oturumu hafıza köprüsü: botun kendi SOUL/USER/MEMORY dosyaları */
     this.botMemory = opts.botMemory || null;
@@ -334,6 +336,16 @@ class Engine {
     else this.sessionTools.delete(id);
   }
 
+  /* BOT MODEL OVERRIDE: her bot farklı model kullanabilir (sel boşsa global seçim).
+     sel biçimi: 'providerId::model' — zincirde yoksa sessizce global'e düşer. */
+  setSessionModel(sessionId, sel) {
+    const id = String(sessionId || '');
+    if (!id) return;
+    const resolved = sel ? this._resolve(String(sel)) : null;
+    if (resolved) this.sessionModel.set(id, resolved);
+    else this.sessionModel.delete(id);
+  }
+
   /* Oturumun bağlı olduğu MÜŞTERİ botu (admin/seasız → null → global hafıza) */
   _sessionBotCtx(session) {
     if (!session || !session.botId || typeof this.resolveBot !== 'function') return null;
@@ -1286,7 +1298,8 @@ class Engine {
                     'Kullanıcı kalıcı bir arka plan takibi isterse (fiyat eşiği, pil seviyesi, sayfa değişikliği) watcher_add ile izleyici kur; kurduktan sonra watcher_list ile doğrula ve kullanıcıya koşulu + kontrol sıklığını kısaca bildir.',
           'Anlık olay takipleri için (yeni mail, fiyat eşiği, dosya değişimi, webhook) event_subscribe kullan — cron/polling gerekmez; listeyi event_list ile göster, vazgeçirirse event_unsubscribe.',
         'Kullanıcı "artık hep böyle yap / bunu unutma" tarzı kalıcı talimat verirse kural olarak kaydet: sohbette /rule <metin> kullanmasını söyle VEYA kullanıcı isterse event_subscribe ile olaya bağlan (mail/fiyat/dosya/webhook).',
-          'Kullanıcının mesajında 2+ ayrı iş/hedef varsa (örn "X yap ve sonra Y\u2019i kontrol et") KODLAMAYA/İŞE BAŞLAMADAN önce todo_write ile plan çıkar ve sırayla yürüt; her adımı tamamlarken güncelle.',
+          'Kullanıcının mesajında 2+ ayrı iş/hedef varsa (örn "X yap ve sonra Y\u2019i kontrol et") KODLAMAYA/İŞE BAŞLAMADAN önce todo_write ile plan çıkar ve sırayla yürüt; her adımı tamamlarken güncelle. LİSTE DİSİPLİNİ: her adım bittiği AN status:"done" yap; son cevabını vermeden önce tüm maddeler done olmalı — yapılmayacaksa listeden düş. Listeyi yarım bırakma.',
+          'HIZ KURALI: Bağımsız işleri AYNI turda birden çok tool_calls ile PARALEL ver. Küçük işleri tek tek çağırma — her ayrı araç turu 5-15 sn LLM gecikmesidir: 3+ küçük komutu TEK run_command\u2019te `;` ile zincirle (örn `git status; node -v; dir`), döngülü/çoklu işleri TEK python_run betiğinde topla, çok dosyalık değişikliği TEK script ile yap. Her küçük işlem için ayrı araç çağrısı açmak yavaşlığın 1 numaralı sebebidir.',
           this.ceoMode
             ? 'Bağımsız alt-işleri run_background ile PARALEL ajana devret; işi KENDİN YÜRÜTME — emri ver, takip et, raporla.'
             : 'Bağımsız alt-işleri delegate_task ile devret; kendi başına halledebileceğin işleri devretme.',
@@ -1910,7 +1923,7 @@ class Engine {
     job.lastActivityAt = nowIso();
   }
 
-  /* Saf sınıflandırma (test edilebilir): null | 'stuck' | 'wrapup' | 'long' */
+  /* Saf sınıflandırma (test edilebilir): null | 'stuck' | 'long' */
   static superviseReason(job, nowMs) {
     if (!job || job.status !== 'running') return null;
     const started = Date.parse(job.startedAt || '') || nowMs;
@@ -1922,7 +1935,6 @@ class Engine {
       : Infinity;
     if (nudgedMin < SUP_NUDGE_COOLDOWN_MIN) return null; // yeni uyardık — boğmayalım
     if (runMin >= SUP_STUCK_START_MIN && idleMin >= SUP_IDLE_MIN) return 'stuck';
-    if (!job.wrapAt && runMin >= BG_WRAP_MIN) return 'wrapup';
     if (runMin >= SUP_LONG_MIN) return 'long';
     return null;
   }
@@ -1939,11 +1951,6 @@ class Engine {
         this._bgSelfHeal(job, now);
         continue;
       }
-      /* zarif bitirme: süre dolunca yeni araştırma yasak → SON RAPORU yazsın */
-      if (reason === 'wrapup') {
-        this._bgWrapUp(job, now);
-        continue;
-      }
       job.lastNudgeAt = nowIso();
       job.checks = (job.checks || 0) + 1;
       const det = this.bgDetail(job.id);
@@ -1982,24 +1989,6 @@ class Engine {
     this._bgKick(job, text);
   }
 
-  /* Zarif bitirme: süre dolunca ajanı kesip SON RAPORU yazmasını iste.
-     Uzatma yok, öldürme yok — mevcut bulgularla düzgün kapanış. */
-  _bgWrapUp(job, now) {
-    job.wrapAt = nowIso();
-    job.lastNudgeAt = nowIso();
-    job.checks = (job.checks || 0) + 1;
-    const runMin = Math.max(1, Math.round((now - Date.parse(job.startedAt)) / 60000));
-    const det = this.bgDetail(job.id);
-    const tail = det.ok && det.messages.length ? det.messages.slice(-3).join('\n') : '';
-    const text =
-      `[SÜRE UYARISI] "${job.title}" görevi ${runMin} dk'dır sürüyor — süre doldu.\n` +
-      `YENİ arama/fetch/sayfa açma YAPMA. Şu ana kadar bulduklarınla SON RAPORU şimdi yaz:\n` +
-      `- 3-5 madde: net sonuç + yapılamayanlar açıkça "bulunamadı" diye.\n` +
-      `Raporu yazınca görev tamamlanır — fazladan tur harcama.` +
-      (tail ? `\n\nSon çıktın:\n${tail}` : '');
-    this._bgKick(job, text);
-  }
-
   /* Arka plan oturumuna müdahale: asılı turu kes (ctrl.abort), sonra
       kurtarma mesajını bas. abort → eski _run sonlanır → send yeni tur açar.
       revive bayrağı: /stop veya silme sonrası bekleyen müdahaleler patlamasın. */
@@ -2225,6 +2214,11 @@ class Engine {
       role = 'terminal';
     }
     let sel = this.modelFor(role);
+    /* bot model override: rol modeli (vision/terminal) yoksa botun kendi seçimi kazanır */
+    if (!role) {
+      const ssel = this.sessionModel.get(String(session.id));
+      if (ssel) sel = ssel;
+    }
     if (role && this.roleModels[role]) {
       emitSafe(this, session.id, { type: 'status', status: `rol: ${role} → ${sel.providerName} · ${sel.model}` });
     }
@@ -2288,9 +2282,26 @@ class Engine {
     const sid = session.id;
     const emit = (ev) => this.emit({ ...ev, sessionId: sid });
     try {
-      if (!this.sel) throw new Error('Model yapılandırılmadı — %APPDATA%\\beast\\config.yaml ve .env kontrol et');
+      if (!this.sel && !this.sessionModel.get(String(session.id))) throw new Error('Model yapılandırılmadı — %APPDATA%\\beast\\config.yaml ve .env kontrol et');
 
+      let nudged = false; // görev listesi disiplini: run başına en fazla 1 hatırlatma
+      let wrapNudged = false; // tur limitine yaklaşınca zarif kapanış (bg ajanlar)
       for (let turn = 0; turn < MAX_TURNS; turn++) {
+        /* SÜRE SINIRI YOK — ama sonsuz tur da yok: bg ajan son 3 tura gelirken
+           "raporu yaz ve bitir" uyarısı alır; MAX_TURNS sert tavan olarak kalır. */
+        if (session.bgJob && turn === MAX_TURNS - 3 && !wrapNudged) {
+          wrapNudged = true;
+          const wmsg = {
+            role: 'user',
+            content:
+              '[TUR LİMİTİ YAKLAŞIYOR] Kalın son turlar: yeni araştırma/iş AÇMA — şu ana kadarki bulgularınla SON RAPORU yaz ve bitir. Yapılamayanları açıkça "bulunamadı" diye belirt.',
+          };
+          session.messages.push(wmsg);
+          try {
+            this._append(session, wmsg);
+          } catch {}
+          emit({ type: 'message', message: wmsg });
+        }
         this._bgTrim(session); // #21 bg geçmişini olabildiğince ince tut
         emit({ type: 'status', status: 'thinking' });
         const res = await this._chatTurn(session, ctrl.signal, (delta) =>
@@ -2306,6 +2317,27 @@ class Engine {
         emit({ type: 'message', message: assistant });
 
         if (!res.toolCalls || !res.toolCalls.length) {
+          /* GÖREV LİSTESİ DİSİPLİNİ: ajan işi bitti sanıyor ama listede hâlâ
+             bekleyen/aktif madde varsa BİR KEZ hatırlat ve tura devam et —
+             liste ya tamamlanmalı ya kalan maddeler listeden düşürülmeli. */
+          const todos = session.todos || this.todos.get(sid) || [];
+          const pending = todos.filter((t) => t && t.status !== 'done');
+          if (pending.length && !nudged) {
+            nudged = true;
+            const nudge = {
+              role: 'user',
+              content:
+                '[OTOMATİK HATIRLATMA] Görev listende hâlâ tamamlanmamış maddeler var: ' +
+                pending.map((t) => '"' + t.title + '"').join(', ') +
+                '. Görevi yarım bırakma: eksik adımları ŞİMDİ tamamla; gerçekten yapılmayacaksa listeden düş. todo_write ile listeyi güncelle (status:"done") ve işi kapat.',
+            };
+            session.messages.push(nudge);
+            try {
+              this._append(session, nudge);
+            } catch {}
+            emit({ type: 'message', message: nudge });
+            continue;
+          }
           /* cevap tamam → done HEMEN: kullanıcı beklemeden yeni iş yazabilsin.
              Not/memory/skill bakımı artık arka planda (_postRunHousekeeping). */
           this._clearCrash();
@@ -3282,7 +3314,7 @@ const TOOLS = [
     function: {
       name: 'todo_write',
       description:
-        'Replace the visible task checklist for this chat. Use ONLY for multi-step work (3+ steps); do not use for simple questions. Keep titles short; update statuses as you progress; clear the list when done.',
+        'Replace the visible task checklist for this chat. Use ONLY for multi-step work (3+ steps); do not use for simple questions. Keep titles short; update statuses as you progress; clear the list when done. DISCIPLINE: mark each step done THE MOMENT it is completed; NEVER end your reply while items are still pending/active — the system bounces unfinished lists back.',
       parameters: {
         type: 'object',
         properties: {