wormclaude 1.0.13 → 1.0.15

package/dist/injections.js

@@ -0,0 +1,108 @@
+// Komut şablonu injection'ları — extension komutlarında dinamik içerik.
+// Gemini/Blackbox CLI injectionParser + shellProcessor + atFileProcessor'dan uyarlandı.
+//   {{args}}   -> kullanıcı argümanı (ham; !{} içinde shell-escape'li)
+//   !{komut}   -> shell çıktısı gömer (cmdsec güvenlik kontrolüyle)
+//   @{dosya}   -> dosya içeriği gömer (cwd'ye göre)
+import { execSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { checkCommand, escapeShellArg } from './cmdsec.js';
+const ARGS = '{{args}}';
+const SHELL_TRIG = '!{';
+const FILE_TRIG = '@{';
+// Brace-sayan parser (injectionParser.js — temiz, birebir).
+export function extractInjections(prompt, trigger, contextName) {
+    const injections = [];
+    let index = 0;
+    while (index < prompt.length) {
+        const startIndex = prompt.indexOf(trigger, index);
+        if (startIndex === -1)
+            break;
+        let i = startIndex + trigger.length;
+        let depth = 1;
+        let closed = false;
+        while (i < prompt.length) {
+            const ch = prompt[i];
+            if (ch === '{')
+                depth++;
+            else if (ch === '}') {
+                depth--;
+                if (depth === 0) {
+                    injections.push({ content: prompt.substring(startIndex + trigger.length, i).trim(), startIndex, endIndex: i + 1 });
+                    index = i + 1;
+                    closed = true;
+                    break;
+                }
+            }
+            i++;
+        }
+        if (!closed) {
+            const ctx = contextName ? ` ('${contextName}')` : '';
+            throw new Error(`Geçersiz injection${ctx}: ${trigger} kapanmamış (index ${startIndex}). Süslü parantezler dengeli olmalı.`);
+        }
+    }
+    return injections;
+}
+function runShell(cmd, cwd) {
+    const chk = checkCommand(cmd);
+    if (chk.decision === 'deny')
+        return `[engellendi: ${chk.reason || 'tehlikeli komut'}]`;
+    try {
+        const out = execSync(cmd, {
+            cwd, encoding: 'utf8', timeout: 30000, maxBuffer: 1024 * 1024,
+            windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        return String(out).trim();
+    }
+    catch (e) {
+        const o = (e?.stdout ? String(e.stdout) : '') + (e?.stderr ? String(e.stderr) : '');
+        return (o.trim() || `[komut hatası: ${e?.message || e}]`);
+    }
+}
+function readFileInjection(p, cwd) {
+    try {
+        const abs = path.isAbsolute(p) ? p : path.resolve(cwd, p);
+        const data = fs.readFileSync(abs, 'utf8');
+        return `--- ${p} ---\n${data}\n--- /${p} ---`;
+    }
+    catch {
+        return `[dosya okunamadı: ${p}]`;
+    }
+}
+// Bir injection türünü çözer; resolver(content) çıktıyı döndürür.
+function replaceTrigger(text, trigger, resolver, ctx) {
+    const injs = extractInjections(text, trigger, ctx);
+    if (injs.length === 0)
+        return text;
+    let out = '';
+    let last = 0;
+    for (const inj of injs) {
+        out += text.substring(last, inj.startIndex);
+        out += resolver(inj.content);
+        last = inj.endIndex;
+    }
+    out += text.substring(last);
+    return out;
+}
+// Şablonu çöz: !{komut} -> shell çıktısı, @{dosya} -> dosya, {{args}} -> argüman.
+export function resolveInjections(text, opts = {}) {
+    const args = opts.args ?? '';
+    const cwd = opts.cwd ?? process.cwd();
+    const ctx = opts.contextName;
+    let out = text;
+    // 1) !{komut}: içindeki {{args}} shell-escape'li, sonra cmdsec ile çalıştır.
+    if (out.includes(SHELL_TRIG)) {
+        const shell = process.platform === 'win32' ? 'cmd' : 'bash';
+        out = replaceTrigger(out, SHELL_TRIG, (cmd) => {
+            const resolved = cmd.split(ARGS).join(escapeShellArg(args, shell));
+            return runShell(resolved, cwd);
+        }, ctx);
+    }
+    // 2) @{dosya}: içindeki {{args}} ham, sonra oku.
+    if (out.includes(FILE_TRIG)) {
+        out = replaceTrigger(out, FILE_TRIG, (p) => readFileInjection(p.split(ARGS).join(args), cwd), ctx);
+    }
+    // 3) Kalan {{args}} -> ham argüman.
+    out = out.split(ARGS).join(args);
+    return out;
+}

package/dist/memory.js

@@ -2,6 +2,7 @@
 // Tetik eşikleri ve kilit mekanizması Claude Code'dan uyarlandı.
 import * as fs from 'node:fs';
 import * as path from 'node:path';
+import * as os from 'node:os';
 import { completeText } from './agent.js';
 import { approxTokens } from './usage.js';
 import { tasks } from './tasks.js';
@@ -133,6 +134,46 @@ export function dreamTimeGatePassed() {
     }
 }
 export function getMemoryPath() { return MEM_FILE; }
+// ── Açık kayıt: save_memory tool'u (otomatik hafızayı tamamlar) ────────────────
+const MEMORY_HEADER = '## Eklenen Hatıralar';
+/**
+ * Modelin/kullanıcının açıkça istediği tek bir kalıcı bilgiyi hafıza dosyasına ekler.
+ * Otomatik konsolidasyondan bağımsız; "## Eklenen Hatıralar" başlığı altına "- <fact>" yazar.
+ * scope: 'project' → cwd/.wormclaude/memory.md (varsayılan), 'global' → ~/.wormclaude/memory.md.
+ */
+export function saveMemoryFact(fact, scope = 'project') {
+    const clean = String(fact || '').trim().replace(/^(-+\s*)+/, '').trim();
+    if (!clean)
+        throw new Error('boş hatıra');
+    const dir = scope === 'global'
+        ? path.join(os.homedir(), '.wormclaude')
+        : MEM_DIR;
+    const file = path.join(dir, 'memory.md');
+    fs.mkdirSync(dir, { recursive: true });
+    let content = '';
+    try {
+        content = fs.readFileSync(file, 'utf8');
+    }
+    catch { }
+    const item = `- ${clean}`;
+    const idx = content.indexOf(MEMORY_HEADER);
+    if (idx === -1) {
+        const sep = content.length === 0 ? '' : content.endsWith('\n') ? '\n' : '\n\n';
+        content += `${sep}${MEMORY_HEADER}\n${item}\n`;
+    }
+    else {
+        // Başlıktan sonraki bölümün sonuna ekle (sonraki ## başlığına kadar)
+        const start = idx + MEMORY_HEADER.length;
+        let end = content.indexOf('\n## ', start);
+        if (end === -1)
+            end = content.length;
+        const before = content.slice(0, end).replace(/\s+$/, '');
+        const after = content.slice(end);
+        content = `${before}\n${item}${after.startsWith('\n') ? '' : '\n'}${after}`;
+    }
+    fs.writeFileSync(file, content);
+    return file;
+}
 // Kalıcı hafızayı başlangıçta context'e yüklemek için oku.
 // .wormclaude/memory.md (oturumlar arası hafıza) + WORMCLAUDE.md (proje notu).
 export function loadMemoryContext() {

package/dist/safejson.js

@@ -0,0 +1,166 @@
+// Qwen-14B'nin bozuk JSON tool-call argümanlarını kurtarmak için dayanıklı JSON yardımcıları.
+// Bağımlılıksız (jsonrepair YOK) — elle onarım stratejileri. Gemini safeJsonParse + fixBooleanCasing'den
+// uyarlandı; WormClaude'a özel sadeleştirildi.
+/**
+ * Python-tarzı True/False/None'ı JSON karşılıklarına çevirir (özyinelemeli, string-güvenli).
+ * Qwen bazen `{"flag": True}` üretir → geçerli JSON değil.
+ */
+export function fixBooleanCasing(text) {
+    let out = '';
+    let inString = false;
+    let escape = false;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (inString) {
+            out += ch;
+            if (escape)
+                escape = false;
+            else if (ch === '\\')
+                escape = true;
+            else if (ch === '"')
+                inString = false;
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+            out += ch;
+            continue;
+        }
+        // String dışında: Python literal'lerini kelime-sınırında değiştir
+        const rest = text.slice(i);
+        const m = /^(True|False|None)\b/.exec(rest);
+        if (m) {
+            out += m[1] === 'True' ? 'true' : m[1] === 'False' ? 'false' : 'null';
+            i += m[1].length - 1;
+            continue;
+        }
+        out += ch;
+    }
+    return out;
+}
+/** String dışındaki trailing virgülleri kaldırır: `{"a":1,}` → `{"a":1}` */
+function stripTrailingCommas(text) {
+    let out = '';
+    let inString = false;
+    let escape = false;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (inString) {
+            out += ch;
+            if (escape)
+                escape = false;
+            else if (ch === '\\')
+                escape = true;
+            else if (ch === '"')
+                inString = false;
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+            out += ch;
+            continue;
+        }
+        if (ch === ',') {
+            // Sonraki anlamlı karakter } veya ] ise virgülü at
+            let j = i + 1;
+            while (j < text.length && /\s/.test(text[j]))
+                j++;
+            if (text[j] === '}' || text[j] === ']')
+                continue;
+        }
+        out += ch;
+    }
+    return out;
+}
+/** Açık kalan string/parantez/köşeli ayraçları kapatır (streaming kesintisi onarımı). */
+function closeOpenStructures(text) {
+    let inString = false;
+    let escape = false;
+    const stack = [];
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (inString) {
+            if (escape)
+                escape = false;
+            else if (ch === '\\')
+                escape = true;
+            else if (ch === '"')
+                inString = false;
+            continue;
+        }
+        if (ch === '"')
+            inString = true;
+        else if (ch === '{')
+            stack.push('}');
+        else if (ch === '[')
+            stack.push(']');
+        else if (ch === '}' || ch === ']')
+            stack.pop();
+    }
+    let out = text;
+    if (inString)
+        out += '"';
+    while (stack.length)
+        out += stack.pop();
+    return out;
+}
+/**
+ * Bozuk/yarım JSON'u en iyi çabayla parse eder. Sırayla: düz parse → fixBooleanCasing →
+ * trailing-comma temizliği → açık yapıları kapatma. Hepsi başarısızsa fallback döner.
+ */
+export function safeJsonParse(text, fallback) {
+    if (text == null)
+        return fallback;
+    const raw = String(text).trim();
+    if (!raw)
+        return fallback;
+    // 1) Düz
+    try {
+        return JSON.parse(raw);
+    }
+    catch { }
+    // 2) Boolean casing
+    let repaired = fixBooleanCasing(raw);
+    try {
+        return JSON.parse(repaired);
+    }
+    catch { }
+    // 3) Trailing virgüller
+    repaired = stripTrailingCommas(repaired);
+    try {
+        return JSON.parse(repaired);
+    }
+    catch { }
+    // 4) Açık yapıları kapat
+    repaired = closeOpenStructures(repaired);
+    try {
+        return JSON.parse(repaired);
+    }
+    catch { }
+    // 5) Pes
+    return fallback;
+}
+/**
+ * Döngüsel referansları ve hata/undefined değerleri tolere ederek JSON üretir.
+ * Asla fırlatmaz; başarısızsa fallback string döner.
+ */
+export function safeJsonStringify(value, space, fallback = '"[unserializable]"') {
+    const seen = new WeakSet();
+    try {
+        return JSON.stringify(value, (_k, v) => {
+            if (typeof v === 'bigint')
+                return v.toString();
+            if (v instanceof Error)
+                return { name: v.name, message: v.message };
+            if (typeof v === 'object' && v !== null) {
+                if (seen.has(v))
+                    return '[Circular]';
+                seen.add(v);
+            }
+            return v;
+        }, space);
+    }
+    catch {
+        return fallback;
+    }
+}

