Add claude opus/sonnet support

9 files changed, 1011 insertions, 101 deletions

diff --git a/Cargo.lock b/Cargo.lock
index 4c6f35a..c1f237b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -300,6 +300,15 @@ dependencies = [
 ]
 
 [[package]]
+name = "chumsky"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8eebd66744a15ded14960ab4ccdbfb51ad3b81f51f3f04a80adac98c985396c9"
+dependencies = [
+ "hashbrown 0.14.5",
+]
+
+[[package]]
 name = "clap"
 version = "4.5.53"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -635,6 +644,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1aaf95b3e5c8f23aa320147307562d361db0ae0d51242340f558153b4eb2439b"
 
 [[package]]
+name = "dyn-clone"
+version = "1.0.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555"
+
+[[package]]
 name = "either"
 version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -963,6 +978,16 @@ dependencies = [
 
 [[package]]
 name = "hashbrown"
+version = "0.14.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
+dependencies = [
+ "ahash",
+ "allocator-api2",
+]
+
+[[package]]
+name = "hashbrown"
 version = "0.15.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
@@ -1030,6 +1055,12 @@ dependencies = [
 ]
 
 [[package]]
+name = "hifijson"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a7763b98ba8a24f59e698bf9ab197e7676c640d6455d1580b4ce7dc560f0f0d"
+
+[[package]]
 name = "hkdf"
 version = "0.12.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1407,6 +1438,66 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
+name = "jaq-core"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6fda09ee08c84c81293fdf811d9ebaa87b327557b5391f290c926d728c2ddd4"
+dependencies = [
+ "aho-corasick",
+ "base64 0.22.1",
+ "chrono",
+ "hifijson",
+ "jaq-interpret",
+ "libm",
+ "log",
+ "regex",
+ "urlencoding",
+]
+
+[[package]]
+name = "jaq-interpret"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2fe95ec3c24af3fd9f3dd1091593f5e49b003a66c496a8aa39d764d0a06ae17b"
+dependencies = [
+ "ahash",
+ "dyn-clone",
+ "hifijson",
+ "indexmap",
+ "jaq-syn",
+ "once_cell",
+ "serde_json",
+]
+
+[[package]]
+name = "jaq-parse"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0346d7d3146cdda8acd929581f3d6626a332356c74d5c95aeaffaac2eb6dee82"
+dependencies = [
+ "chumsky",
+ "jaq-syn",
+]
+
+[[package]]
+name = "jaq-std"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfbaa55578fd3b70433b594a370741e0c364e4afff92cc0099623fce87311bc1"
+dependencies = [
+ "jaq-syn",
+]
+
+[[package]]
+name = "jaq-syn"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ba44fe4428c71304604261ecbae047ee9cfb60c4f1a6bd222ebbb31726d3948"
+dependencies = [
+ "serde",
+]
+
+[[package]]
 name = "js-sys"
 version = "0.3.83"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1514,12 +1605,18 @@ checksum = "670fdfda89751bc4a84ac13eaa63e205cf0fd22b4c9a5fbfa085b63c1f1d3a30"
 name = "makima"
 version = "0.1.0"
 dependencies = [
+ "ahash",
  "anyhow",
  "axum",
  "bytes",
  "chrono",
  "futures",
  "hf-hub",
+ "indexmap",
+ "jaq-core",
+ "jaq-interpret",
+ "jaq-parse",
+ "jaq-std",
  "ndarray",
  "once_cell",
  "ort",
@@ -3682,6 +3779,12 @@ dependencies = [
 ]
 
 [[package]]
+name = "urlencoding"
+version = "2.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da"
+
+[[package]]
 name = "utf-8"
 version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
diff --git a/makima/Cargo.toml b/makima/Cargo.toml
index 5cf1f65..4bf629f 100644
--- a/makima/Cargo.toml
+++ b/makima/Cargo.toml
@@ -46,3 +46,11 @@ reqwest = { version = "0.12", features = ["json"] }
 
 # Lazy statics
 once_cell = "1.19"
+
+# JQ for JSON transformation
+jaq-interpret = "1.5"
+jaq-parse = "1.0"
+jaq-core = "1.5"
+jaq-std = "1.6"
+indexmap = "2.0"
+ahash = "0.8"
diff --git a/makima/frontend/src/components/files/CliInput.tsx b/makima/frontend/src/components/files/CliInput.tsx
index b20eb27..1dcc884 100644
--- a/makima/frontend/src/components/files/CliInput.tsx
+++ b/makima/frontend/src/components/files/CliInput.tsx
@@ -1,5 +1,5 @@
 import { useState, useCallback, useRef, useEffect } from "react";
-import { chatWithFile, type BodyElement } from "../../lib/api";
+import { chatWithFile, type BodyElement, type LlmModel } from "../../lib/api";
 
 interface CliInputProps {
   fileId: string;
@@ -13,11 +13,18 @@ interface Message {
   toolCalls?: { name: string; success: boolean; message: string }[];
 }
 
+const MODEL_OPTIONS: { value: LlmModel; label: string }[] = [
+  { value: "claude-opus", label: "Claude Opus" },
+  { value: "claude-sonnet", label: "Claude Sonnet" },
+  { value: "groq", label: "Groq Kimi" },
+];
+
 export function CliInput({ fileId, onUpdate }: CliInputProps) {
   const [input, setInput] = useState("");
   const [loading, setLoading] = useState(false);
   const [messages, setMessages] = useState<Message[]>([]);
   const [expanded, setExpanded] = useState(false);
+  const [model, setModel] = useState<LlmModel>("claude-opus");
   const inputRef = useRef<HTMLInputElement>(null);
   const messagesRef = useRef<HTMLDivElement>(null);
 
@@ -47,7 +54,7 @@ export function CliInput({ fileId, onUpdate }: CliInputProps) {
       setLoading(true);
 
       try {
-        const response = await chatWithFile(fileId, userMessage);
+        const response = await chatWithFile(fileId, userMessage, model);
 
         // Add assistant response
         const assistantMsgId = (Date.now() + 1).toString();
@@ -82,7 +89,7 @@ export function CliInput({ fileId, onUpdate }: CliInputProps) {
         inputRef.current?.focus();
       }
     },
-    [input, loading, fileId, onUpdate]
+    [input, loading, fileId, model, onUpdate]
   );
 
   const clearMessages = useCallback(() => {
@@ -136,7 +143,19 @@ export function CliInput({ fileId, onUpdate }: CliInputProps) {
 
       {/* Input Bar */}
       <form onSubmit={handleSubmit} className="flex items-center gap-2 p-3">
-        <span className="text-[#9bc3ff] font-mono text-sm">$</span>
+        <select
+          value={model}
+          onChange={(e) => setModel(e.target.value as LlmModel)}
+          disabled={loading}
+          className="bg-[#0d1b2d] border border-[rgba(117,170,252,0.25)] text-[#9bc3ff] font-mono text-xs px-2 py-1 rounded-none outline-none focus:border-[#3f6fb3] disabled:opacity-50"
+        >
+          {MODEL_OPTIONS.map((opt) => (
+            <option key={opt.value} value={opt.value}>
+              {opt.label}
+            </option>
+          ))}
+        </select>
+        <span className="text-[#9bc3ff] font-mono text-sm">&gt;</span>
         <input
           ref={inputRef}
           type="text"
diff --git a/makima/frontend/src/lib/api.ts b/makima/frontend/src/lib/api.ts
index 5ef9c22..6f7071d 100644
--- a/makima/frontend/src/lib/api.ts
+++ b/makima/frontend/src/lib/api.ts
@@ -108,9 +108,13 @@ export interface UpdateFileRequest {
   body?: BodyElement[];
 }
 
+// Available LLM models
+export type LlmModel = "claude-sonnet" | "claude-opus" | "groq";
+
 // Chat API types
 export interface ChatRequest {
   message: string;
+  model?: LlmModel;
 }
 
 export interface ToolCallInfo {
@@ -184,12 +188,17 @@ export async function deleteFile(id: string): Promise<void> {
 // Chat API function
 export async function chatWithFile(
   id: string,
-  message: string
+  message: string,
+  model?: LlmModel
 ): Promise<ChatResponse> {
+  const body: ChatRequest = { message };
+  if (model) {
+    body.model = model;
+  }
   const res = await fetch(`${API_BASE}/api/v1/files/${id}/chat`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ message }),
+    body: JSON.stringify(body),
   });
   if (!res.ok) {
     const errorText = await res.text();
diff --git a/makima/src/llm/claude.rs b/makima/src/llm/claude.rs
new file mode 100644
index 0000000..f475acd
--- /dev/null
+++ b/makima/src/llm/claude.rs
@@ -0,0 +1,304 @@
+//! Claude API client for LLM tool calling.
+
+use serde::{Deserialize, Serialize};
+use thiserror::Error;
+
+use super::tools::{Tool, ToolCall};
+
+const CLAUDE_API_URL: &str = "https://api.anthropic.com/v1/messages";
+const ANTHROPIC_VERSION: &str = "2023-06-01";
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ClaudeModel {
+    Opus,
+    Sonnet,
+}
+
+impl ClaudeModel {
+    pub fn model_id(&self) -> &'static str {
+        match self {
+            ClaudeModel::Opus => "claude-opus-4-5-20251101",
+            ClaudeModel::Sonnet => "claude-sonnet-4-5-20250929",
+        }
+    }
+}
+
+impl Default for ClaudeModel {
+    fn default() -> Self {
+        ClaudeModel::Opus
+    }
+}
+
+#[derive(Debug, Error)]
+pub enum ClaudeError {
+    #[error("HTTP request failed: {0}")]
+    Request(#[from] reqwest::Error),
+    #[error("API error: {0}")]
+    Api(String),
+    #[error("Missing API key")]
+    MissingApiKey,
+}
+
+#[derive(Debug, Clone)]
+pub struct ClaudeClient {
+    api_key: String,
+    client: reqwest::Client,
+    model: ClaudeModel,
+}
+
+// Request types
+#[derive(Debug, Serialize)]
+struct ClaudeRequest {
+    model: String,
+    max_tokens: u32,
+    messages: Vec<Message>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    tools: Option<Vec<ToolDefinition>>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Message {
+    pub role: String,
+    pub content: MessageContent,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum MessageContent {
+    Text(String),
+    Blocks(Vec<ContentBlock>),
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type")]
+pub enum ContentBlock {
+    #[serde(rename = "text")]
+    Text { text: String },
+    #[serde(rename = "tool_use")]
+    ToolUse {
+        id: String,
+        name: String,
+        input: serde_json::Value,
+    },
+    #[serde(rename = "tool_result")]
+    ToolResult {
+        tool_use_id: String,
+        content: String,
+    },
+}
+
+#[derive(Debug, Serialize)]
+struct ToolDefinition {
+    name: String,
+    description: String,
+    input_schema: serde_json::Value,
+}
+
+// Response types
+#[derive(Debug, Deserialize)]
+struct ClaudeResponse {
+    content: Vec<ResponseContentBlock>,
+    stop_reason: Option<String>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(tag = "type")]
+pub enum ResponseContentBlock {
+    #[serde(rename = "text")]
+    Text { text: String },
+    #[serde(rename = "tool_use")]
+    ToolUse {
+        id: String,
+        name: String,
+        input: serde_json::Value,
+    },
+}
+
+#[derive(Debug)]
+pub struct ChatResult {
+    pub content: Option<String>,
+    pub tool_calls: Vec<ToolCall>,
+    /// Raw tool use blocks for including in subsequent messages
+    pub raw_tool_uses: Vec<ResponseContentBlock>,
+    pub stop_reason: String,
+}
+
+impl ClaudeClient {
+    pub fn new(api_key: String, model: ClaudeModel) -> Self {
+        Self {
+            api_key,
+            client: reqwest::Client::new(),
+            model,
+        }
+    }
+
+    pub fn from_env(model: ClaudeModel) -> Result<Self, ClaudeError> {
+        let api_key = std::env::var("ANTHROPIC_API_KEY").map_err(|_| ClaudeError::MissingApiKey)?;
+        Ok(Self::new(api_key, model))
+    }
+
+    pub async fn chat_with_tools(
+        &self,
+        messages: Vec<Message>,
+        tools: &[Tool],
+    ) -> Result<ChatResult, ClaudeError> {
+        let tool_definitions: Vec<ToolDefinition> = tools
+            .iter()
+            .map(|t| ToolDefinition {
+                name: t.name.clone(),
+                description: t.description.clone(),
+                input_schema: t.parameters.clone(),
+            })
+            .collect();
+
+        let request = ClaudeRequest {
+            model: self.model.model_id().to_string(),
+            max_tokens: 4096,
+            messages,
+            tools: Some(tool_definitions),
+        };
+
+        let response = self
+            .client
+            .post(CLAUDE_API_URL)
+            .header("x-api-key", &self.api_key)
+            .header("anthropic-version", ANTHROPIC_VERSION)
+            .header("Content-Type", "application/json")
+            .json(&request)
+            .send()
+            .await?;
+
+        if !response.status().is_success() {
+            let error_text = response.text().await.unwrap_or_default();
+            return Err(ClaudeError::Api(error_text));
+        }
+
+        let claude_response: ClaudeResponse = response.json().await?;
+
+        let stop_reason = claude_response.stop_reason.unwrap_or_else(|| "end_turn".to_string());
+
+        // Extract text content and tool uses from content blocks
+        let mut text_parts: Vec<String> = Vec::new();
+        let mut raw_tool_uses: Vec<ResponseContentBlock> = Vec::new();
+
+        for block in &claude_response.content {
+            match block {
+                ResponseContentBlock::Text { text } => {
+                    if !text.is_empty() {
+                        text_parts.push(text.clone());
+                    }
+                }
+                ResponseContentBlock::ToolUse { .. } => {
+                    raw_tool_uses.push(block.clone());
+                }
+            }
+        }
+
+        let content = if text_parts.is_empty() {
+            None
+        } else {
+            Some(text_parts.join("\n"))
+        };
+
+        // Convert tool uses to ToolCalls
+        let tool_calls: Vec<ToolCall> = raw_tool_uses
+            .iter()
+            .filter_map(|block| {
+                if let ResponseContentBlock::ToolUse { id, name, input } = block {
+                    Some(ToolCall {
+                        id: id.clone(),
+                        name: name.clone(),
+                        arguments: input.clone(),
+                    })
+                } else {
+                    None
+                }
+            })
+            .collect();
+
+        Ok(ChatResult {
+            content,
+            tool_calls,
+            raw_tool_uses,
+            stop_reason,
+        })
+    }
+}
+
+/// Helper to convert Groq-style messages to Claude messages
+pub fn groq_messages_to_claude(messages: &[super::groq::Message]) -> Vec<Message> {
+    let mut claude_messages: Vec<Message> = Vec::new();
+
+    for msg in messages {
+        match msg.role.as_str() {
+            "system" => {
+                // Claude handles system prompts as first user message
+                if let Some(ref content) = msg.content {
+                    claude_messages.push(Message {
+                        role: "user".to_string(),
+                        content: MessageContent::Text(format!("[System Instructions]: {}", content)),
+                    });
+                    // Add assistant acknowledgment to maintain conversation structure
+                    claude_messages.push(Message {
+                        role: "assistant".to_string(),
+                        content: MessageContent::Text("Understood. I'll follow these instructions.".to_string()),
+                    });
+                }
+            }
+            "user" => {
+                if let Some(ref content) = msg.content {
+                    claude_messages.push(Message {
+                        role: "user".to_string(),
+                        content: MessageContent::Text(content.clone()),
+                    });
+                }
+            }
+            "assistant" => {
+                let mut blocks: Vec<ContentBlock> = Vec::new();
+
+                // Add text content if present
+                if let Some(ref content) = msg.content {
+                    if !content.is_empty() {
+                        blocks.push(ContentBlock::Text { text: content.clone() });
+                    }
+                }
+
+                // Add tool uses if present
+                if let Some(ref tool_calls) = msg.tool_calls {
+                    for tc in tool_calls {
+                        let input: serde_json::Value =
+                            serde_json::from_str(&tc.function.arguments).unwrap_or_default();
+                        blocks.push(ContentBlock::ToolUse {
+                            id: tc.id.clone(),
+                            name: tc.function.name.clone(),
+                            input,
+                        });
+                    }
+                }
+
+                if !blocks.is_empty() {
+                    claude_messages.push(Message {
+                        role: "assistant".to_string(),
+                        content: MessageContent::Blocks(blocks),
+                    });
+                }
+            }
+            "tool" => {
+                // Tool results in Claude go in a user message with tool_result blocks
+                if let Some(ref content) = msg.content {
+                    let tool_use_id = msg.tool_call_id.clone().unwrap_or_default();
+                    claude_messages.push(Message {
+                        role: "user".to_string(),
+                        content: MessageContent::Blocks(vec![ContentBlock::ToolResult {
+                            tool_use_id,
+                            content: content.clone(),
+                        }]),
+                    });
+                }
+            }
+            _ => {}
+        }
+    }
+
+    claude_messages
+}
diff --git a/makima/src/llm/groq.rs b/makima/src/llm/groq.rs
index be0e2bc..ee01fcf 100644
--- a/makima/src/llm/groq.rs
+++ b/makima/src/llm/groq.rs
@@ -92,6 +92,8 @@ struct MessageResponse {
 pub struct ChatResult {
     pub content: Option<String>,
     pub tool_calls: Vec<ToolCall>,
+    /// Raw tool call responses for including in subsequent messages
+    pub raw_tool_calls: Vec<ToolCallResponse>,
     pub finish_reason: String,
 }
 
@@ -154,14 +156,13 @@ impl GroqClient {
             .next()
             .ok_or_else(|| GroqError::Api("No choices in response".to_string()))?;
 
-        let tool_calls = choice
-            .message
-            .tool_calls
-            .unwrap_or_default()
-            .into_iter()
+        let raw_tool_calls = choice.message.tool_calls.unwrap_or_default();
+
+        let tool_calls = raw_tool_calls
+            .iter()
             .map(|tc| ToolCall {
-                id: tc.id,
-                name: tc.function.name,
+                id: tc.id.clone(),
+                name: tc.function.name.clone(),
                 arguments: serde_json::from_str(&tc.function.arguments).unwrap_or_default(),
             })
             .collect();
@@ -169,6 +170,7 @@ impl GroqClient {
         Ok(ChatResult {
             content: choice.message.content,
             tool_calls,
+            raw_tool_calls,
             finish_reason: choice.finish_reason,
         })
     }
diff --git a/makima/src/llm/mod.rs b/makima/src/llm/mod.rs
index 00f3333..7de8afe 100644
--- a/makima/src/llm/mod.rs
+++ b/makima/src/llm/mod.rs
@@ -1,7 +1,32 @@
 //! LLM integration module for file editing via tool calling.
 
+pub mod claude;
 pub mod groq;
 pub mod tools;
 
+pub use claude::{ClaudeClient, ClaudeModel};
 pub use groq::GroqClient;
 pub use tools::{execute_tool_call, Tool, ToolCall, ToolResult, AVAILABLE_TOOLS};
+
+/// Available LLM providers and models
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum LlmModel {
+    /// Claude Sonnet 4.5 - balanced speed and capability
+    ClaudeSonnet,
+    /// Claude Opus 4.5 (default) - most capable
+    #[default]
+    ClaudeOpus,
+    /// Groq Kimi - fast alternative provider
+    GroqKimi,
+}
+
+impl LlmModel {
+    pub fn from_str(s: &str) -> Option<Self> {
+        match s.to_lowercase().as_str() {
+            "claude-sonnet" | "sonnet" | "claude" => Some(LlmModel::ClaudeSonnet),
+            "claude-opus" | "opus" => Some(LlmModel::ClaudeOpus),
+            "groq" | "kimi" | "groq-kimi" => Some(LlmModel::GroqKimi),
+            _ => None,
+        }
+    }
+}
diff --git a/makima/src/llm/tools.rs b/makima/src/llm/tools.rs
index 3bd102f..e6b2954 100644
--- a/makima/src/llm/tools.rs
+++ b/makima/src/llm/tools.rs
@@ -1,5 +1,6 @@
 //! Tool definitions for file editing via LLM.
 
+use jaq_interpret::FilterT;
 use serde::{Deserialize, Serialize};
 use serde_json::json;
 
@@ -121,7 +122,7 @@ pub static AVAILABLE_TOOLS: once_cell::sync::Lazy<Vec<Tool>> =
             },
             Tool {
                 name: "update_element".to_string(),
-                description: "Update an existing element in the file body".to_string(),
+                description: "Update an existing element in the file body. IMPORTANT: You must provide ALL required fields. For heading: type, level (1-6), text. For paragraph: type, text. For chart: type, chartType (line/bar/pie/area), data (array of objects).".to_string(),
                 parameters: json!({
                     "type": "object",
                     "properties": {
@@ -129,12 +130,35 @@ pub static AVAILABLE_TOOLS: once_cell::sync::Lazy<Vec<Tool>> =
                             "type": "integer",
                             "description": "Index of element to update (0-indexed)"
                         },
-                        "element": {
-                            "type": "object",
-                            "description": "New element data. Must include 'type' field (heading, paragraph, chart)."
+                        "element_type": {
+                            "type": "string",
+                            "enum": ["heading", "paragraph", "chart"],
+                            "description": "Type of element"
+                        },
+                        "text": {
+                            "type": "string",
+                            "description": "Text content (required for heading and paragraph)"
+                        },
+                        "level": {
+                            "type": "integer",
+                            "description": "Heading level 1-6 (required for heading)"
+                        },
+                        "chartType": {
+                            "type": "string",
+                            "enum": ["line", "bar", "pie", "area"],
+                            "description": "Chart type (required for chart)"
+                        },
+                        "data": {
+                            "type": "array",
+                            "description": "Chart data array (required for chart)",
+                            "items": { "type": "object" }
+                        },
+                        "title": {
+                            "type": "string",
+                            "description": "Chart title (optional for chart)"
                         }
                     },
-                    "required": ["index", "element"]
+                    "required": ["index", "element_type"]
                 }),
             },
             Tool {
@@ -191,6 +215,23 @@ pub static AVAILABLE_TOOLS: once_cell::sync::Lazy<Vec<Tool>> =
                     "properties": {}
                 }),
             },
+            Tool {
+                name: "jq".to_string(),
+                description: "Transform JSON data using jq expressions. Useful for filtering, mapping, grouping, and aggregating data before creating charts.".to_string(),
+                parameters: json!({
+                    "type": "object",
+                    "properties": {
+                        "input": {
+                            "description": "The JSON data to transform (can be an array or object)"
+                        },
+                        "filter": {
+                            "type": "string",
+                            "description": "The jq filter expression. Examples: '.[] | select(.value > 10)', 'group_by(.category) | map({name: .[0].category, count: length})', '[.[] | {name: .label, value: .amount}]'"
+                        }
+                    },
+                    "required": ["input", "filter"]
+                }),
+            },
         ]
     });
 
@@ -219,6 +260,7 @@ pub fn execute_tool_call(
         "set_summary" => execute_set_summary(call, current_summary),
         "parse_csv" => execute_parse_csv(call),
         "clear_body" => execute_clear_body(),
+        "jq" => execute_jq(call),
         _ => ToolExecutionResult {
             result: ToolResult {
                 success: false,
@@ -415,7 +457,7 @@ fn execute_remove_element(call: &ToolCall, current_body: &[BodyElement]) -> Tool
 
 fn execute_update_element(call: &ToolCall, current_body: &[BodyElement]) -> ToolExecutionResult {
     let index = call.arguments.get("index").and_then(|v| v.as_u64());
-    let element_json = call.arguments.get("element");
+    let element_type = call.arguments.get("element_type").and_then(|v| v.as_str());
 
     let Some(index) = index else {
         return ToolExecutionResult {
@@ -429,11 +471,11 @@ fn execute_update_element(call: &ToolCall, current_body: &[BodyElement]) -> Tool
         };
     };
 
-    let Some(element_json) = element_json else {
+    let Some(element_type) = element_type else {
         return ToolExecutionResult {
             result: ToolResult {
                 success: false,
-                message: "Missing element parameter".to_string(),
+                message: "Missing element_type parameter".to_string(),
             },
             new_body: None,
             new_summary: None,
@@ -454,31 +496,55 @@ fn execute_update_element(call: &ToolCall, current_body: &[BodyElement]) -> Tool
         };
     }
 
-    let new_element: Result<BodyElement, _> = serde_json::from_value(element_json.clone());
-    match new_element {
-        Ok(element) => {
-            let mut new_body = current_body.to_vec();
-            new_body[index] = element;
-
-            ToolExecutionResult {
+    // Build the element based on type
+    let new_element = match element_type {
+        "heading" => {
+            let level = call.arguments.get("level").and_then(|v| v.as_u64()).unwrap_or(1) as u8;
+            let text = call.arguments.get("text").and_then(|v| v.as_str()).unwrap_or("").to_string();
+            BodyElement::Heading { level, text }
+        }
+        "paragraph" => {
+            let text = call.arguments.get("text").and_then(|v| v.as_str()).unwrap_or("").to_string();
+            BodyElement::Paragraph { text }
+        }
+        "chart" => {
+            let chart_type_str = call.arguments.get("chartType").and_then(|v| v.as_str()).unwrap_or("bar");
+            let chart_type = match chart_type_str {
+                "line" => ChartType::Line,
+                "bar" => ChartType::Bar,
+                "pie" => ChartType::Pie,
+                "area" => ChartType::Area,
+                _ => ChartType::Bar,
+            };
+            let title = call.arguments.get("title").and_then(|v| v.as_str()).map(|s| s.to_string());
+            let data = call.arguments.get("data").cloned().unwrap_or(json!([]));
+            let config = call.arguments.get("config").cloned();
+            BodyElement::Chart { chart_type, title, data, config }
+        }
+        _ => {
+            return ToolExecutionResult {
                 result: ToolResult {
-                    success: true,
-                    message: format!("Updated element at index {}", index),
+                    success: false,
+                    message: format!("Unknown element_type: {}. Must be heading, paragraph, or chart.", element_type),
                 },
-                new_body: Some(new_body),
+                new_body: None,
                 new_summary: None,
                 parsed_data: None,
-            }
+            };
         }
-        Err(e) => ToolExecutionResult {
-            result: ToolResult {
-                success: false,
-                message: format!("Invalid element format: {}", e),
-            },
-            new_body: None,
-            new_summary: None,
-            parsed_data: None,
+    };
+
+    let mut new_body = current_body.to_vec();
+    new_body[index] = new_element;
+
+    ToolExecutionResult {
+        result: ToolResult {
+            success: true,
+            message: format!("Updated element at index {} to {}", index, element_type),
         },
+        new_body: Some(new_body),
+        new_summary: None,
+        parsed_data: None,
     }
 }
 
@@ -616,3 +682,191 @@ fn execute_clear_body() -> ToolExecutionResult {
         parsed_data: None,
     }
 }
+
+fn execute_jq(call: &ToolCall) -> ToolExecutionResult {
+    let input = match call.arguments.get("input") {
+        Some(v) => v.clone(),
+        None => {
+            return ToolExecutionResult {
+                result: ToolResult {
+                    success: false,
+                    message: "Missing input parameter".to_string(),
+                },
+                new_body: None,
+                new_summary: None,
+                parsed_data: None,
+            };
+        }
+    };
+
+    let filter = match call.arguments.get("filter").and_then(|v| v.as_str()) {
+        Some(f) => f,
+        None => {
+            return ToolExecutionResult {
+                result: ToolResult {
+                    success: false,
+                    message: "Missing filter parameter".to_string(),
+                },
+                new_body: None,
+                new_summary: None,
+                parsed_data: None,
+            };
+        }
+    };
+
+    // Parse the jq filter
+    let mut defs = jaq_interpret::ParseCtx::new(Vec::new());
+    defs.insert_natives(jaq_core::core());
+    defs.insert_defs(jaq_std::std());
+
+    let (parsed_filter, errs) = jaq_parse::parse(filter, jaq_parse::main());
+    if !errs.is_empty() {
+        return ToolExecutionResult {
+            result: ToolResult {
+                success: false,
+                message: format!("Invalid jq filter: {:?}", errs),
+            },
+            new_body: None,
+            new_summary: None,
+            parsed_data: None,
+        };
+    }
+
+    let Some(parsed_filter) = parsed_filter else {
+        return ToolExecutionResult {
+            result: ToolResult {
+                success: false,
+                message: "Failed to parse jq filter".to_string(),
+            },
+            new_body: None,
+            new_summary: None,
+            parsed_data: None,
+        };
+    };
+
+    // Compile the filter
+    let compiled = defs.compile(parsed_filter);
+    if !defs.errs.is_empty() {
+        return ToolExecutionResult {
+            result: ToolResult {
+                success: false,
+                message: format!("Failed to compile jq filter ({} errors)", defs.errs.len()),
+            },
+            new_body: None,
+            new_summary: None,
+            parsed_data: None,
+        };
+    }
+
+    // Convert serde_json::Value to jaq Value
+    let jaq_input = json_to_jaq(&input);
+
+    // Execute the filter
+    let inputs = jaq_interpret::RcIter::new(std::iter::empty());
+    let mut results: Vec<serde_json::Value> = Vec::new();
+
+    for output in compiled.run((jaq_interpret::Ctx::new([], &inputs), jaq_input)) {
+        match output {
+            Ok(val) => {
+                results.push(jaq_to_json(&val));
+            }
+            Err(e) => {
+                return ToolExecutionResult {
+                    result: ToolResult {
+                        success: false,
+                        message: format!("jq execution error: {:?}", e),
+                    },
+                    new_body: None,
+                    new_summary: None,
+                    parsed_data: None,
+                };
+            }
+        }
+    }
+
+    // Return single value or array based on results
+    let output = if results.len() == 1 {
+        results.into_iter().next().unwrap()
+    } else {
+        json!(results)
+    };
+
+    let preview = {
+        let s = output.to_string();
+        if s.len() > 100 {
+            format!("{}...", &s[..100])
+        } else {
+            s
+        }
+    };
+
+    ToolExecutionResult {
+        result: ToolResult {
+            success: true,
+            message: format!("jq transform complete: {}", preview),
+        },
+        new_body: None,
+        new_summary: None,
+        parsed_data: Some(output),
+    }
+}
+
+/// Convert serde_json::Value to jaq_interpret::Val
+fn json_to_jaq(value: &serde_json::Value) -> jaq_interpret::Val {
+    match value {
+        serde_json::Value::Null => jaq_interpret::Val::Null,
+        serde_json::Value::Bool(b) => jaq_interpret::Val::Bool(*b),
+        serde_json::Value::Number(n) => {
+            if let Some(i) = n.as_i64() {
+                jaq_interpret::Val::Int(i as isize)
+            } else if let Some(f) = n.as_f64() {
+                jaq_interpret::Val::Float(f)
+            } else {
+                jaq_interpret::Val::Null
+            }
+        }
+        serde_json::Value::String(s) => jaq_interpret::Val::Str(s.clone().into()),
+        serde_json::Value::Array(arr) => {
+            jaq_interpret::Val::Arr(std::rc::Rc::new(arr.iter().map(json_to_jaq).collect()))
+        }
+        serde_json::Value::Object(obj) => {
+            let mut map: indexmap::IndexMap<std::rc::Rc<String>, jaq_interpret::Val, ahash::RandomState> =
+                indexmap::IndexMap::with_hasher(ahash::RandomState::new());
+            for (k, v) in obj {
+                map.insert(std::rc::Rc::new(k.clone()), json_to_jaq(v));
+            }
+            jaq_interpret::Val::Obj(std::rc::Rc::new(map))
+        }
+    }
+}
+
+/// Convert jaq_interpret::Val to serde_json::Value
+fn jaq_to_json(value: &jaq_interpret::Val) -> serde_json::Value {
+    match value {
+        jaq_interpret::Val::Null => serde_json::Value::Null,
+        jaq_interpret::Val::Bool(b) => json!(*b),
+        jaq_interpret::Val::Int(i) => json!(*i),
+        jaq_interpret::Val::Float(f) => json!(*f),
+        jaq_interpret::Val::Num(n) => {
+            // Try to parse the number string
+            if let Ok(i) = n.parse::<i64>() {
+                json!(i)
+            } else if let Ok(f) = n.parse::<f64>() {
+                json!(f)
+            } else {
+                json!(n.as_ref())
+            }
+        }
+        jaq_interpret::Val::Str(s) => json!(s.as_ref()),
+        jaq_interpret::Val::Arr(arr) => {
+            json!(arr.iter().map(jaq_to_json).collect::<Vec<_>>())
+        }
+        jaq_interpret::Val::Obj(obj) => {
+            let mut map = serde_json::Map::new();
+            for (k, v) in obj.iter() {
+                map.insert((**k).clone(), jaq_to_json(v));
+            }
+            serde_json::Value::Object(map)
+        }
+    }
+}
diff --git a/makima/src/server/handlers/chat.rs b/makima/src/server/handlers/chat.rs
index e6d22ca..92c4ec8 100644
--- a/makima/src/server/handlers/chat.rs
+++ b/makima/src/server/handlers/chat.rs
@@ -12,17 +12,24 @@ use uuid::Uuid;
 
 use crate::db::{models::BodyElement, repository};
 use crate::llm::{
+    claude::{self, ClaudeClient, ClaudeError, ClaudeModel},
     execute_tool_call,
-    groq::{GroqClient, GroqError, Message},
-    ToolResult, AVAILABLE_TOOLS,
+    groq::{GroqClient, GroqError, Message, ToolCallResponse},
+    LlmModel, ToolCall, ToolResult, AVAILABLE_TOOLS,
 };
 use crate::server::state::SharedState;
 
+/// Maximum number of tool-calling rounds to prevent infinite loops
+const MAX_TOOL_ROUNDS: usize = 10;
+
 #[derive(Debug, Deserialize, ToSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct ChatRequest {
     /// The user's message/instruction
     pub message: String,
+    /// Optional model selection: "claude-sonnet" (default), "claude-opus", or "groq"
+    #[serde(default)]
+    pub model: Option<String>,
 }
 
 #[derive(Debug, Serialize, ToSchema)]
@@ -45,9 +52,18 @@ pub struct ToolCallInfo {
     pub result: ToolResult,
 }
 
-#[derive(Debug, Serialize)]
-struct ErrorResponse {
-    error: String,
+/// Enum to hold LLM clients
+enum LlmClient {
+    Groq(GroqClient),
+    Claude(ClaudeClient),
+}
+
+/// Unified result from LLM call
+struct LlmResult {
+    content: Option<String>,
+    tool_calls: Vec<ToolCall>,
+    raw_tool_calls: Vec<ToolCallResponse>,
+    finish_reason: String,
 }
 
 /// Chat with a file using LLM tool calling
@@ -105,40 +121,102 @@ pub async fn chat_handler(
         }
     };
 
-    // Initialize Groq client
-    let groq = match GroqClient::from_env() {
-        Ok(client) => client,
-        Err(GroqError::MissingApiKey) => {
-            return (
-                StatusCode::SERVICE_UNAVAILABLE,
-                Json(serde_json::json!({
-                    "error": "GROQ_API_KEY not configured"
-                })),
-            )
-                .into_response();
+    // Parse model selection (default to Claude Sonnet)
+    let model = request
+        .model
+        .as_ref()
+        .and_then(|m| LlmModel::from_str(m))
+        .unwrap_or_default();
+
+    tracing::info!("Using LLM model: {:?}", model);
+
+    // Initialize the appropriate LLM client
+    let llm_client = match model {
+        LlmModel::ClaudeSonnet => {
+            match ClaudeClient::from_env(ClaudeModel::Sonnet) {
+                Ok(client) => LlmClient::Claude(client),
+                Err(ClaudeError::MissingApiKey) => {
+                    return (
+                        StatusCode::SERVICE_UNAVAILABLE,
+                        Json(serde_json::json!({
+                            "error": "ANTHROPIC_API_KEY not configured"
+                        })),
+                    )
+                        .into_response();
+                }
+                Err(e) => {
+                    return (
+                        StatusCode::INTERNAL_SERVER_ERROR,
+                        Json(serde_json::json!({
+                            "error": format!("Claude client error: {}", e)
+                        })),
+                    )
+                        .into_response();
+                }
+            }
         }
-        Err(e) => {
-            return (
-                StatusCode::INTERNAL_SERVER_ERROR,
-                Json(serde_json::json!({
-                    "error": format!("Groq client error: {}", e)
-                })),
-            )
-                .into_response();
+        LlmModel::ClaudeOpus => {
+            match ClaudeClient::from_env(ClaudeModel::Opus) {
+                Ok(client) => LlmClient::Claude(client),
+                Err(ClaudeError::MissingApiKey) => {
+                    return (
+                        StatusCode::SERVICE_UNAVAILABLE,
+                        Json(serde_json::json!({
+                            "error": "ANTHROPIC_API_KEY not configured"
+                        })),
+                    )
+                        .into_response();
+                }
+                Err(e) => {
+                    return (
+                        StatusCode::INTERNAL_SERVER_ERROR,
+                        Json(serde_json::json!({
+                            "error": format!("Claude client error: {}", e)
+                        })),
+                    )
+                        .into_response();
+                }
+            }
+        }
+        LlmModel::GroqKimi => {
+            match GroqClient::from_env() {
+                Ok(client) => LlmClient::Groq(client),
+                Err(GroqError::MissingApiKey) => {
+                    return (
+                        StatusCode::SERVICE_UNAVAILABLE,
+                        Json(serde_json::json!({
+                            "error": "GROQ_API_KEY not configured"
+                        })),
+                    )
+                        .into_response();
+                }
+                Err(e) => {
+                    return (
+                        StatusCode::INTERNAL_SERVER_ERROR,
+                        Json(serde_json::json!({
+                            "error": format!("Groq client error: {}", e)
+                        })),
+                    )
+                        .into_response();
+                }
+            }
         }
     };
 
     // Build context about the file
     let file_context = build_file_context(&file);
 
-    // Build messages
-    let messages = vec![
+    // Build initial messages (Groq/OpenAI format - will be converted for Claude)
+    let mut messages = vec![
         Message {
             role: "system".to_string(),
             content: Some(format!(
                 "You are a helpful assistant that helps users edit and analyze document files. \
                 You have access to tools to add headings, paragraphs, charts, and set summaries. \
                 When the user asks you to modify the file, use the appropriate tools.\n\n\
+                IMPORTANT: You can call multiple tools in sequence. For example, if the user provides CSV data \
+                and asks for a chart, first call parse_csv to convert the data to JSON, then use that JSON \
+                to call add_chart.\n\n\
                 Current file context:\n{}",
                 file_context
             )),
@@ -153,46 +231,154 @@ pub async fn chat_handler(
         },
     ];
 
-    // Call Groq API
-    let result = match groq.chat_with_tools(messages, &AVAILABLE_TOOLS).await {
-        Ok(result) => result,
-        Err(e) => {
-            tracing::error!("Groq API error: {}", e);
-            return (
-                StatusCode::INTERNAL_SERVER_ERROR,
-                Json(serde_json::json!({
-                    "error": format!("LLM API error: {}", e)
-                })),
-            )
-                .into_response();
-        }
-    };
-
-    // Execute tool calls
+    // State for tracking changes
     let mut current_body = file.body.clone();
     let mut current_summary = file.summary.clone();
-    let mut tool_call_infos = Vec::new();
+    let mut all_tool_call_infos: Vec<ToolCallInfo> = Vec::new();
+    let mut final_response: Option<String> = None;
 
-    for tool_call in &result.tool_calls {
-        let execution_result =
-            execute_tool_call(tool_call, &current_body, current_summary.as_deref());
+    // Multi-turn tool calling loop
+    for round in 0..MAX_TOOL_ROUNDS {
+        tracing::debug!(round = round, "LLM tool calling round");
 
-        // Apply state changes
-        if let Some(new_body) = execution_result.new_body {
-            current_body = new_body;
-        }
-        if let Some(new_summary) = execution_result.new_summary {
-            current_summary = Some(new_summary);
+        // Call the appropriate LLM API
+        let result = match &llm_client {
+            LlmClient::Groq(groq) => {
+                match groq.chat_with_tools(messages.clone(), &AVAILABLE_TOOLS).await {
+                    Ok(r) => LlmResult {
+                        content: r.content,
+                        tool_calls: r.tool_calls,
+                        raw_tool_calls: r.raw_tool_calls,
+                        finish_reason: r.finish_reason,
+                    },
+                    Err(e) => {
+                        tracing::error!("Groq API error: {}", e);
+                        return (
+                            StatusCode::INTERNAL_SERVER_ERROR,
+                            Json(serde_json::json!({
+                                "error": format!("LLM API error: {}", e)
+                            })),
+                        )
+                            .into_response();
+                    }
+                }
+            }
+            LlmClient::Claude(claude_client) => {
+                // Convert messages to Claude format
+                let claude_messages = claude::groq_messages_to_claude(&messages);
+                match claude_client.chat_with_tools(claude_messages, &AVAILABLE_TOOLS).await {
+                    Ok(r) => {
+                        // Convert Claude tool uses to Groq-style ToolCallResponse for consistency
+                        let raw_tool_calls: Vec<ToolCallResponse> = r
+                            .tool_calls
+                            .iter()
+                            .map(|tc| ToolCallResponse {
+                                id: tc.id.clone(),
+                                call_type: "function".to_string(),
+                                function: crate::llm::groq::FunctionCall {
+                                    name: tc.name.clone(),
+                                    arguments: tc.arguments.to_string(),
+                                },
+                            })
+                            .collect();
+
+                        LlmResult {
+                            content: r.content,
+                            tool_calls: r.tool_calls,
+                            raw_tool_calls,
+                            finish_reason: r.stop_reason,
+                        }
+                    }
+                    Err(e) => {
+                        tracing::error!("Claude API error: {}", e);
+                        return (
+                            StatusCode::INTERNAL_SERVER_ERROR,
+                            Json(serde_json::json!({
+                                "error": format!("LLM API error: {}", e)
+                            })),
+                        )
+                            .into_response();
+                    }
+                }
+            }
+        };
+
+        // Check if there are tool calls to execute
+        if result.tool_calls.is_empty() {
+            // No more tool calls - capture the final response and exit loop
+            final_response = result.content;
+            break;
         }
 
-        tool_call_infos.push(ToolCallInfo {
-            name: tool_call.name.clone(),
-            result: execution_result.result,
+        // Add assistant message with tool calls to conversation
+        messages.push(Message {
+            role: "assistant".to_string(),
+            content: result.content.clone(),
+            tool_calls: Some(result.raw_tool_calls.clone()),
+            tool_call_id: None,
         });
+
+        // Execute each tool call and add results to conversation
+        for (i, tool_call) in result.tool_calls.iter().enumerate() {
+            let execution_result =
+                execute_tool_call(tool_call, &current_body, current_summary.as_deref());
+
+            // Apply state changes
+            if let Some(new_body) = execution_result.new_body {
+                current_body = new_body;
+            }
+            if let Some(new_summary) = execution_result.new_summary {
+                current_summary = Some(new_summary);
+            }
+
+            // Build tool result message content
+            let result_content = if let Some(parsed_data) = &execution_result.parsed_data {
+                // Include parsed data in the result for the LLM to use
+                serde_json::json!({
+                    "success": execution_result.result.success,
+                    "message": execution_result.result.message,
+                    "data": parsed_data
+                })
+                .to_string()
+            } else {
+                serde_json::json!({
+                    "success": execution_result.result.success,
+                    "message": execution_result.result.message
+                })
+                .to_string()
+            };
+
+            // Add tool result message
+            // Use the appropriate ID format for each provider
+            let tool_call_id = match &llm_client {
+                LlmClient::Groq(_) => result.raw_tool_calls[i].id.clone(),
+                LlmClient::Claude(_) => tool_call.id.clone(),
+            };
+
+            messages.push(Message {
+                role: "tool".to_string(),
+                content: Some(result_content),
+                tool_calls: None,
+                tool_call_id: Some(tool_call_id),
+            });
+
+            // Track for response
+            all_tool_call_infos.push(ToolCallInfo {
+                name: tool_call.name.clone(),
+                result: execution_result.result,
+            });
+        }
+
+        // If finish reason indicates completion, exit loop
+        let finish_lower = result.finish_reason.to_lowercase();
+        if finish_lower == "stop" || finish_lower == "end_turn" {
+            final_response = result.content;
+            break;
+        }
     }
 
     // Save changes to database if any tools were executed
-    if !result.tool_calls.is_empty() {
+    if !all_tool_call_infos.is_empty() {
         let update_req = crate::db::models::UpdateFileRequest {
             name: None,
             description: None,
@@ -214,14 +400,14 @@ pub async fn chat_handler(
     }
 
     // Build response
-    let response_text = result.content.unwrap_or_else(|| {
-        if tool_call_infos.is_empty() {
+    let response_text = final_response.unwrap_or_else(|| {
+        if all_tool_call_infos.is_empty() {
             "I couldn't understand your request. Please try rephrasing.".to_string()
         } else {
             format!(
                 "Done! Executed {} tool{}.",
-                tool_call_infos.len(),
-                if tool_call_infos.len() == 1 { "" } else { "s" }
+                all_tool_call_infos.len(),
+                if all_tool_call_infos.len() == 1 { "" } else { "s" }
             )
         }
     });
@@ -230,7 +416,7 @@ pub async fn chat_handler(
         StatusCode::OK,
         Json(ChatResponse {
             response: response_text,
-            tool_calls: tool_call_infos,
+            tool_calls: all_tool_call_infos,
             updated_body: current_body,
             updated_summary: current_summary,
         }),