Snapshot async request configuration for HTTP sessions

Replaced retired Anthropic model ids with the recommended replacements: the default model in src/anthropic.c and decai (claude-sonnet-5-5), plus docs, examples and model lists.

Notice anthropic-retired-models-2026-10 about api.anthropic.com's API describes the change. It was read from a file and is not signed by the provider.

.github/dependabot.yml

@@ -0,0 +1,8 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    labels:
+      - buildsystem

.github/workflows/ci.yml

@@ -1,49 +1,170 @@
-# TODO: add windows
-name: ci
+name: CI and Release
 
 env:
-  R2V: 5.9.8
+  R2V: 6.2.6
 
 on:
   push:
-  pull_request:
-  workflow_dispatch:
+    branches:
+      - '**'
+    tags:
+      - '[0-9]*'
+#  pull_request:
 
 jobs:
-  build-linux:
-    runs-on: ubuntu-24.04
+  build:
+    name: Build (${{ matrix.os }} / ${{ matrix.build_system }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-24.04, macos-latest, windows-latest]
+        build_system: [make, meson]
+        exclude:
+          - os: windows-latest
+            build_system: make
+
     steps:
-    - uses: actions/checkout@v4
-    - name: Installing radare2
-      run: |
-        wget "https://github.com/radareorg/radare2/releases/download/${R2V}/radare2_${R2V}_amd64.deb"
-        wget "https://github.com/radareorg/radare2/releases/download/${R2V}/radare2-dev_${R2V}_amd64.deb"
-        sudo dpkg -i "radare2_${R2V}_amd64.deb"
-        sudo dpkg -i "radare2-dev_${R2V}_amd64.deb"
-    - name: Building the C rewrite
-      run: make -C src
-    - name: Setting up the Python virtual environment
-      run: |
-        python -m venv venv
-        . venv/bin/activate
-        pip install pylint
-    - name: Install Python dependencies
-      run: |
-        . venv/bin/activate
-        pip install .
-    - name: Linting
-      run: |
-        . venv/bin/activate
-        make cilint
-    - name: Running r2ai from the shell
-      run: |
-        . venv/bin/activate
-        python -m r2ai.cli -h
-    - name: Running r2ai from r2pipe
-      run: |
-        . venv/bin/activate
-        r2 -q -c '#!pipe python -m r2ai.cli -h' /bin/ls
-    - name: Running r2ai from r2
-      run: |
-        . venv/bin/activate
-        r2 -q -i r2ai/plugin.py -c r2ai /bin/ls
+      - name: Checkout
+        uses: actions/checkout@v7
+
+      - name: Setup Meson/Ninja
+        if: matrix.build_system == 'meson'
+        run: |
+          python -m pip install --upgrade pip
+          pip install meson ninja
+
+      - name: Install radare2
+        id: r2
+        uses: radareorg/github-actions@v3
+        with:
+          version: ${{ env.R2V }}
+
+      - name: Build with Make
+        if: matrix.build_system == 'make'
+        run: make -C src
+
+      - name: Build with Meson (Unix)
+        if: matrix.build_system == 'meson' && matrix.os != 'windows-latest'
+        run: |
+          cd src
+          meson setup build || meson configure build
+          meson compile -C build
+
+      - name: Build with Meson (Windows)
+        if: matrix.build_system == 'meson' && matrix.os == 'windows-latest'
+        shell: powershell
+        run: |
+          cd src
+          $prefix = "${{ steps.r2.outputs.prefix }}"
+          meson setup build --backend ninja --prefix="$prefix" -Dr2_prefix="$prefix"
+          if ($LASTEXITCODE -ne 0) { meson configure build }
+          meson compile -C build
+
+  bindist:
+    name: Build r2pm binary (${{ matrix.os }})
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, ubuntu-24.04-arm, macos-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v7
+
+      - name: Install radare2
+        uses: radareorg/github-actions@v3
+        with:
+          version: ${{ env.R2V }}
+
+      - name: Package r2pm binary
+        run: make -C src bindist
+
+      - name: Upload r2pm binary artifact
+        uses: actions/upload-artifact@v7
+        with:
+          name: bindist-${{ matrix.os }}
+          path: r2ai-*.zip
+          if-no-files-found: error
+
+  windows-bindist:
+    name: Build r2pm binary (Windows)
+    runs-on: windows-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v7
+
+      - name: Setup Meson/Ninja
+        run: |
+          python -m pip install --upgrade pip
+          pip install meson ninja
+
+      - name: Install radare2
+        id: r2
+        uses: radareorg/github-actions@v3
+        with:
+          version: ${{ env.R2V }}
+
+      - name: Build with Meson
+        shell: powershell
+        run: |
+          cd src
+          $prefix = "${{ steps.r2.outputs.prefix }}"
+          meson setup build --backend ninja --prefix="$prefix" -Dr2_prefix="$prefix"
+          if ($LASTEXITCODE -ne 0) { meson configure build }
+          meson compile -C build
+
+      - name: Package r2pm binary
+        shell: pwsh
+        run: |
+          New-Item -ItemType Directory -Force -Path bindist\plugins,bindist\bin,bindist\prompts | Out-Null
+          Get-ChildItem src\build\ -Filter "*r2ai*.dll" -ErrorAction SilentlyContinue | Copy-Item -Destination bindist\plugins
+          Get-ChildItem src\..\build\ -Filter "*r2ai*.dll" -ErrorAction SilentlyContinue | Copy-Item -Destination bindist\plugins
+          Copy-Item src\build\r2ai.exe bindist\bin
+          Copy-Item prompts\*.r2ai.md bindist\prompts
+          $rv = (& radare2 -qv).Trim()
+          Compress-Archive -Path bindist\* -DestinationPath "r2ai-$rv-windows-x86-64.zip" -Force
+
+      - name: Upload r2pm binary artifact
+        uses: actions/upload-artifact@v7
+        with:
+          name: windows-bindist
+          path: r2ai-*.zip
+          if-no-files-found: error
+
+  release:
+    name: Create Release
+    needs: [bindist, windows-bindist]
+    if: startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v7
+
+      - name: Verify tag is on master
+        run: |
+          git fetch origin master:refs/remotes/origin/master
+          if ! git branch -r --contains ${GITHUB_SHA} | grep -q "origin/master"; then
+            echo "Tag commit is not on origin/master — skipping release."
+            exit 0
+          fi
+
+      - name: Download r2pm binary artifacts
+        uses: actions/download-artifact@v8
+        with:
+          pattern: '*bindist*'
+          path: release-artifacts
+          merge-multiple: true
+
+      - name: Add decai.r2.js to release artifacts
+        run: cp decai/decai.r2.js release-artifacts/
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v3
+        with:
+          files: |
+            release-artifacts/*.zip
+            release-artifacts/decai.r2.js
+          generate_release_notes: true

.github/workflows/releases.yml

@@ -1,19 +0,0 @@
-name: Create release
-
-on:
-  push:
-    tags:
-      - '*'
-
-jobs:
-  release:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-      - name: Create GitHub release
-        uses: softprops/action-gh-release@v2
-        with:
-          draft: false
-          prerelease: false
-          generate_release_notes: true

.gitignore

@@ -1,4 +1,8 @@
 build
+b
+src/b
+src/r2ai
+src/r2ai.dSYM
 venv
 **/__pycache__
 *.pyc
@@ -6,4 +10,8 @@ venv
 *.o
 *.so
 *.dylib
-*.a
+*.a
+third_party
+
+# r2pm binary packages
+r2ai-*.zip

Attic/examples/ai.sh

@@ -23,12 +23,12 @@ if [ -f ~/.r2ai.openai-key ]; then
 	OPENAI_KEY=$(cat ~/.r2ai.openai-key)
 fi
 CLAUDE_KEY=""
-CLAUDE_MODEL="claude-3-5-sonnet-20241022"
+CLAUDE_MODEL="claude-sonnet-5-5"
 if [ -f ~/.r2ai.anthropic-key ]; then
 	CLAUDE_KEY=$(cat ~/.r2ai.anthropic-key)
 fi
 DEEPSEEK_KEY=""
-DEEPSEEK_MODEL="claude-3-5-sonnet-20241022"
+DEEPSEEK_MODEL="claude-sonnet-5-5"
 if [ -f ~/.r2ai.deepseek-key ]; then
 	DEEPSEEK_KEY=$(cat ~/.r2ai.anthropic-key)
 fi
@@ -138,7 +138,7 @@ GEMINI_KEY=~/.r2ai-gemini.key
 OPENAI_KEY=~/.r2ai-openai.key
 CLAUDE_KEY=~/.r2ai-anthropic.key
 DEEPSEEK_KEY=~/.r2ai-deepseek.key
-CLAUDE_MODEL=claude-3-5-sonnet-20241022
+CLAUDE_MODEL=claude-sonnet-5-5
 EOF
 	exit 0
 }

Attic/examples/benchmark/Makefile