package/dist/streamparser.js

@@ -0,0 +1,158 @@
+// Streaming tool-call delta'larını dayanıklı biçimde birleştirir.
+// Qwen-14B + vLLM(hermes) parçalı JSON arg, index çakışması, ID'siz devam chunk'ı üretebilir.
+// Gemini streamingToolCallParser'dan uyarlandı; bizim {index, id?, name?, argChunk} delta'mıza göre sade.
+import { safeJsonParse } from './safejson.js';
+export class StreamingToolCallParser {
+    buffers = new Map();
+    depths = new Map();
+    inStrings = new Map();
+    escapes = new Map();
+    meta = new Map();
+    idToIndex = new Map();
+    nextIndex = 0;
+    /**
+     * Bir delta chunk'ı ekler. index streaming yanıtından gelir (çakışabilir); id yeni çağrı başlangıcı.
+     * @returns chunk işlendikten sonra o index'te JSON tamamlandıysa parse edilmiş değer.
+     */
+    addChunk(index, chunk, id, name) {
+        let actual = index;
+        if (id) {
+            if (this.idToIndex.has(id)) {
+                actual = this.idToIndex.get(id);
+            }
+            else {
+                // Bu index'te FARKLI id'li, tamamlanmış bir çağrı varsa yeni slot bul
+                if (this.buffers.has(index)) {
+                    const buf = this.buffers.get(index);
+                    const depth = this.depths.get(index);
+                    const m = this.meta.get(index);
+                    if (buf.trim() && depth === 0 && m?.id && m.id !== id) {
+                        try {
+                            JSON.parse(buf);
+                            actual = this.findNextIndex();
+                        }
+                        catch { /* yarım → güvenle yeniden kullan */ }
+                    }
+                }
+                this.idToIndex.set(id, actual);
+            }
+        }
+        else if (this.buffers.has(index)) {
+            // ID'siz devam: bu index tamamlandıysa en son yarım çağrıya yönlendir
+            const buf = this.buffers.get(index);
+            const depth = this.depths.get(index);
+            if (depth === 0 && buf.trim()) {
+                try {
+                    JSON.parse(buf);
+                    actual = this.findMostRecentIncomplete();
+                }
+                catch {
+                    actual = index;
+                }
+            }
+        }
+        if (!this.buffers.has(actual)) {
+            this.buffers.set(actual, '');
+            this.depths.set(actual, 0);
+            this.inStrings.set(actual, false);
+            this.escapes.set(actual, false);
+            this.meta.set(actual, {});
+        }
+        const m = this.meta.get(actual);
+        if (id)
+            m.id = id;
+        if (name)
+            m.name = (m.name || '') + name;
+        const newBuffer = this.buffers.get(actual) + chunk;
+        this.buffers.set(actual, newBuffer);
+        // Derinlik takibi — sadece string DIŞINDAKİ ayraçları say
+        let depth = this.depths.get(actual);
+        let inString = this.inStrings.get(actual);
+        let escape = this.escapes.get(actual);
+        for (const ch of chunk) {
+            if (!inString) {
+                if (ch === '{' || ch === '[')
+                    depth++;
+                else if (ch === '}' || ch === ']')
+                    depth--;
+            }
+            if (ch === '"' && !escape)
+                inString = !inString;
+            escape = ch === '\\' && !escape;
+        }
+        this.depths.set(actual, depth);
+        this.inStrings.set(actual, inString);
+        this.escapes.set(actual, escape);
+        if (depth === 0 && newBuffer.trim().length > 0) {
+            try {
+                return { complete: true, value: JSON.parse(newBuffer) };
+            }
+            catch {
+                return { complete: false };
+            }
+        }
+        return { complete: false };
+    }
+    /** Stream bittiğinde (finish_reason) çağrılır. name'i olan ve buffer'ı dolu tüm çağrıları döndürür. */
+    getCompleted() {
+        const out = [];
+        for (const [index, buffer] of this.buffers.entries()) {
+            const m = this.meta.get(index);
+            if (!m?.name)
+                continue; // isimsiz parça → çağrı değil
+            // Boş buffer = argümansız tool (ör. {}). safeJsonParse onarım dener, başarısızsa {} fallback.
+            const args = buffer.trim() ? safeJsonParse(buffer, {}) : {};
+            out.push({ id: m.id || `call_${index}`, name: m.name, args, index });
+        }
+        return out;
+    }
+    reset() {
+        this.buffers.clear();
+        this.depths.clear();
+        this.inStrings.clear();
+        this.escapes.clear();
+        this.meta.clear();
+        this.idToIndex.clear();
+        this.nextIndex = 0;
+    }
+    findNextIndex() {
+        while (this.buffers.has(this.nextIndex)) {
+            const buf = this.buffers.get(this.nextIndex);
+            const depth = this.depths.get(this.nextIndex);
+            const m = this.meta.get(this.nextIndex);
+            if (!buf.trim() || depth > 0 || !m?.id)
+                return this.nextIndex;
+            try {
+                JSON.parse(buf);
+                if (depth === 0) {
+                    this.nextIndex++;
+                    continue;
+                }
+            }
+            catch {
+                return this.nextIndex;
+            }
+            this.nextIndex++;
+        }
+        return this.nextIndex++;
+    }
+    findMostRecentIncomplete() {
+        let maxIndex = -1;
+        for (const [index, buffer] of this.buffers.entries()) {
+            const depth = this.depths.get(index);
+            const m = this.meta.get(index);
+            if (m?.id && (depth > 0 || !buffer.trim())) {
+                maxIndex = Math.max(maxIndex, index);
+            }
+            else if (buffer.trim()) {
+                try {
+                    JSON.parse(buffer);
+                }
+                catch {
+                    maxIndex = Math.max(maxIndex, index);
+                }
+            }
+        }
+        return maxIndex >= 0 ? maxIndex : this.findNextIndex();
+    }
+}