@@ -0,0 +1,14 @@
+SHELL=/bin/bash
+
+MODELS=gpt-oss:20b gemma3:4b gemma3:12b
+MODELS+=granite3-dense:8b mannix/jan-nano:latest yi-coder:latest qwen3:latest deepseek-coder-v2:latest hhao/qwen2.5-coder-tools:latest qwen2.5-coder:latest
+MODELS=granite3-dense:8b mannix/jan-nano:latest yi-coder:latest qwen3:latest deepseek-coder-v2:latest hhao/qwen2.5-coder-tools:latest qwen2.5-coder:latest
+LANGS=Dart Perl Ruby Javascript PHP C
+
+all:
+	for a in ${MODELS} ; do \
+		declare -a ARGS; \
+		for l in ${LANGS} ; do \
+			ARGS+=("echo \"decai -e model=$$a;decai -e lang=$$l;s 0x100000924;af;decai -d\" | r2 -q /bin/ls"); \
+		done ; \
+		./run.sh "$${ARGS[@]}" > ${a//\//_}.html ; done

Attic/examples/benchmark/decai/BENCH.txt

@@ -0,0 +1,4 @@
+<b>
+decai -e model=$a;decai -e lang=$l;s 0x100000924;af;decai -d
+</b><br/>
+Transform this pseudocode and respond ONLY with plain code (NO explanations, comments or markdown), Change 'goto' into if/else/for/while, Simplify as much as possible, use better variable names, take function arguments and strings from comments like 'string:', Reduce lines of code and fit everything in a single function, Remove all dead code

Attic/examples/benchmark/index.sh

@@ -0,0 +1,49 @@
+#!/bin/bash
+
+# Find all directories containing BENCH.txt
+dirs=$(find . -name "BENCH.txt" -type f | xargs dirname | sort | uniq)
+
+# Start HTML output
+cat <<EOF > benchmark_index.html
+<html>
+<table>
+EOF
+
+# Process each directory
+for dir in $dirs; do
+    cat <<EOF >> benchmark_index.html
+	<tr> <td>
+	<div>
+EOF
+
+    # Add contents of BENCH.txt
+    cat "$dir/BENCH.txt" >> benchmark_index.html
+
+    cat <<EOF >> benchmark_index.html
+	</div>
+	</td>
+	<td>
+EOF
+
+    # Find and add links to HTML files
+    for html_file in $(ls "$dir"/*.html 2>/dev/null | sort); do
+        base=$(basename "$html_file" .html)
+        cat <<EOF >> benchmark_index.html
+	<a href="$dir/$base.html">$base</a>
+	<br />
+EOF
+    done
+
+    cat <<EOF >> benchmark_index.html
+	</td>
+	</tr>
+EOF
+done
+
+# End HTML output
+cat <<EOF >> benchmark_index.html
+</table>
+<br />
+<br />
+</html>
+EOF

Attic/examples/benchmark/run.sh

@@ -0,0 +1,177 @@
+#!/bin/bash
+
+# Generate HTML output for command executions with collapsible sections and width control
+
+if [ $# -eq 0 ]; then
+    echo "Usage: $0 command1 [command2 ...]"
+    exit 1
+fi
+
+# Timeout in seconds for each command (configurable via TIMEOUT environment variable)
+TIMEOUT=${TIMEOUT:-30}
+
+cat << 'EOF'
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Command Execution Results</title>
+    <style>
+        * {
+            box-sizing: border-box;
+        }
+        :root {
+            --max-width: 400px;
+        }
+        body {
+            font-family: monospace;
+            margin: 0;
+            padding: 20px;
+            background-color: #f5f5f5;
+            overflow-x: hidden;
+        }
+        .slider-container {
+            background: white;
+            padding: 15px;
+            margin-bottom: 20px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+            width: 100%;
+        }
+        .slider-container label {
+            display: block;
+            margin-bottom: 10px;
+            font-weight: bold;
+        }
+        .slider-container input {
+            width: 100%;
+        }
+        .commands-container {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 15px;
+            align-items: flex-start;
+        }
+        .command-section {
+            background: white;
+            border-radius: 8px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+            overflow: hidden;
+            width: var(--max-width);
+        }
+        .command-title {
+            background: #e9ecef;
+            padding: 12px 15px;
+            cursor: pointer;
+            border: none;
+            width: 100%;
+            text-align: left;
+            font-family: inherit;
+            font-size: inherit;
+            border-radius: 8px 8px 0 0;
+            position: relative;
+        }
+        .command-title:hover {
+            background: #dee2e6;
+        }
+        .command-time {
+            position: absolute;
+            top: 12px;
+            right: 15px;
+            color: #6c757d;
+            font-size: 0.9em;
+        }
+        .command-body {
+            padding: 15px;
+            border-top: 1px solid #dee2e6;
+            display: none;
+        }
+        .command-output {
+            background: #f8f9fa;
+            padding: 10px;
+            border-radius: 4px;
+            white-space: pre-wrap;
+            word-wrap: break-word;
+            overflow-x: auto;
+        }
+        .command-section.expanded .command-body {
+            display: block;
+        }
+    </style>
+</head>
+<body>
+    <div class="slider-container">
+        <label for="width-slider">Maximum Width: <span id="width-value">400</span>px</label>
+        <input type="range" id="width-slider" min="200" max="2000" value="400" step="50">
+    </div>
+    <div class="commands-container">
+EOF
+
+# Process each command
+for cmd in "$@"; do
+    # Extract title: if command starts with #, use the rest as title, else use the command
+    if [[ "$cmd" =~ ^#[[:space:]]*(.*) ]]; then
+        title="${BASH_REMATCH[1]}"
+        exec_cmd="${cmd#*#}"
+        exec_cmd="${exec_cmd#"${exec_cmd%%[![:space:]]*}"}"  # trim leading spaces
+    else
+        title="$cmd"
+        exec_cmd="$cmd"
+    fi
+
+    # Execute command and time it
+    start_time=$(date +%s.%N)
+    tmpfile=$(mktemp)
+    eval "$exec_cmd" > "$tmpfile" 2>&1 &
+    pid=$!
+    (sleep $TIMEOUT && kill $pid 2>/dev/null) &
+    wait $pid 2>/dev/null
+    output=$(cat "$tmpfile")
+    rm "$tmpfile"
+    exit_code=$?
+    end_time=$(date +%s.%N)
+    
+    # Calculate execution time
+    execution_time=$(echo "$end_time - $start_time" | bc -l 2>/dev/null || echo "0")
+    if [ $? -ne 0 ]; then
+        execution_time="N/A"
+    else
+        execution_time=$(printf "%.3f" "$execution_time")
+    fi
+
+    # Escape HTML in output
+    escaped_output=$(echo "$output" | sed 's/&/\&amp;/g; s/</\&lt;/g; s/>/\&gt;/g')
+
+    cat << EOF
+        <div class="command-section expanded">
+            <button class="command-title" onclick="toggleSection(this)">$title<span class="command-time">${execution_time}s</span></button>
+            <div class="command-body">
+                <div class="command-output">$escaped_output</div>
+            </div>
+        </div>
+EOF
+done
+
+cat << 'EOF'
+    </div>
+
+    <script>
+        // Slider functionality
+        const slider = document.getElementById('width-slider');
+        const widthValue = document.getElementById('width-value');
+        
+        slider.addEventListener('input', function() {
+            const value = this.value;
+            document.documentElement.style.setProperty('--max-width', value + 'px');
+            widthValue.textContent = value;
+        });
+
+        // Toggle functionality
+        function toggleSection(button) {
+            const section = button.parentElement;
+            section.classList.toggle('expanded');
+        }
+    </script>
+</body>
+</html>
+EOF

Attic/examples/substitute.c

@@ -0,0 +1,66 @@
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+#define ALPHABET_SIZE 26
+
+// Function to perform substitution (both encryption and decryption)
+void substitute(const char *input, const char *substitution, char *output, int reverse) {
+    char mapping[ALPHABET_SIZE];
+
+    if (reverse) {
+        // Create reverse substitution table for decryption
+        for (int i = 0; i < ALPHABET_SIZE; i++) {
+            mapping[substitution[i] - 'A'] = 'A' + i;
+        }
+    } else {
+        // Use the direct substitution table for encryption
+        for (int i = 0; i < ALPHABET_SIZE; i++) {
+            mapping[i] = substitution[i];
+        }
+    }
+
+    for (int i = 0; input[i] != '\0'; i++) {
+        char c = input[i];
+
+        // Handle uppercase letters
+        if (isupper(c)) {
+            output[i] = mapping[c - 'A'];
+        }
+        // Handle lowercase letters
+        else if (islower(c)) {
+            output[i] = tolower(mapping[c - 'a']);
+        }
+        // Leave non-alphabet characters unchanged
+        else {
+            output[i] = c;
+        }
+    }
+
+    output[strlen(input)] = '\0';  // Null-terminate the output string
+}
+
+int main() {
+    char input[256];
+    char output[256];
+
+    // Configurable substitution key (A-Z)
+    const char *substitution = "QWERTYUIOPASDFGHJKLZXCVBNM";  // Example substitution key
+
+    // Get input from the user
+    printf("Enter text to encrypt: ");
+    fgets(input, sizeof(input), stdin);
+
+    // Remove newline character from input if it exists
+    input[strcspn(input, "\n")] = 0;
+
+    // Perform encryption (forward substitution)
+    substitute(input, substitution, output, 0);
+    printf("Encrypted text: %s\n", output);
+
+    // Perform decryption (reverse substitution)
+    substitute(output, substitution, input, 1);
+    printf("Decrypted text: %s\n", input);
+
+    return 0;
+}

Attic/llmcom.py

@@ -0,0 +1,28 @@
+from transformers import AutoTokenizer
+import transformers
+import torch
+
+model = "facebook/llm-compiler-13b"
+model = "QuantFactory/llm-compiler-7b-GGUF"
+# model = "file:///tmp/llm-compiler.gguf"
+
+tokenizer = AutoTokenizer.from_pretrained(model)
+pipeline = transformers.pipeline(
+    "text-generation",
+    model=model,
+    torch_dtype=torch.float16,
+    device_map="auto",
+)
+
+sequences = pipeline(
+    '%3 = alloca i32, align 4',
+    do_sample=True,
+    top_k=10,
+    temperature=0.1,
+    top_p=0.95,
+    num_return_sequences=1,
+    eos_token_id=tokenizer.eos_token_id,
+    max_length=200,
+)
+for seq in sequences:
+    print(f"Result: {seq['generated_text']}")

Attic/pancake-vdb.swift

@@ -0,0 +1,249 @@
+import Foundation
+
+// Token representation
+struct Token {
+    var token: String
+    var count: Int
+    var df: Int
+}
+
+// KD-Tree Node
+class KDNodeData {
+    let point: [Float]
+    let text: String
+    var left: KDNodeData?
+    var right: KDNodeData?
+    let splitDim: Int
+    
+    init(point: [Float], text: String, left: KDNodeData? = nil, right: KDNodeData? = nil, splitDim: Int) {
+        self.point = point
+        self.text = text
+        self.left = left
+        self.right = right
+        self.splitDim = splitDim
+    }
+}
+
+// Result for K-Nearest Neighbors
+struct KNNResult {
+    let node: KDNodeData
+    let distanceSq: Float
+}
+
+class VectorDB {
+    // Core database structures
+    private let dimension: Int
+    private var root: KDNodeData?
+    private var tokens: [Token] = []
+    private var totalDocs: Int = 0
+    private var size: Int = 0
+    
+    init(dimension: Int) {
+        self.dimension = dimension
+    }
+    
+    // Validate token (similar to C implementation)
+    private func isValidToken(_ token: String) -> Bool {
+        let invalidTokens = ["pancake", "author", "radare2"]
+        return !invalidTokens.contains(token)
+    }
+    
+    // Find a token in the token list
+    private func findToken(_ tokens: [Token], _ token: String) -> Token? {
+        return tokens.first { $0.token == token }
+    }
+    
+    // Compute embedding using TF-IDF approach
+    private func computeEmbedding(_ text: String) -> [Float] {
+        // Zero the embedding vector
+        var embedding = [Float](repeating: 0.0, count: dimension)
+        
+        // Tokenize and normalize
+        let words = text
+            .lowercased()
+            .replacingOccurrences(of: "[^a-z0-9\\s]", with: " ", options: .regularExpression)
+            .split(separator: " ")
+            .map { String($0) }
+            .filter { !$0.isEmpty }
+        
+        // Local document token frequency
+        var docTokens: [Token] = []
+        for token in words {
+            if let existingToken = findToken(docTokens, token) {
+                let index = docTokens.firstIndex { $0.token == token }!
+                docTokens[index].count += 1
+            } else {
+                docTokens.append(Token(token: token, count: 1, df: 0))
+            }
+        }
+        
+        // Increment total documents
+        totalDocs += 1
+        
+        // Update global document frequencies
+        for docToken in docTokens {
+            if let globalToken = findToken(self.tokens, docToken.token) {
+                if isValidToken(docToken.token) {
+                    let index = self.tokens.firstIndex { $0.token == docToken.token }!
+                    self.tokens[index].count += 1
+                    self.tokens[index].df += 1
+                }
+            } else {
+                self.tokens.append(Token(token: docToken.token, count: docToken.count, df: 1))
+            }
+        }
+        
+        // Compute TF-IDF and update embedding
+        for docToken in docTokens {
+            // Compute term frequency
+            let tf = 1 + log(Float(docToken.count))
+            
+            // Find global token to get document frequency
+            let dfValue = findToken(self.tokens, docToken.token)?.df ?? 1
+            
+            // Compute inverse document frequency
+            let idf = log(Float(totalDocs + 1) / Float(dfValue + 1)) + 1
+            
+            // Compute weight
+            let weight = tf * idf
+            
+            // Hash-based index assignment
+            let hash = simpleHash(docToken.token)
+            let index = hash % dimension
+            
+            // Add weighted value to embedding
+            embedding[index] += weight
+        }
+        
+        // L2 Normalize the embedding
+        return normalizeVector(embedding)
+    }
+    
+    // Simple string hash function
+    private func simpleHash(_ str: String) -> Int {
+        var hash = 0
+        for char in str.unicodeScalars {
+            hash = ((hash << 5) - hash) + Int(char.value)
+            hash = hash & hash // Convert to 32-bit integer
+        }
+        return abs(hash)
+    }
+    
+    // Normalize vector to unit length
+    private func normalizeVector(_ vec: [Float]) -> [Float] {
+        let normSq = vec.reduce(0) { $0 + $1 * $1 }
+        if normSq > 0 {
+            let norm = sqrt(normSq)
+            return vec.map { $0 / norm }
+        }
+        return vec
+    }
+    
+    // Compute squared Euclidean distance
+    private func squaredDistance(_ a: [Float], _ b: [Float]) -> Float {
+        guard a.count == b.count else { return Float.greatestFiniteMagnitude }
+        return zip(a, b).reduce(0) { $0 + pow($1.0 - $1.1, 2) }
+    }
+    
+    // Recursive KD-Tree insertion
+    private func insertRecursive(_ node: KDNodeData?, point: [Float], text: String, depth: Int) -> KDNodeData {
+        guard let currentNode = node else {
+            return KDNodeData(point: point, text: text, splitDim: depth % dimension)
+        }
+        
+        let axis = currentNode.splitDim
+        if point[axis] < currentNode.point[axis] {
+            currentNode.left = insertRecursive(currentNode.left, point: point, text: text, depth: depth + 1)
+        } else {
+            currentNode.right = insertRecursive(currentNode.right, point: point, text: text, depth: depth + 1)
+        }
+        
+        return currentNode
+    }
+    
+    // Insert a document into the vector database
+    func insert(_ text: String) {
+        guard !text.isEmpty else { return }
+        
+        // Compute embedding
+        let embedding = computeEmbedding(text)
+        
+        // Insert into KD-Tree
+        root = insertRecursive(root, point: embedding, text: text, depth: 0)
+        size += 1
+    }
+    
+    // K-Nearest Neighbors search
+    func query(_ text: String, k: Int) -> [String] {
+        guard !text.isEmpty, root != nil else { return [] }
+        
+        // Compute query embedding
+        let queryEmbedding = computeEmbedding(text)
+        
+        // Initialize result set
+        var results: [KNNResult] = []
+        
+        // Recursive KNN search
+        func searchRecursive(_ node: KDNodeData?, query: [Float], depth: Int) {
+            guard let node = node else { return }
+            
+            // Compute distance and potentially insert into results
+            let distSq = squaredDistance(query, node.point)
+            
+            if results.count < k {
+                results.append(KNNResult(node: node, distanceSq: distSq))
+                // Maintain max-heap property
+                results.sort { $0.distanceSq > $1.distanceSq }
+            } else if distSq < results[0].distanceSq {
+                results[0] = KNNResult(node: node, distanceSq: distSq)
+                results.sort { $0.distanceSq > $1.distanceSq }
+            }
+            
+            // Decide which subtree to search first
+            let axis = node.splitDim
+            let diff = query[axis] - node.point[axis]
+            let first = diff < 0 ? node.left : node.right
+            let second = diff < 0 ? node.right : node.left
+            
+            // Recursively search
+            searchRecursive(first, query: query, depth: depth + 1)
+            
+            // Potentially search the other subtree
+            if results.count < k || diff * diff < results[0].distanceSq {
+                searchRecursive(second, query: query, depth: depth + 1)
+            }
+        }
+        
+        // Perform the search
+        searchRecursive(root, query: queryEmbedding, depth: 0)
+        
+        // Sort results and return texts
+        return results
+            .sorted { $0.distanceSq < $1.distanceSq }
+            .map { $0.node.text }
+    }
+    
+    // Get total number of documents
+    func getSize() -> Int {
+        return size
+    }
+}
+
+// Example usage
+func main() {
+    // Create a vector database with 64-dimensional embeddings
+    let db = VectorDB(dimension: 64)
+    
+    // Insert some sample documents
+    db.insert("The quick brown fox jumps over the lazy dog")
+    db.insert("A quick brown fox is very quick")
+    db.insert("The author of radare2 is name / named pancake")
+    db.insert("The lazy dog sleeps all day")
+    
+    // Query for similar documents
+    let results = db.query("who is the author of radare2?", k: 2)
+    print("Similar documents:", results)
+}
+
+// Run example
+main()

Attic/py/Makefile

@@ -0,0 +1,81 @@
+R2_USER_PLUGINS=$(shell r2 -H R2_USER_PLUGINS)
+
+PWD=$(shell pwd)
+R2PM_BINDIR=$(shell r2pm -H R2PM_BINDIR)
+PV=3.12
+ifeq ($(shell which python${PV} > /dev/null && echo ok),ok)
+PYTHON?=python${PV}
+else
+PYTHON?=python3
+endif
+PIP=$(PYTHON) -m pip
+
+ifeq ($(R2PM_BINDIR),)
+MISSING RADARE2
+endif
+
+LINTED=r2ai/code_block.py
+LINTED+=r2ai/bubble.py
+LINTED+=r2ai/const.py
+LINTED+=r2ai/backend/kobaldcpp.py
+# LINTED+=r2ai/index.py
+# LINTED+=r2ai/voice.py
+# LINTED+=r2ai/anthropic.py
+r2ai-python py python r2aipy: venv
+	@./r2ai.sh
+
+large:
+	. venv/bin/activate ; $(PYTHON) -m r2ai.cli -l
+
+all.old:
+	@test -n "${VIRTUAL_ENV}" || (echo "Run:"; echo ". venv/bin/activate" ; exit 1)
+	$(PYTHON) main.py || $(MAKE) deps
+
+venv:
+	$(PYTHON) -m venv venv
+	if [ -z "`find venv | grep llama_cpp`" ]; then . venv/bin/activate ; pip install . ; fi
+
+deps: venv
+	#test -n "${VIRTUAL_ENV}" || (echo "Run: . venv/bin/activate" ; exit 1)
+	. venv/bin/activate && export CMAKE_ARGS="-DLLAMA_METAL=on -DLLAMA_METAL_EMBED_LIBRARY=ON" && \
+		pip install --force-reinstall -U --no-cache-dir .
+clean:
+	rm -rf venv
+	rm -rf build
+	find . -name "*.egg-info" -exec rm -rf {} +
+
+user-install:
+	rm -f $(R2PM_BINDIR)/r2ai
+	ln -fs $(PWD)/r2ai.sh $(R2PM_BINDIR)/r2ai
+
+install: user-install
+	-mkdir -p /usr/local/share/man/man1/r2ai.1
+	-cp doc/usage/r2ai.1 /usr/local/share/man/man1/r2ai.1
+
+install-plugin user-install-plugin:
+	ln -fs $(PWD)/r2ai/plugin.py $(R2_USER_PLUGINS)/r2ai.py
+
+uninstall user-uninstall:
+	rm -f $(R2PM_BINDIR)/r2ai
+	-rm -f /usr/local/share/man/man1/r2ai.1
+
+user-uninstall-plugin uninstall-plugin:
+	rm -f $(R2_USER_PLUGINS)/r2ai.py
+
+pub:
+	$(PYTHON) -m build
+	twine check dist/*
+	twine upload -u __token__ --repository-url https://upload.pypi.org/legacy/ --verbose dist/*
+
+pylint lint cilint:
+	. venv/bin/activate ; pylint $(LINTED)
+
+lintall:
+	pylint *.py r2ai/*.py
+
+.PHONY: lint lintall
+
+deps-global:
+	export CMAKE_ARGS="-DLLAMA_METAL=on -DLLAMA_METAL_EMBED_LIBRARY=ON" && \
+		$(PIP) install --force-reinstall -U --break-system-packages --no-cache-dir .
+

Attic/py/README.md

@@ -0,0 +1,155 @@
+# r2ai-python
+
+This directory contains the original implementation of the AI support for radare2 written in Python.
+
+It is considered _deprecated_, but it's still useful and aims to be maintained, we recommend using decai or the C rewrite as alternatives.
+
+The Python implementation consists in a module can be used in 3 different ways:
+
+* commandline repl using r2pipe to spawn or connect to remote radare2 instances
+* radare2 core plugin that is instantiated when placing it in the radare2 plugin's directory
+* Python API to be used for writing your own scripts
+
+## API Providers
+
+The Python implementation focused on supporting the LlamaCpp Python module, which is somehow heavy to load in many environments, but it also supports litellm which provides access to many external connectors like ollama, openai, anthropic, gemini, etc.
+
+## Deprecation Reasons
+
+There are several reasons why this implementation is considered deprecated and not recommended to use:
+
+1) It's Python.
+
+ - Aka, it's slow, heavy loads in same process
+ - Your system probably have multiple versions installed
+ - The shell and radare2 python bindings are probably not the same
+ - Required venv to be created (at least an extra 1GB)
+ - Not typed, regressions and bugs appear at runtime
+
+2) Goto 1
+
+### Windows
+
+On Windows you may follow the same instructions, just ensure you have the right python environment ready and create the venv to use
+
+```cmd
+git clone https://github.com/radareorg/r2ai
+cd r2ai
+set PATH=C:\Users\YOURUSERNAME\Local\Programs\Python\Python39\;%PATH%
+python3 -m pip install .
+python3 main.py
+```
+
+### Selecting the model
+
+- List all downloaded models: `-m`
+- Get a short list of models: `-MM`
+- Help: `-h`
+
+**Example selecting a remote models:**
+
+```
+[r2ai:0x00006aa0]> -m anthropic:claude-sonnet-5-5
+[r2ai:0x00006aa0]> -m openai:gpt-4
+```
+
+**Example downloading a free local AI: Mistral 7B v0.2:**
+
+Launch r2ai, select the model and ask a question. If the model isn't downloaded yet, r2ai will ask you which precise version to download.
+
+```
+[r2ai:0x00006aa0]> -m TheBloke/Mistral-7B-Instruct-v0.2-GGUF
+```
+
+Then ask your question, and r2ai will automatically download if needed:
+
+```
+[r2ai:0x00006aa0]> give me a short algorithm to test prime numbers
+Select TheBloke/Mistral-7B-Instruct-v0.2-GGUF model. See -M and -m flags
+[?] Quality (smaller is faster): 
+ > Small | Size: 2.9 GB, Estimated RAM usage: 5.4 GB
+   Medium | Size: 3.9 GB, Estimated RAM usage: 6.4 GB
+   Large | Size: 7.2 GB, Estimated RAM usage: 9.7 GB
+   See More
+
+[?] Quality (smaller is faster): 
+ > mistral-7b-instruct-v0.2.Q2_K.gguf | Size: 2.9 GB, Estimated RAM usage: 5.4 GB
+   mistral-7b-instruct-v0.2.Q3_K_L.gguf | Size: 3.6 GB, Estimated RAM usage: 6.1 GB
+   mistral-7b-instruct-v0.2.Q3_K_M.gguf | Size: 3.3 GB, Estimated RAM usage: 5.8 GB
+   mistral-7b-instruct-v0.2.Q3_K_S.gguf | Size: 2.9 GB, Estimated RAM usage: 5.4 GB
+   mistral-7b-instruct-v0.2.Q4_0.gguf | Size: 3.8 GB, Estimated RAM usage: 6.3 GB
+   mistral-7b-instruct-v0.2.Q4_K_M.gguf | Size: 4.1 GB, Estimated RAM usage: 6.6 GB
+   mistral-7b-instruct-v0.2.Q4_K_S.gguf | Size: 3.9 GB, Estimated RAM usage: 6.4 GB
+   mistral-7b-instruct-v0.2.Q5_0.gguf | Size: 4.7 GB, Estimated RAM usage: 7.2 GB
+   mistral-7b-instruct-v0.2.Q5_K_M.gguf | Size: 4.8 GB, Estimated RAM usage: 7.3 GB
+   mistral-7b-instruct-v0.2.Q5_K_S.gguf | Size: 4.7 GB, Estimated RAM usage: 7.2 GB
+   mistral-7b-instruct-v0.2.Q6_K.gguf | Size: 5.5 GB, Estimated RAM usage: 8.0 GB
+   mistral-7b-instruct-v0.2.Q8_0.gguf | Size: 7.2 GB, Estimated RAM usage: 9.7 GB
+
+[?] Use this model by default? ~/.r2ai.model: 
+ > Yes
+   No
+
+[?] Download to ~/.local/share/r2ai/models? (Y/n): Y
+```
+
+**Example selecting a local model served by Ollama**
+
+Download a model and make it available through Ollama:
+
+```
+$ ollama ls
+NAME                  ID              SIZE      MODIFIED     
+codegeex4:latest      867b8e81d038    5.5 GB    23 hours ago  
+```
+
+Use it from r2ai by prefixing its name with `ollama/`
+
+```
+[r2ai:0x00002d30]> -m ollama/codegeex4:latest
+[r2ai:0x00002d30]> hi
+Hello! How can I assist you today?
+```
+
+### Standard/Auto mode
+
+The standard mode is invoked by directly asking the question.
+For the Auto mode, the question **must be prefixed** by `' ` (quote + space). The AI may instruct r2ai to run various commands. Those commands are run on *your host*, so you will be asked to review them before they run.
+
+Example in "standard" mode:
+
+```
+[r2ai:0x00006aa0]> compute 4+5
+4 + 5 = 9
+[r2ai:0x00006aa0]> draw me a pancake in ASCII art
+Sure, here's a simple ASCII pancake:
+
+  _____  
+ (     )
+ (     )
+  -----
+```
+
+Example in auto mode:
+
+```
+[r2ai:0x00006aa0]>' Decompile the main
+[..]
+r2ai is going to execute the following command on the host
+Want to edit? (ENTER to validate) pdf @ fcn.000015d0
+This command will execute on this host: pdf @ fcn.000015d0. Agree? (y/N) y
+```
+
+If you wish to edit the command, you can do it inline for short one line commands, or an editor will pop up.
+
+### r2ai Configuration settings
+
+List all settings with `-e`
+
+| Key         | Explanation                           |
+| ----------- | ------------------------------------- |
+| debug_level | All verbose messages for level 1. Default is 2 |
+| auto.max_runs | Maximum number of questions the AI is allowed to ask r2 in auto mode. |
+| auto.hide_tool_output | By default false, consequently output of r2cmd, run_python etc is shown. Set to `true` to hide those internal messages. |
+| chat.show_cost | Show the cost of each request to the AI if true |
+

Attic/py/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "r2ai"
 dynamic = ["readme"]
-version = "0.9.4"
+version = "0.9.6"
 description = "Artificial intelligence tooling for radare2"
 
 license = {text = "MIT License"}

Attic/py/r2ai/auto.py

@@ -83,8 +83,8 @@ class ChatAuto:
         init_prompt = ""
         
         if not self.llama_instance:
-
-            model_info = litellm.get_model_info(self.model)
+            rmodel = re.sub(r'ft:([^:]+).*', r'\1', self.model)
+            model_info = litellm.get_model_info(rmodel)
             self.max_tokens = min(self.max_tokens, model_info['max_tokens'])
 
             if self.model.startswith('openai/o'):

Attic/py/r2ai/interpreter.py

@@ -163,7 +163,7 @@ class Interpreter:
         self.env["chat.rawdog"] = "false"
         self.env["chat.reasoning_effort"] = "high"
         self.env["chat.stream"] = "true"
-        self.env["chat.show_cost"] = "true"
+        self.env["chat.show_cost"] = "false"
         self.env["chat.drop_params"] = "false"
         self.env["chat.openai_store"] = "false"
         self.env["auto.max_runs"] = "100"

Attic/py/r2ai/models.py

@@ -62,7 +62,7 @@ Uncensored:
 Remote:
 -m openapi:http://localhost:5001
 -m openai:gpt-4
--m anthropic:claude-3-7-sonnet-20250219
+-m anthropic:claude-sonnet-5-5
 -m bedrock:anthropic.claude-3-5-sonnet-20241022-v1
 -m kobaldcpp:http://localhost:5001
 """
@@ -80,12 +80,9 @@ OpenAI:
 -m openai:gpt-4
 -m openai:gpt-4-1106-preview
 Anthropic:
--m anthropic:claude-2.1
--m anthropic:claude-3-haiku-20240307
--m anthropic:claude-3-opus-20240229
--m anthropic:claude-3-sonnet-20240229
--m anthropic:claude-3-5-sonnet-20241022
--m anthropic:claude-3-7-sonnet-20250219
+-m anthropic:claude-opus-4-8
+-m anthropic:claude-sonnet-5-5
+-m anthropic:claude-haiku-4-5-20251001
 groq:
 -m groq:gemma-7b-it
 -m groq:llama2-70b-4096

Attic/py/r2ai/repl.py

@@ -170,8 +170,7 @@ def slurp_until(endword):
 def list_models():
     print("ollama/llama3:latest")
     print("ollama/granite-code:8b")
-    print("anthropic/claude-3-5-sonnet-20240620")
-    print("anthropic/claude-3-7-sonnet-20250219")
+    print("anthropic/claude-sonnet-5-5")
     print("openai/gpt-4o")
     print("mistral/mistral-tiny")
 

Attic/py/r2ai/voice.py

@@ -50,8 +50,16 @@ def stt(seconds, lang):
         return
     tts("(r2ai) listening for 5s... ", "digues?", lang)
     print(f"DEVICE IS {device}")
-    os.system("rm -f .audiomsg.wav")
-    rc = os.system(f"ffmpeg -f avfoundation -t 5 -i '{device}' .audiomsg.wav > /dev/null 2>&1")
+    try:
+        os.remove(".audiomsg.wav")
+    except OSError:
+        pass
+    result = subprocess.run(
+        ["ffmpeg", "-f", "avfoundation", "-t", "5", "-i", device, ".audiomsg.wav"],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL
+    )
+    rc = result.returncode
     if rc != 0:
         tts("(r2ai)", "cannot record from microphone. missing permissions in terminal?", lang)
         return
@@ -60,7 +68,10 @@ def stt(seconds, lang):
         result = model.transcribe(".audiomsg.wav")
     else:
         result = model.transcribe(".audiomsg.wav", language=lang)
-    os.system("rm -f .audiomsg.wav")
+    try:
+        os.remove(".audiomsg.wav")
+    except OSError:
+        pass
     tts("(r2ai)", "ok", lang)
     text = result["text"].strip()
     if text == "you":

Attic/server/Makefile

@@ -3,12 +3,17 @@ R2PM_BINDIR=$(shell r2pm -H R2PM_BINDIR)
 R2_BINDIR=$(shell r2 -H R2_BINDIR)
 
 install:
+#	rm -f $(R2PM_BINDIR)/r2ai-server
+#	ln -fs $(PWD)/r2ai-server/r2ai-server $(R2PM_BINDIR)/r2ai-server
+	mkdir -p $(R2_BINDIR)
 	cp -f r2ai-server $(R2_BINDIR)/r2ai-server || echo Maybe use user-install instead?
 
 uninstall:
 	rm -f $(R2_BINDIR)/r2ai-server
 
 user-install:
+	mkdir -p $(R2PM_BINDIR)
+	rm -f $(R2PM_BINDIR)/r2ai-server
 	ln -fs $(PWD)/r2ai-server $(R2PM_BINDIR)/r2ai-server
 
 user-uninstall:

Attic/server/README.md

@@ -0,0 +1,25 @@
+# r2ai-server
+
+Start ollama, llamacpp, llamafile, r2ai, kobaldcpp and other language model webservers using a the same syntax for all of them to simplify its launching and setup.
+
+* Use -l to list the implementations available
+
+You can install more via r2pm
+
+* Use -m to list or select the model. Those models can be absolute paths or model names when downloaded via r2ai, which uses the hugging face api
+
+## Running r2ai-server
+
+- Get usage: `r2pm -r r2ai-server`
+- List available servers: `r2pm -r r2ai-server -l`
+- List available models: `r2pm -r r2ai-server -m`
+
+On Linux, models are stored in `~/.r2ai.models/`. File `~/.r2ai.model` lists the default model and other models.
+
+**Example launching a local Mistral AI server:**
+
+```
+$ r2pm -r r2ai-server -l r2ai -m mistral-7b-instruct-v0.2.Q2_K
+[12/13/24 10:35:22] INFO     r2ai.server - INFO - [R2AI] Serving at port 8080                               web.py:336
+```
+

MANIFEST.in

@@ -1 +0,0 @@
-recursive-include r2ai/ui *.tcss

Makefile

@@ -1,93 +1,9 @@
-R2_USER_PLUGINS=$(shell r2 -H R2_USER_PLUGINS)
-PWD=$(shell pwd)
-R2PM_BINDIR=$(shell r2pm -H R2PM_BINDIR)
-PV=3.12
-ifeq ($(shell which python${PV} > /dev/null && echo ok),ok)
-PYTHON?=python${PV}
-else
-PYTHON?=python3
-endif
-PIP=$(PYTHON) -m pip
+TARGETS=all clean mrproper user-install install user-uninstall uninstall fmt indent
 
-LINTED=r2ai/code_block.py
-LINTED+=r2ai/bubble.py
-LINTED+=r2ai/const.py
-LINTED+=r2ai/backend/kobaldcpp.py
-# LINTED+=r2ai/index.py
-# LINTED+=r2ai/voice.py
-# LINTED+=r2ai/anthropic.py
+$(TARGETS):
+	$(MAKE) -C src $@
 
-ifeq ($(R2PM_BINDIR),)
-FATAL ERROR
-endif
+test: all
+	$(MAKE) -C test
 
-.PHONY: all all.old deps clean deps-global pub lint cilint
-.PHONY: install uninstall user-install user-uninstall
-
-all: venv
-	@./r2ai.sh
-
-large:
-	. venv/bin/activate ; $(PYTHON) -m r2ai.cli -l
-
-all.old:
-	@test -n "${VIRTUAL_ENV}" || (echo "Run:"; echo ". venv/bin/activate" ; exit 1)
-	$(PYTHON) main.py || $(MAKE) deps
-
-venv:
-	$(PYTHON) -m venv venv
-	if [ -z "`find venv | grep llama_cpp`" ]; then . venv/bin/activate ; pip install . ; fi
-
-deps: venv
-	#test -n "${VIRTUAL_ENV}" || (echo "Run: . venv/bin/activate" ; exit 1)
-	. venv/bin/activate && export CMAKE_ARGS="-DLLAMA_METAL=on -DLLAMA_METAL_EMBED_LIBRARY=ON" && \
-		pip install --force-reinstall -U --no-cache-dir .
-
-clean:
-	rm -rf venv
-	rm -rf build
-	find . -name "*.egg-info" -exec rm -rf {} +
-
-mrproper:
-	$(MAKE) clean
-
-deps-global:
-	export CMAKE_ARGS="-DLLAMA_METAL=on -DLLAMA_METAL_EMBED_LIBRARY=ON" && \
-		$(PIP) install --force-reinstall -U --break-system-packages --no-cache-dir .
-
-user-install:
-	rm -f $(R2PM_BINDIR)/r2ai-server
-	ln -fs $(PWD)/r2ai-server/r2ai-server $(R2PM_BINDIR)/r2ai-server
-	rm -f $(R2PM_BINDIR)/r2ai
-	ln -fs $(PWD)/r2ai.sh $(R2PM_BINDIR)/r2ai
-
-install: user-install
-	-mkdir -p /usr/local/share/man/man1/r2ai.1
-	-cp doc/usage/r2ai.1 /usr/local/share/man/man1/r2ai.1
-
-install-decai:
-	$(MAKE) -C decai user-install
-
-install-server:
-	$(MAKE) -C r2ai-server user-install
-
-install-plugin user-install-plugin:
-	ln -fs $(PWD)/r2ai/plugin.py $(R2_USER_PLUGINS)/r2ai.py
-
-uninstall user-uninstall:
-	rm -f $(R2PM_BINDIR)/r2ai
-	-rm -f /usr/local/share/man/man1/r2ai.1
-
-user-uninstall-plugin uninstall-plugin:
-	rm -f $(R2_USER_PLUGINS)/r2ai.py
-
-pub:
-	$(PYTHON) -m build
-	twine check dist/*
-	twine upload -u __token__ --repository-url https://upload.pypi.org/legacy/ --verbose dist/*
-
-cilint:
-	pylint $(LINTED)
-
-lint:
-	pylint *.py r2ai/*.py
+.PHONY: $(TARGETS) test

README.md

@@ -1,391 +1,115 @@
-```
-,______  .______ .______  ,___
-: __   \ \____  |:      \ : __|
-|  \____|/  ____||  _,_  || : |
-|   :  \ \   .  ||   :   ||   |
-|   |___\ \__:__||___|   ||   |
-|___|        :       |___||___|
-             *
+# R2AI - Augmented reversing with LLM for radare2
+
+```console
+         ╭─────────────────────────────────╮
+         │ ,______  .______ .______  ,___  │
+ ╭──╮    │ : __   \ \____  |:      \ : __| │
+ │ _│_   │ |  \____|/  ____||  _,_  || : | │
+ │ O O  <  |   :  \ \   .  ||   :   ||   | │
+ │  │╷   │ |   |___\ \__:__||___|   ||   | │
+ │  ││   │ |___|        :       |___||___| │
+ │ ─╯│   ╰─────────────────────────────────╯
+ ╰───╯
 ```
 
 [![ci](https://github.com/radareorg/r2ai/actions/workflows/ci.yml/badge.svg)](https://github.com/radareorg/r2ai/actions/workflows/ci.yml)
-
-Run a language model to entertain you or help answering questions about radare2 or reverse engineering in general. The language model may be local (running without Internet on your host) or remote (e.g if you have an API key). Note that models used by r2ai are pulled from external sources which may behave different or respond unreliable information. That's why there's an ongoing effort into improving the post-finetuning using memgpt-like techniques which can't get better without your help!
-
-<p align="center">
-  <img src="doc/r2clippy.jpg">
-</p>
+[![radare2](https://img.shields.io/badge/radare2-6.0.4-green)](https://github.com/radareorg/radare2)
 
 ## Components
 
-R2AI is structured into four independent components:
+This repository contains two plugins for radare2:
 
-* r2ai (python cli tool)
-  * r2-like repl using r2pipe to comunicate with r2
-  * supports auto solving mode
-  * client and server openapi protocol
-  * download and manage models from huggingface
-* decai (r2js plugin focus on decompilation)
-  * adds 'decai' command to the r2 shell
-  * talks to local or remote services with curl
-  * focus on decompilation
-* *r2ai-plugin*
-  * Native plugin written in C
-  * adds r2ai command inside r2
-* r2ai-server
-  * favour *ollama* instead
-  * list and select models downloaded from r2ai
-  * simple cli tool to start local openapi webservers
-  * supports llamafile, llamacpp, r2ai-w and kobaldcpp
-  
+* **r2ai** - native [AI plugin](./src/README.md) for radare2
+* **decai** - r2js plugin with special [focus on decompilation](./decai/README.md)
+
+If you are looking to use radare2 with other agents via MCP:
+
+* **r2mcp** - the [official radare2 mcp](https://github.com/radare2/radare2-mcp)
+* **r2copilot** - the mcp with focus on CTF [r2copilot](https://github.com/darallium/r2-copilot)
+
+If you are looking for a radare2 focused autonomous agent:
+* **r2agent** - automate radare2 workflows through autonomous agents. [r2agent](https://github.com/nitanmarcel/r2agent)
 
 ## Features
 
-* Support Auto mode to solve tasks using function calling
-* Use local and remote language models (llama, ollama, openai, anthropic, ..)
-* Support OpenAI, Anthropic, Bedrock
-* Index large codebases or markdown books using a vector database
-* Slurp file and perform actions on that
-* Embed the output of an r2 command and resolve questions on the given data
-* Define different system-level assistant role
-* Set environment variables to provide context to the language model
+* Configure different roles and customize prompts
+* Scriptable via r2pipe via the r2ai command
 * Live with repl and batch mode from cli or r2 prompt
-* Scriptable via r2pipe
-* Use different models, dynamically adjust query template
-* Load multiple models and make them talk between them
+* Support Automatic (ReAct) mode to solve tasks using function calling
+* Use local and remote language models (ollama, openai, grok, anthropic, ..)
+* RAG markdown, code or textfiles using its native vector database
+* Embed the output of an r2 command and resolve questions on the given data
+
+## User defined Prompts
+
+```console
+[0x00000000]> r2ai -q
+explain: Explain the current function -
+devices: Find and explain devices used -
+libs: Group imports by Libraries -
+varnames: Better variable names -
+autoname: Automatically suggest a better name for this function -
+vulns: Find vulnerabilities or bugs in the current function -
+signature: Suggest an improved function signature -
+dlopen: List libraries loaded with dlopen - Some libraries are loaded
+decompile: Augmented decompilation based on LLM -
+[0x00000000]>
+```
 
 ## Installation
 
-### From r2pm
+The recommended way to install any of the r2ai components is via r2pm:
 
-Install the various components via `r2pm`:
-
-- `r2pm -ci r2ai`
-- `r2pm -ci r2ai-plugin`
-- `r2pm -ci decai`
-- `r2pm -ci r2ai-server`
-
-### From sources
-
-Running `make` will setup a python virtual environment in the current directory installing all the necessary dependencies and will get into a shell to run r2ai.
-
-The installation is now splitted into two different targets:
-
-* `make install` will place a symlink in `$BINDIR/r2ai`
-* `make install-decai` will install the decai r2js decompiler plugin
-* `make install-server` will install the r2ai-server
-
-### Windows
-
-On Windows you may follow the same instructions, just ensure you have the right python environment ready and create the venv to use
-
-```cmd
-git clone https://github.com/radareorg/r2ai
-cd r2ai
-set PATH=C:\Users\YOURUSERNAME\Local\Programs\Python\Python39\;%PATH%
-python3 -m pip install .
-python3 main.py
+```console
+$ r2pm -Uci r2ai
+$ r2pm -Uci decai
 ```
 
-## Running r2ai
+## Using r2ai
 
-### Launch r2ai
+- Adds the **r2ai** command to the radare2 shell: `r2 -qc r2ai`
+- You can also run the wrapper in $PATH: `r2pm -r r2ai`
 
-- If you installed via r2pm, you can execute it like this: `r2pm -r r2ai`
-- Otherwise, `./r2ai.sh [/absolute/path/to/binary]`
+Drop your API keys in environment variables or use the configuration file:
 
-If you have an **API key**, put it in the adequate file:
-
-| AI        | API key                    |
-| --------- | -------------------------- |
-| OpenAI    | `$HOME/.r2ai.openai-key` |
-| Gemini    | `$HOME/.r2ai.gemini-key` |
-| Anthropic | `$HOME/.r2ai.anthropic-key` |
-| Mistral   | `$HOME/.r2ai.mistral-key` |
-
-Example using an Anthropic API key:
-
-```
-$ cat ~/.r2ai.anthropic-key 
-sk-ant-api03-CENSORED
+```console
+$ export ANTHROPIC_API_KEY=sk-ant-api03-CENSORED
+$ export OPENAI_API_KEY=sk-proj-6rlSPS-zN1v...
 ```
 
-### Selecting the model
+Or edit the api keys file `~/.config/r2ai/apikeys.txt` run:
 
-- List all downloaded models: `-m`
-- Get a short list of models: `-MM`
-- Help: `-h`
-
-**Example selecting a remote models:**
-
-```
-[r2ai:0x00006aa0]> -m anthropic:claude-3-7-sonnet-20250219
-[r2ai:0x00006aa0]> -m openai:gpt-4
+```console
+$ r2ai -K
 ```
 
-**Example downloading a free local AI: Mistral 7B v0.2:**
+## Saving settings
 
-Launch r2ai, select the model and ask a question. If the model isn't downloaded yet, r2ai will ask you which precise version to download.
+You may customize and save your configuration settings using your OS's default settings file (e.g `~/.radare2rc` on Linux).
+For example, the following configuration sets Claude 3.7 by default, with max output tokens to 64000.
 
-```
-[r2ai:0x00006aa0]> -m TheBloke/Mistral-7B-Instruct-v0.2-GGUF
+
+```console
+$ r2ai -E
 ```
 
-Then ask your question, and r2ai will automatically download if needed:
+then you can type the commands you want to run when the r2ai plugin is loaded:
 
-```
-[r2ai:0x00006aa0]> give me a short algorithm to test prime numbers
-Select TheBloke/Mistral-7B-Instruct-v0.2-GGUF model. See -M and -m flags
-[?] Quality (smaller is faster): 
- > Small | Size: 2.9 GB, Estimated RAM usage: 5.4 GB
-   Medium | Size: 3.9 GB, Estimated RAM usage: 6.4 GB
-   Large | Size: 7.2 GB, Estimated RAM usage: 9.7 GB
-   See More
-
-[?] Quality (smaller is faster): 
- > mistral-7b-instruct-v0.2.Q2_K.gguf | Size: 2.9 GB, Estimated RAM usage: 5.4 GB
-   mistral-7b-instruct-v0.2.Q3_K_L.gguf | Size: 3.6 GB, Estimated RAM usage: 6.1 GB
-   mistral-7b-instruct-v0.2.Q3_K_M.gguf | Size: 3.3 GB, Estimated RAM usage: 5.8 GB
-   mistral-7b-instruct-v0.2.Q3_K_S.gguf | Size: 2.9 GB, Estimated RAM usage: 5.4 GB
-   mistral-7b-instruct-v0.2.Q4_0.gguf | Size: 3.8 GB, Estimated RAM usage: 6.3 GB
-   mistral-7b-instruct-v0.2.Q4_K_M.gguf | Size: 4.1 GB, Estimated RAM usage: 6.6 GB
-   mistral-7b-instruct-v0.2.Q4_K_S.gguf | Size: 3.9 GB, Estimated RAM usage: 6.4 GB
-   mistral-7b-instruct-v0.2.Q5_0.gguf | Size: 4.7 GB, Estimated RAM usage: 7.2 GB
-   mistral-7b-instruct-v0.2.Q5_K_M.gguf | Size: 4.8 GB, Estimated RAM usage: 7.3 GB
-   mistral-7b-instruct-v0.2.Q5_K_S.gguf | Size: 4.7 GB, Estimated RAM usage: 7.2 GB
-   mistral-7b-instruct-v0.2.Q6_K.gguf | Size: 5.5 GB, Estimated RAM usage: 8.0 GB
-   mistral-7b-instruct-v0.2.Q8_0.gguf | Size: 7.2 GB, Estimated RAM usage: 9.7 GB
-
-[?] Use this model by default? ~/.r2ai.model: 
- > Yes
-   No
-
-[?] Download to ~/.local/share/r2ai/models? (Y/n): Y
+```console
+r2ai -e api=anthropic
+r2ai -e model=claude-sonnet-5-5
+r2ai -e max_tokens=64000
 ```
 
-**Example selecting a local model served by Ollama**
-
-Download a model and make it available through Ollama:
-
-```
-$ ollama ls
-NAME                  ID              SIZE      MODIFIED     
-codegeex4:latest      867b8e81d038    5.5 GB    23 hours ago  
-```
-
-Use it from r2ai by prefixing its name with `ollama/`
-
-```
-[r2ai:0x00002d30]> -m ollama/codegeex4:latest
-[r2ai:0x00002d30]> hi
-Hello! How can I assist you today?
-```
-
-### Standard/Auto mode
-
-The standard mode is invoked by directly asking the question.
-For the Auto mode, the question **must be prefixed** by `' ` (quote + space). The AI may instruct r2ai to run various commands. Those commands are run on *your host*, so you will be asked to review them before they run.
-
-Example in "standard" mode:
-
-```
-[r2ai:0x00006aa0]> compute 4+5
-4 + 5 = 9
-[r2ai:0x00006aa0]> draw me a pancake in ASCII art
-Sure, here's a simple ASCII pancake:
-
-  _____  
- (     )
- (     )
-  -----
-```
-
-Example in auto mode:
-
-```
-[r2ai:0x00006aa0]>' Decompile the main
-[..]
-r2ai is going to execute the following command on the host
-Want to edit? (ENTER to validate) pdf @ fcn.000015d0
-This command will execute on this host: pdf @ fcn.000015d0. Agree? (y/N) y
-```
-
-If you wish to edit the command, you can do it inline for short one line commands, or an editor will pop up.
-
-### r2ai Configuration settings
-
-List all settings with `-e`
-
-| Key         | Explanation                           |
-| ----------- | ------------------------------------- |
-| debug_level | All verbose messages for level 1. Default is 2 |
-| auto.max_runs | Maximum number of questions the AI is allowed to ask r2 in auto mode. |
-| auto.hide_tool_output | By default false, consequently output of r2cmd, run_python etc is shown. Set to `true` to hide those internal messages. |
-| chat.show_cost | Show the cost of each request to the AI if true |
-
-
-## Running r2ai-server
-
-- Get usage: `r2pm -r r2ai-server`
-- List available servers: `r2pm -r r2ai-server -l`
-- List available models: `r2pm -r r2ai-server -m`
-
-On Linux, models are stored in `~/.r2ai.models/`. File `~/.r2ai.model` lists the default model and other models.
-
-**Example launching a local Mistral AI server:**
-
-```
-$ r2pm -r r2ai-server -l r2ai -m mistral-7b-instruct-v0.2.Q2_K
-[12/13/24 10:35:22] INFO     r2ai.server - INFO - [R2AI] Serving at port 8080                               web.py:336
-```
-
-## Running decai
-
-Decai is used from `r2` (e.g `r2 ./mybinary`). Get help with `decai -h`:
-
-```
-[0x00406cac]> decai -h
-Usage: decai (-h) ...
- decai -H         - help setting up r2ai
- decai -a [query] - solve query with auto mode
- decai -d [f1 ..] - decompile given functions
- decai -dr        - decompile function and its called ones (recursive)
- decai -dd [..]   - same as above, but ignoring cache
- decai -dD [query]- decompile current function with given extra query
- ...
-```
-
-List configuration variables with `decai -e`:
-
-```
-[0x00406cac]> decai -e
-decai -e api=ollama
-decai -e host=http://localhost
-decai -e port=11434
-decai -e prompt=Rewrite this function and respond ONLY with code, NO explanations, NO markdown, Change 'goto' into if/else/for/while, Simplify as much as possible, use better variable names, take function arguments and strings from comments like 'string:'
-decai -e ctxfile=
-...
-```
-
-List possible APIs to discuss with AI: `decai -e api=?`:
-
-```
-[0x00406cac]> decai -e api=?
-r2ai
-claude
-openapi
-...
-```
-
-### Example using a local model and ollama
-
-For example, if Ollama serves model codegeex4:latest (`ollama ls`), set decai API as `ollama` and model `codegeex4:latest`.
-
-```
-[0x00002d30]> decai -e api=ollama
-[0x00002d30]> decai -e model=codegeex4:latest
-[0x00002d30]> decai -q Explain what forkpty does in 2 lines
-The `forkpty` function creates a new process with a pseudo-terminal, allowing the parent to interact with the child via standard input/output/err and controlling its terminal.
-```
-
-
-
-### Example using a local Mistral model and r2ai-server
-
-For example, assuming we have a *local* Mistral AI server running on port 8080 with `r2ai-server`, we can decompile a given function with `decai -d`.
-The server shows it received the question:
-
-```
-GET
-CUSTOM
-RUNLINE: -R
-127.0.0.1 - - [13/Dec/2024 10:40:49] "GET /cmd/-R HTTP/1.1" 200 -
-GET
-CUSTOM
-RUNLINE: -i /tmp/.pdc.txt Rewrite this function and respond ONLY with code, NO explanations, NO markdown, Change goto into if/else/for/while, Simplify as much as possible, use better variable names, take function arguments and and strings from comments like string:. Transform this pseudocode into C
-```
-
-### Example using a Mistral API key 
-
-Put the API key in `~/.r2ai.mistral-key`.
-
-```
-[0x000010d0]> decai -e api=mistral
-[0x000010d0]> decai -d main
-```c
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-
-int main(int argc, char **argv, char **envp) {
-    char password[40];
-    char input[40];
-...
-```
-
-
-### Example with ChatGPT 4
-
-```
-[0x00406cac]> decai -e api=openai
-[0x00406cac]> decai -d
-#include <stdio.h>
-#include <unistd.h>
-
-void daemonize() {
-    daemon(1, 0);
-}
-...
-```
-
-
+## Further Reading
 
+* There's [a chapter](https://book.rada.re/plugins/r2ai.html) in the official r2book
+* Cryptax on [lmstudio+gptoss](https://cryptax.medium.com/r2ai-with-lmstudio-and-gpt-oss-08efa5ea2476) blog post
+* Malware analysis [with r2ai](https://arxiv.org/pdf/2504.07574) by Cryptax and Daniel Nakov
+* Analysis of [Linux/Trigona ransomware](https://cryptax.medium.com/linux-trigona-analysis-with-r2ai-3e2bd1815e52),  [Linux/Prometei botnet](https://cryptax.medium.com/reversing-a-prometei-botnet-binary-with-r2-and-ai-part-one-3cdb3dc6ffab) and [W32/SkyAI](https://cryptax.medium.com/w32-skyai-uses-ai-so-do-i-d33f04d63534with) with r2ai
 
 ## Videos
 
-- https://infosec.exchange/@radareorg/111946255058894583
-
-
-## Development/Testing
-
-Just run `make` 
-
-
-## TODO
-
-* add "undo" command to drop the last message
-* dump / restore conversational states (see -L command)
-* Implement `~`, `|` and `>` and other r2shell features
-
-
-## Messages API
-
-The r2ai project includes a new API for managing messages and tool calls in conversations with AI models. This API is implemented in `messages.c` and `messages.h`.
-
-### Key Functions
-
-- `r2ai_messages_new()`: Create a new messages array
-- `r2ai_messages_free(msgs)`: Free a messages array and all associated data
-- `r2ai_messages_add(msgs, role, content, tool_call_id)`: Add a new message
-- `r2ai_messages_add_tool_call(msgs, name, arguments, id)`: Add a tool call to the last message
-- `r2ai_messages_last(msgs)`: Get the last message in the array
-- `r2ai_messages_parse_json(msgs, json)`: Parse a JSON response into messages
-- `r2ai_messages_clear(msgs)`: Clear all messages
-
-### Example Usage
-
-```c
-// Create a new messages array
-R2AI_Messages *msgs = r2ai_messages_new();
-
-// Add a user message
-r2ai_messages_add(msgs, "user", "What is the disassembly of function main?", NULL);
-
-// Add an assistant message with a tool call
-R2AI_Message *msg = r2ai_messages_add(msgs, "assistant", NULL, NULL);
-r2ai_messages_add_tool_call(msgs, "r2cmd", "{\"command\":\"pdf@main\"}", "tool-123");
-
-// Free all resources when done
-r2ai_messages_free(msgs);
-```
-
+- [Solving a crackme](https://infosec.exchange/@radareorg/111946255058894583)
+- [De-obfuscation of malware Linux/Ladvix](https://asciinema.org/a/724126)
+- [Analysis of the /fast option inside Linux/Trigona ransomware](https://asciinema.org/a/pBPEaJhp6cunWSKFpBUDTgPt4)

VERSION

@@ -0,0 +1 @@
+1.5.4

autogen.sh

@@ -0,0 +1,6 @@
+#!/bin/sh
+vim decai/src/constants.ts
+make -C decai/src
+vim src/r2ai.h
+vim src/meson.build
+vim VERSION

decai/AGENTS.md

@@ -0,0 +1,13 @@
+# Decompiler based AI
+
+## Actions
+
+* Build: `make -C src`
+* Install: `make user-install`
+* Test: `r2 -A -qc "decai -e api=ollamacloud;decai -e model=glm-5;decai -d @ 0x100000924" /bin/ls`
+
+## Hints
+
+* Never read the minified, autogenerated `decai.r2.js`
+* Focus and work only on the TypeScript source
+* Never run `tsc` or `npx`. Always use `make` targets to compile

decai/Makefile

@@ -1,12 +1,17 @@
 PD=$(shell r2 -H R2_USER_PLUGINS)
 SPD=$(shell r2 -H R2_LIBR_PLUGINS)
-#BF=/bin/dd
-BF=a.out
+BF=/bin/dd
 
 all:
-	@echo 'You can now use 'decai' command'
+	@echo "Run: 'make user-install' to install it in your home"
+	@echo "Run: 'make -C src' to recompile the r2.js"
+
+test:
 	r2 -i decai.r2.js -c 'decai -e deterministic=true' -caf $(BF)
 
+fmt indent:
+	$(MAKE) -C src fmt
+
 user-install:
 	mkdir -p "$(PD)"
 	cp decai.r2.js $(PD)/decai.r2.js
@@ -21,4 +26,4 @@ uninstall:
 	make user-uninstall PD=$(SPD)
 
 vs open:
-	open -a "Visual Studio Code" .
+	open -a "Visual Studio Code" src

decai/README.md

@@ -2,23 +2,23 @@
 
 The AI based Decompiler plugin for radare2
 
-* Written in plain Javascript
-* No dependencies than radare2 and curl in PATH
-* Uses local ollama by default, but also r2ai-server
-* Use services like Anthropic, OpenAI, HF, XAI, DeepSeek, ..
+- Written in plain Javascript
+- No dependencies than radare2 and curl in PATH
+- Uses local ollama by default, but also r2ai-server
+- Use services like Anthropic, OpenAI, HF, XAI, DeepSeek, ..
 
 Features
 
-* Auto mode with function calling with ANY model
-* Uses the r2 pseudo decompiler by default, supports any other
-* Explain purpose and auto-document functions
-* Recursive decompilation to inline stubs
-* Autoname functions and perform type propagation
-* Find vulnerabilities, guide you and write exploits
-* Choose any natural language (not just English)
-* Choose output programming language (not just C)
-* Chain queries to manually fine tune the results
-* Customize decompilation prompt at any time
+- Auto mode with function calling with ANY model
+- Uses the r2 pseudo decompiler by default, supports any other
+- Explain purpose and auto-document functions
+- Recursive decompilation to inline stubs
+- Autoname functions and perform type propagation
+- Find vulnerabilities, guide you and write exploits
+- Choose any natural language (not just English)
+- Choose output programming language (not just C)
+- Chain queries to manually fine tune the results
+- Customize decompilation prompt at any time
 
 ## Installation
 
@@ -37,6 +37,7 @@ Usage: decai (-h) ...
  decai -dd [..]   - same as above, but ignoring cache
  decai -dD [query]- decompile current function with given extra query
  decai -e         - display and change eval config vars
+ decai -E         - edit decai.txt
  decai -h         - show this help
  decai -i [f] [q] - include given file and query
  decai -n         - suggest better function name
@@ -55,10 +56,12 @@ Configuration options:
 ```console
 [0x00000000]> decai -e
 decai -e api=ollama
+decai -e apitype=chat
 decai -e host=http://localhost
 decai -e port=11434
 decai -e prompt=Rewrite this function and respond ONLY with code, NO explanations, NO markdown, Change 'goto' into if/else/for/while, Simplify as much as possible, use better variable names, take function arguments and strings from comments like 'string:'
 decai -e ctxfile=
+decai -e headers=
 decai -e cmds=pdc
 decai -e cache=false
 decai -e lang=C
@@ -68,10 +71,78 @@ decai -e model=
 decai -e maxinputtokens=-1
 ```
 
+## Running decai
+
+Decai is used from `r2` (e.g `r2 ./mybinary`). Get help with `decai -h`:
+
+```
+[0x00406cac]> decai -h
+Usage: decai (-h) ...
+ decai -H         - help setting up r2ai
+ decai -a [query] - solve query with auto mode
+ decai -d [f1 ..] - decompile given functions
+ decai -dr        - decompile function and its called ones (recursive)
+ decai -dd [..]   - same as above, but ignoring cache
+ decai -dD [query]- decompile current function with given extra query
+ ...
+```
+
+List configuration variables with `decai -e`:
+
+```
+[0x00406cac]> decai -e
+decai -e api=ollama
+decai -e host=http://localhost
+decai -e port=11434
+decai -e prompt=Rewrite this function and respond ONLY with code, NO explanations, NO markdown, Change 'goto' into if/else/for/while, Simplify as much as possible, use better variable names, take function arguments and strings from comments like 'string:'
+decai -e ctxfile=
+...
+```
+
+Persist user defaults in `~/.config/r2ai/decai.txt` with one `key=value` entry
+per line, then edit it with `decai -E`. That file is loaded on the first
+`decai` command in a session and reloaded after `decai -E` exits.
+
+Use `decai -e http=curl` to force system curl, `http=r2` to require `r2.http()`,
+or `http=auto` (the default) to use `r2.http()` when available and curl otherwise.
+Failed `r2.http()` calls return an error without falling back to curl. The
+`timeout` setting applies only to system curl. Save `http=curl` in
+`~/.config/r2ai/decai.txt` to persist the override.
+
+List possible APIs to discuss with AI: `decai -e api=?`:
+
+```
+[0x00406cac]> decai -e api=?
+r2ai
+claude
+openapi
+...
+```
+
+Extra headers can be injected globally with `decai -e headers=...` or from the
+environment with `DECAI_HEADERS` / `R2AI_HEADERS`. Use one header per line, for
+example:
+
+```console
+[0x00406cac]> decai -e headers=Authorization: Bearer sk-123\nUser-Agent: curl/8.7.1
+```
+
+### Example using a local model and ollama
+
+For example, if Ollama serves model codegeex4:latest (`ollama ls`), set decai
+API as `ollama` and model `codegeex4:latest`.
+
+```
+[0x00002d30]> decai -e api=ollama
+[0x00002d30]> decai -e model=codegeex4:latest
+[0x00002d30]> decai -q Explain what forkpty does in 2 lines
+The `forkpty` function creates a new process with a pseudo-terminal, allowing the parent to interact with the child via standard input/output/err and controlling its terminal.
+```
+
 ## Examples
 
-See [https://github.com/radareorg/r2ai-examples](https://github.com/radareorg/r2ai-examples)
-
+See
+[https://github.com/radareorg/r2ai-examples](https://github.com/radareorg/r2ai-examples)
 
 ```c
 $ cat stack-overflow/bug.c 
@@ -100,4 +171,68 @@ int main(int argc, char **argv, char **envp) {
 }
 ```
 
---pancake
+### Example using a local Mistral model and r2ai-server
+
+For example, assuming we have a _local_ Mistral AI server running on port 8080
+with `r2ai-server`, we can decompile a given function with `decai -d`. The
+server shows it received the question:
+
+```
+GET
+CUSTOM
+RUNLINE: -R
+127.0.0.1 - - [13/Dec/2024 10:40:49] "GET /cmd/-R HTTP/1.1" 200 -
+GET
+CUSTOM
+RUNLINE: -i /tmp/.pdc.txt Rewrite this function and respond ONLY with code, NO explanations, NO markdown, Change goto into if/else/for/while, Simplify as much as possible, use better variable names, take function arguments and and strings from comments like string:. Transform this pseudocode into C
+```
+
+### Example using a Mistral API key
+
+Put the API key in `~/.r2ai.mistral-key`.
+
+````
+[0x000010d0]> decai -e api=mistral
+[0x000010d0]> decai -d main
+```c
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+int main(int argc, char **argv, char **envp) {
+    char password[40];
+    char input[40];
+...
+````
+
+### Example with ChatGPT 4
+
+```
+[0x00406cac]> decai -e api=openai
+[0x00406cac]> decai -d
+#include <stdio.h>
+#include <unistd.h>
+
+void daemonize() {
+    daemon(1, 0);
+}
+...
+```
+
+## WASM HTTP
+
+With radare2's WASI HTTP build, decai defaults to `r2.http()` to reach the existing
+`r_socket_http_get/post` C APIs. Headers and JSON payloads go directly to the
+host HTTP adapter; no shell curl, temporary payload file or WebSocket proxy is
+needed. A failed/denied HTTP call is returned as an error, without a shell
+fallback. In `http=auto` mode, runtimes without `r2.http()` use system curl.
+
+Enable HTTP in the embedding application (`enabled: true` in JavaScript or
+`network=True` in Python). The radare2 sandbox must permit both `socket` and
+`network`; process execution is not needed. Browser requests remain subject
+to CORS. The host adapter controls the HTTP deadline in WASM; decai's `timeout`
+setting still controls native curl only. Responses are buffered, not streamed.
+
+This requires radareorg/radare2#27037 and the rebuilt decai script. For the
+C r2ai plugin compiled into WASM, the `auto` HTTP backend likewise selects
+radare2's C HTTP implementation; native backend selection is unchanged.

decai/r2plugin/README.md

@@ -0,0 +1,36 @@
+# decai r2plugin
+
+Boilerplate to embed `decai.r2.js` inside the radare2 core library using the
+external plugin system (XPS). Unlike `r2ai/r2plugin`, this does not link any
+native code: the r2.js script is converted into a C buffer and registered as
+an embedded startup script, so r2 runs it at startup exactly like a file in
+the `plugins/*.r2.js` directory (honoring `cfg.plugins`).
+
+The `decai.r2.js` bundle is built from the typescript sources with
+`r2frida-compile` (see `make -C src` in the decai directory). The C buffer is
+generated at build time with `rax2 -C` (make builds) or `js2c.py` (meson).
+
+## Usage
+
+decai lives inside the r2ai repository, so expose it as `libr/xps/p/decai`:
+
+```console
+cd radare2/libr/xps/p
+git clone https://github.com/radareorg/r2ai
+ln -s r2ai/decai decai
+```
+
+For acr/make builds:
+
+```console
+cd radare2
+make -C libr/xps EXTERNAL_PLUGINS=decai
+./configure-plugins
+make
+```
+
+For meson builds, make `libr/xps/p/meson.build` contain:
+
+```meson
+subdir('decai/r2plugin')
+```

decai/r2plugin/core/decai.r2.js.d

@@ -0,0 +1,2 @@
+/Users/pancake/prg/radare2/libr/xps/p/decai/r2plugin/core/decai.r2.js.o: \
+  /Users/pancake/prg/radare2/libr/xps/p/decai/r2plugin/core/decai.r2.js.c

decai/r2plugin/core/deps.h

@@ -0,0 +1,3 @@
+#ifdef R2_CORE_H
+extern RCorePlugin r_core_plugin_decai;
+#endif

decai/r2plugin/core/deps.mk

@@ -0,0 +1,10 @@
+DECAI_CORE_WD=$(LIBR)/xps/p/decai
+DECAI_CORE_OBJ= \
+	$(DECAI_CORE_WD)/r2plugin/core/plugin.o \
+	$(DECAI_CORE_WD)/r2plugin/core/decai.r2.js.o
+EXTERNAL_STATIC_OBJS+=$(DECAI_CORE_OBJ)
+
+# decai.r2.js can be rebuilt from typescript with r2frida-compile (make -C src)
+$(DECAI_CORE_WD)/r2plugin/core/decai.r2.js.c: $(DECAI_CORE_WD)/decai.r2.js
+	rax2 -C < $(DECAI_CORE_WD)/decai.r2.js | \
+		sed -e 's,^unsigned,const unsigned,' -e 's,buf,decai_qjs,g' > $@

decai/r2plugin/core/plugin.c

@@ -0,0 +1,35 @@
+/* decai - LGPL - Copyright 2026 - pancake */
+
+#include <r_core.h>
+
+// generated from ../decai.r2.js, see ../deps.mk
+extern const unsigned char decai_qjs[];
+extern const unsigned int decai_qjs_len;
+
+static bool decai_init(RCorePluginSession *cps) {
+	r_core_script_embed (cps->core, "decai", "qjs", (const char *)decai_qjs, (int)decai_qjs_len);
+	return true;
+}
+
+static bool decai_call(RCorePluginSession *cps, const char *input) {
+	return false;
+}
+
+RCorePlugin r_core_plugin_decai = {
+	.meta = {
+		.name = "decai",
+		.desc = "AI decompiler (embedded decai.r2.js)",
+		.author = "pancake",
+		.license = "MIT",
+	},
+	.init = decai_init,
+	.call = decai_call,
+};
+
+#ifndef R2_PLUGIN_INCORE
+R_API RLibStruct radare_plugin = {
+	.type = R_LIB_TYPE_CORE,
+	.data = &r_core_plugin_decai,
+	.version = R2_VERSION,
+};
+#endif