package/dist/subagents.js

@@ -0,0 +1,119 @@
+// İsimli/uzman alt-ajan tanımları + kullanıcı-seviyesi loader.
+// Agent tool'u opsiyonel `subagent_type` ile çağrılınca buradan uzman prompt + tool-kısıtı çözülür.
+// Gemini builtin-agents + subagent-manager'dan uyarlandı; WormClaude güvenlik kimliğine göre.
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+// ── Gömülü uzman ajanlar ──────────────────────────────────────────────────────
+const BUILTINS = [
+    {
+        name: 'general-purpose',
+        description: 'Karmaşık soruları araştırma, kod arama ve çok adımlı görevler için genel amaçlı ajan.',
+        system: 'Sen bir WormClaude alt-ajanısın: tek bir görevi uçtan uca bitirmek için doğmuş otonom bir işçi. ' +
+            'İstenen neyse onu yap — fazlası değil, eksiği değil. Geniş arama için Grep/Glob, bilinen yol için Read kullan. ' +
+            'Gereksiz dosya YARATMA; *.md/README dosyalarını yalnız açıkça istenirse oluştur. ' +
+            'Bu görev dışında hafızan yok. Bitince yaptıklarının ve istenen sonuçların kısa, net bir raporunu döndür. ' +
+            'Yanıtta paylaştığın dosya yolları MUTLAK olmalı; göreli yol kullanma. Emoji kullanma.',
+    },
+    {
+        name: 'security-recon',
+        description: 'YETKİLİ güvenlik testlerinde keşif: port/servis/teknoloji tespiti, yüzey analizi, raporlama.',
+        system: 'Sen bir WormClaude güvenlik-keşif alt-ajanısın. SADECE yetkili/izinli hedeflerde çalış. ' +
+            'Görevin: pasif ve aktif keşif (port/servis tespiti, teknoloji parmak izi, dizin/endpoint yüzeyi, ' +
+            'sürüm tespiti) yapıp bulgularını yapılandırılmış bir rapor olarak döndürmek. ' +
+            'Yıkıcı işlem, gerçek istismar veya hizmet-dışı bırakma YAPMA — yalnız keşif ve analiz. ' +
+            'Bulguları önem derecesiyle (bilgi/düşük/orta/yüksek) sınıflandır. Komut çıktısını ham bırakma, yorumla. Emoji kullanma.',
+        tools: ['Bash', 'Read', 'Grep', 'Glob', 'WebFetch', 'WebSearch', 'TaskOutput'],
+    },
+    {
+        name: 'code-explorer',
+        description: 'Büyük kod tabanlarını haritalama: mimari, modül ilişkileri, giriş noktaları.',
+        system: 'Sen bir WormClaude kod-keşif alt-ajanısın. Görevin bir kod tabanını hızla haritalamak: ' +
+            'dizin yapısı, ana modüller, giriş noktaları, önemli soyutlamalar ve bağımlılıklar. ' +
+            'Grep/Glob ile geniş tara, Read ile kritik dosyaları incele. Dosya YARATMA/DEĞİŞTİRME. ' +
+            'Sonucu: kısa mimari özet + ilgili dosya yolları (MUTLAK) + kod parçaları olarak döndür. Emoji kullanma.',
+        tools: ['Grep', 'Glob', 'Read', 'TaskOutput'],
+    },
+];
+// ── Kullanıcı-seviyesi ajanlar: ~/.wormclaude/agents/*.md ─────────────────────
+function agentsDir() {
+    return path.join(os.homedir(), '.wormclaude', 'agents');
+}
+/** Minimal frontmatter ayrıştırma (yaml-parser gelene kadar; name/description/tools + body). */
+function parseAgentFile(content, fallbackName) {
+    const m = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/.exec(content);
+    if (!m)
+        return null;
+    const [, fm, body] = m;
+    const get = (key) => {
+        const r = new RegExp(`^${key}\\s*:\\s*(.+)$`, 'mi').exec(fm);
+        return r ? r[1].trim().replace(/^["']|["']$/g, '') : undefined;
+    };
+    const name = (get('name') || fallbackName).trim();
+    const description = get('description') || '';
+    const system = body.trim();
+    if (!name || !system)
+        return null;
+    // tools: [A, B] veya A,B
+    let tools;
+    const rawTools = get('tools');
+    if (rawTools) {
+        tools = rawTools.replace(/[\[\]]/g, '').split(',').map((s) => s.trim()).filter(Boolean);
+        if (!tools.length)
+            tools = undefined;
+    }
+    // İsim guard: rezerve/biçim
+    const RESERVED = new Set(['self', 'system', 'user', 'model', 'tool', 'config', 'default']);
+    if (!/^[a-zA-Z0-9_-]{2,50}$/.test(name) || RESERVED.has(name.toLowerCase()))
+        return null;
+    return { name, description, system, tools };
+}
+function loadUserAgents() {
+    try {
+        const dir = agentsDir();
+        if (!fs.existsSync(dir))
+            return [];
+        return fs.readdirSync(dir)
+            .filter((f) => f.endsWith('.md'))
+            .map((f) => {
+            try {
+                const def = parseAgentFile(fs.readFileSync(path.join(dir, f), 'utf8'), f.replace(/\.md$/, ''));
+                return def;
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((d) => d !== null);
+    }
+    catch {
+        return [];
+    }
+}
+/** Ajanı isme göre çöz. Öncelik: kullanıcı dosyası > gömülü. Bulunamazsa null. */
+export function resolveSubagent(type) {
+    if (!type)
+        return null;
+    const t = type.trim().toLowerCase();
+    const user = loadUserAgents().find((a) => a.name.toLowerCase() === t);
+    if (user)
+        return user;
+    return BUILTINS.find((a) => a.name.toLowerCase() === t) || null;
+}
+/** Tüm kullanılabilir ajanları listele (kullanıcı dosyaları gömülüleri gölgeler). */
+export function listSubagents() {
+    const seen = new Set();
+    const out = [];
+    for (const a of [...loadUserAgents(), ...BUILTINS]) {
+        const k = a.name.toLowerCase();
+        if (seen.has(k))
+            continue;
+        seen.add(k);
+        out.push(a);
+    }
+    return out;
+}
+/** Agent tool açıklamasına eklenecek "kullanılabilir tipler" satırı. */
+export function subagentTypesHint() {
+    return listSubagents().map((a) => `- ${a.name}: ${a.description}`).join('\n');
+}

package/dist/textclean.js

@@ -0,0 +1,37 @@
+// Model metnindeki sızıntıları temizler: özel tokenlar + parçalı tool-call markup.
+// Qwen-14B + vLLM(hermes) bazen ham çıktıya kontrol token'ları veya tool-call etiketleri sızdırır.
+// ChatML / Qwen özel token'ları
+const SPECIAL_TOKENS = [
+    '<|endoftext|>', '<|im_start|>', '<|im_end|>', '<|im_sep|>',
+    '<|endofturn|>', '<|fim_prefix|>', '<|fim_middle|>', '<|fim_suffix|>',
+];
+// Hermes tool-call markup (metne sızarsa) — bloğun TAMAMINI kaldır.
+const TOOL_CALL_BLOCK = /<tool_call>[\s\S]*?<\/tool_call>/g;
+const TOOL_RESPONSE_BLOCK = /<tool_response>[\s\S]*?<\/tool_response>/g;
+// Açık kalan (kapanışı gelmemiş) tek etiketler
+const STRAY_TOOL_TAGS = /<\/?(tool_call|tool_response)>/g;
+/**
+ * Görüntülenecek/saklanacak model metnini temizler. İçeriği bozmadan yalnız
+ * sızan kontrol token'larını ve tool-call markup'ını çıkarır.
+ */
+export function cleanModelText(text) {
+    if (!text)
+        return text;
+    let out = text;
+    out = out.replace(TOOL_CALL_BLOCK, '');
+    out = out.replace(TOOL_RESPONSE_BLOCK, '');
+    out = out.replace(STRAY_TOOL_TAGS, '');
+    for (const tok of SPECIAL_TOKENS) {
+        if (out.includes(tok))
+            out = out.split(tok).join('');
+    }
+    return out;
+}
+/**
+ * Streaming sırasında güvenli temizlik: yalnız TAM özel-token'ları ve kapanmış blokları
+ * temizler — yarım gelen bir etiketi (ör. "<tool_") sonraki chunk'ı bekleyeceği için bırakır.
+ * Akan tamponun tamamına uygulanır (parçalı token'ı bölmemek için).
+ */
+export function cleanStreamingBuffer(buffer) {
+    return cleanModelText(buffer);
+}

package/dist/theme.js

@@ -8,4 +8,4 @@ export const theme = {
     green: '#4ade80',
     errorRed: '#ff6b6b',
 };
-export const VERSION = '1.0.13';
+export const VERSION = '1.0.14';