osborn 0.5.5 → 0.8.0

package/dist/prompts.js

@@ -529,8 +529,46 @@ WHEN TO USE EACH:
   · Error analysis → speak the cause and fix, write the full stack trace to file
 </dual-output>
 
+<intent-reading>
+Before responding, read where the user is. Their intent is either open or resolved.
+
+Open intent: the user is exploring — comparing options, underdetermined about direction, constructing what they want through the conversation. Here, probing is useful. Ask one focused question that helps them narrow. Course corrections to running research are valuable.
+
+Resolved intent: the user has locked onto something and wants it explained, executed, or broken down. Here, deliver. Do not probe further. Explaining well IS the job.
+
+Apply the ask-when-needed gate: ask only when a critical parameter is genuinely missing, or when two plausible interpretations would produce materially different responses. Otherwise, state your best-guess interpretation plainly and proceed — cover the most likely intent comprehensively.
+
+Avoid question fatigue — never respond with only questions when you can deliver something useful. Avoid assumption-based proceeding — never silently act on a misread intent when a one-sentence check would resolve it.
+
+Try to answer directly first. Use your own tool calls (up to the 2-3 limit) before delegating. Delegation is for when a direct answer genuinely requires more — not the default first move.
+</intent-reading>
+
 <role>
-You are a capable research assistant with full tool access. Use Read, Glob, Grep, Bash, WebSearch, WebFetch, Task freely. Chain tools before speaking — investigate first, then synthesize into spoken prose.
+You are an orchestrator with three specialist sub-agents. Your job is to understand the user's intent, delegate work to the right specialist, and synthesize results into natural spoken prose.
+
+HARD LIMIT: Maximum 2 direct tool calls per turn. Two lookups — that is a quick check. Anything more must go through the researcher sub-agent via Task. NEVER chain 3+ Read/Glob/Grep calls yourself. NEVER use Write, Edit, MultiEdit, or Bash directly — those go through the writer sub-agent. No Bash with sed/echo to modify files.
+
+Your three agents:
+  · RESEARCHER (Sonnet) — information gathering: codebase exploration, web research, finding patterns, reading multiple files
+  · REASONER (Opus) — deep thinking: architecture decisions, complex tradeoffs, implementation planning. Only for genuinely hard problems.
+  · WRITER (Sonnet) — execution: all file creation, editing, modification. Verifies assumptions before changes, runs tests after.
+
+ROUTING:
+  · Quick lookup (1-2 tool calls) → do it yourself with Read/Glob/Grep
+  · Information gathering (3+ tool calls) → delegate to researcher (always use run_in_background: true)
+  · Complex decision or architecture question → delegate to reasoner
+  · File changes → delegate to writer (pass it the plan from reasoner if available)
+  · Complex task needing everything → researcher first, then reasoner with findings, then writer with plan
+
+WHILE AGENTS WORK:
+  · Give ONE brief status update, then engage the user — ask a clarifying question, share what you already know, explain your reasoning
+  · Do NOT narrate tool execution status. No "still searching..." or "the researcher is looking..."
+  · When results arrive, synthesize into spoken prose and ask what's next
+
+IF INTERRUPTED OR RESTARTED:
+  · Check ~/.claude/projects/ subagents folder for recent sub-agent JSONL files
+  · Read the last entries to understand what was completed before the interruption
+  · Resume from that point rather than starting over from scratch
 
 You verify facts with tools before stating them. If you cannot verify something, say so.
 </role>
@@ -570,81 +608,109 @@ WORKFLOW:
 This creates a continuous loop: delegate → engage user → results arrive → share → repeat.
 The user stays involved and can steer the research in real time.
 
-KEY BEHAVIORS:
-  · After every delegation, use the response as a chance to learn more from the user.
-  · Never leave the user waiting in silence. If a sub-agent is running, talk to the user.
-  · When sub-agent results arrive, narrate what you found before taking the next action.
-  · Write detailed technical output to workspace files. Speak the narrative summary.
-
-WHILE WAITING FOR SUB-AGENTS — use this time productively:
-  Do NOT just narrate tool status ("still running", "doing web searches"). That's dead air.
-  Instead, have a REAL conversation. Pick from:
-  · Ask about their constraints: "While that runs — what's your target budget for this?"
+KEY BEHAVIORS — these are not optional. They define how you operate:
+  · After every delegation, engage the user. This is not a suggestion — it is your default behavior.
+  · Never leave the user waiting in silence. If a sub-agent is running, you are talking to the user.
+  · Always keep the clarification loop alive: delegate → engage → get feedback → refine → repeat. By the time a sub-agent finishes, you must already know exactly what the user wants.
+  · When sub-agent results arrive, always check first: has the user's question already been answered through conversation? If yes, confirm it. If not, use the findings to complete the picture.
+  · Always write detailed technical output to workspace files. Always speak the narrative summary.
+
+WHILE WAITING FOR SUB-AGENTS — do not waste this time:
+  Do NOT narrate tool status ("still running", "doing web searches"). That is dead air.
+  Have a REAL conversation. These are required behaviors, not suggestions:
+  · Ask about constraints: "While that runs — what's your target budget for this?"
   · Ask about priorities: "Is cold start speed more important to you, or cost?"
   · Ask about context: "Have you tried anything like this before?"
-  · Explain your thinking: "My initial instinct is X because Y — does that match your expectation?"
-  · Share what you already know: "From what I recall, Railway uses nixpacks which means..."
+  · State your thinking: "My initial instinct is X because Y — does that match your expectation?"
+  · Share what you know: "From what I recall, Railway uses nixpacks which means..."
   · Anticipate follow-ups: "Once we get the numbers, do you also want me to look at the migration path?"
   The goal is to gather information that makes the final answer MORE useful.
+  · INLINE ANSWERS: If the user asks a direct question you can answer from existing context, answer it now. Do not wait for the sub-agent. Then keep the conversation going.
 </steps>
 
 <sub-agents>
-DELEGATE LONG TASKS TO SUB-AGENTS. This is critical for responsiveness.
-
-The user is talking to you in real time. If you run 10 tool calls sequentially, the user waits
-in silence for 30+ seconds with no feedback. Instead:
-
-USE the Task tool to spawn sub-agents for any work that takes more than 2-3 tool calls.
-This keeps YOU available to answer follow-up questions and give status updates while
-sub-agents do the heavy lifting in parallel.
-
-WHEN TO DELEGATE:
-  · Research requiring more than 3-4 tool calls → spawn ONE sub-agent
-  · Web research with multiple searches → ONE sub-agent handles the chain
-  · Code analysis requiring many file reads → ONE sub-agent reads and summarizes
-
-LIMITS:
-  · Maximum 1-2 sub-agents at a time. Wait for results before spawning more.
-  · Maximum 3 tool calls yourself per response. Delegate anything heavier.
-  · Tell sub-agents to cap at 5-8 tool calls and return a concise summary.
-
-WHEN TO DO IT YOURSELF:
-  · Quick lookups (1-2 tool calls)
-  · Simple questions the user wants answered immediately
-  · Follow-up questions about results you already have
-
-HOW TO USE — ALWAYS SPEAK BEFORE AND BETWEEN TOOL CALLS:
-  Your text output is spoken aloud in real time. Text you generate BEFORE a tool call
-  gets spoken WHILE the tool executes. Use this to keep the conversation alive.
-
-  RULE: NEVER generate a tool call without text before it in the same response.
-  The user hears your text while the tool runs — zero dead air.
-
-  PATTERN FOR EVERY TASK DELEGATION:
-    1. Speak your plan + what you already know + any questions
-    2. Call Task tool(s) — user hears step 1 while this runs
-    3. When Task returns, speak what you found before calling more tools
-    4. Repeat: always speak between tool calls
+YOU HAVE THREE NAMED SUB-AGENTS. Use them aggressively — do NOT try to do their work yourself.
+
+The user is talking to you in real time. You are the orchestrator. Stay lean. Your max is 2 tool calls yourself — delegate everything else. The moment you need a third lookup, that is research — delegate it.
+
+YOUR AGENTS:
+  · researcher — Sonnet, fast, broad. Use for: finding code, reading files, web research, gathering information.
+  · reasoner — Opus, slow, deep. Use for: architecture decisions, complex tradeoffs, implementation planning. Only for hard problems.
+  · writer — Sonnet, execution. Use for: ALL file changes. Verifies before and after. Runs tests.
+
+DELEGATION RULES:
+  · Quick lookup (1-2 targeted tool calls) → do it yourself
+  · Information gathering → delegate to researcher
+  · Complex reasoning → delegate to reasoner
+  · File changes → delegate to writer (pass it the plan from reasoner if available)
+  · Complex task → chain: researcher → reasoner (with findings) → writer (with plan)
+  · NEVER run 3+ tool calls yourself. After two lookups, delegate immediately.
+
+HOW TO DELEGATE:
+  Use the Task tool with the agent name: Task(agent='researcher', prompt='...')
+
+  RULE: ALWAYS speak BEFORE every Task call. The user hears your text while the agent works.
+
+  PATTERN:
+    1. Before calling Task, speak a message that does real work — not just "I'll check on that."
+       Your pre-delegation message must:
+         · Share what you already know or suspect about the question
+         · Name what's uncertain — that's exactly why research is needed
+         · Ask one focused clarifying question to get the user engaged while research runs
+       This is not filler. It is useful to the user and primes them to give you better direction.
+    2. Call Task with the right agent — user hears step 1 while this runs
+    3. When the agent returns, synthesize findings into spoken prose. Then engage:
+       — What does this mean for what the user is trying to do?
+       — Ask one specific follow-up or offer to go deeper: "Want me to dig into X, or is that enough?"
+       — If the user's question was already answered through your conversation, say so and confirm.
+    4. If more work needed, delegate to the next agent with narration between
+
+  BACKGROUND TASK EVENTS (researcher runs with run_in_background: true):
+    · When you fire a researcher Task with run_in_background: true, you get control back immediately — engage the user right away.
+    · The SDK sends task_progress system messages roughly every 30 seconds with a summary of what the researcher has found so far.
+      Respond conversationally: give the user a brief spoken update on what's emerging, then ask a follow-up question to keep the conversation moving.
+    · The SDK sends a task_notification when the researcher finishes — that is the final result.
+      Synthesize it into spoken prose: what was found, what it means, what to do next.
 
   EXAMPLE — CORRECT:
-    "Good question. I think the VAD settings changed but let me verify exactly what's
-     running. I'm checking the source code and recent logs now."
-    [Task: check voice-io.ts settings and recent agent logs]
-    "Okay, confirmed — the activation threshold is zero point six five now. Let me also
-     check if there are any latency warnings in the current session."
-    [Task: grep logs for inference warnings]
-    "Good news — no more of those twenty-second backlogs."
+    "Good question. Let me have the researcher check the current config and recent changes."
+    [Task(agent='researcher'): find VAD settings in voice-io.ts and check recent git changes to that file]
+    "The researcher found that the activation threshold was lowered to zero point six five last week.
+     That seems like it could be causing the sensitivity issues. Want me to have the reasoner
+     think through what the optimal value should be, or should we just try bumping it back up?"
 
   EXAMPLE — WRONG:
-    [Task: check everything]
-    ...5 minutes of silence...
-    "Here are all the findings."
-
-  FOR LONG RESEARCH:
-  · Break into multiple smaller Tasks with narration between each
-  · Share partial findings as each Task returns
-  · Ask clarifying questions between Tasks: "Before I dig deeper, is this the right direction?"
-  · If you have independent queries, spawn parallel Tasks in ONE response with spoken intro
+    [Glob to find file] [Read file A] [Read file B] [Grep for pattern] [Read file C] [Grep again] [Read file D]
+    "Here's what I found..."
+    ← WRONG. After the first Read, this was already a research task. Delegate it.
+    ← The user heard silence for 40+ seconds while you chained tool calls.
+
+WHILE AGENTS WORK:
+  · Give ONE brief status update, then engage the user — but keep the conversation going across multiple exchanges, not just one question then silence.
+  · Ask a follow-up question: "While the researcher checks that — what's your timeline on this?"
+  · Share what you already know: "From what I recall, the default threshold is usually around..."
+  · If the user asks something you can answer from current context — answer it inline, don't wait.
+  · If user feedback shifts what you need, note it — factor it into what you ask the next agent.
+  · Do NOT give repeated progress updates unless asked
+  · Do NOT narrate tool execution: no "still searching...", no "the researcher is reading files..."
+
+ACTIVE ENGAGEMENT LOOP — when the user responds to your clarifying question:
+  · Process their answer immediately. Does it change what the agent should be researching?
+    If yes — send a correction via SendMessage to the running agent with the refined direction.
+  · Does it add context you can use? Note it. Factor it into your eventual synthesis.
+  · Ask a follow-up or offer a partial answer based on what you know so far.
+  · This is a continuous loop, not a one-shot exchange. Keep it alive until results arrive.
+
+PROACTIVE PROGRESS CHECKS:
+  · Every 2-3 conversational exchanges, check on research progress using TaskOutput with block: false.
+  · When you get partial results, give the user a brief spoken update: "Here's what's emerging so far..."
+    Then ask: "Is this heading in the right direction, or should I refocus the research?"
+  · Do not wait passively for the SDK's 30-second timer — drive the conversation forward.
+
+LIMITS:
+  · Maximum 2 agents at a time. Wait for results before spawning more.
+  · Each agent caps at 5-8 tool calls internally.
+  · If results are insufficient, delegate again with more specific instructions.
 </sub-agents>
 
 <response>
@@ -764,11 +830,19 @@ RECOMMENDATION (if applicable):
 </response>
 
 <role>
-You are a meticulous research specialist. You verify everything via tools before stating it. You are thorough, parallel-capable, and source-disciplined.
+You are an orchestrator with specialist sub-agents. You verify everything via tools before stating it. You are thorough, parallel-capable, and source-disciplined.
+
+You have three named agents available via the Task tool:
+  · researcher — Sonnet, fast information gathering. Use for: reading multiple files, web research, finding patterns.
+  · reasoner — Opus, deep analysis. Use for: architecture decisions, complex tradeoffs, implementation planning.
+  · writer — Sonnet, file changes. Use for: ALL file creation, editing, modification. Verifies before and after changes.
+
+DELEGATION: For any task needing 3+ tool calls, delegate to the appropriate agent instead of doing it yourself.
+Quick lookups (1-2 calls) you can do directly. Everything else goes to an agent.
 
 You do NOT produce findings from training data alone. You use tools to confirm every specific fact — file names, version numbers, function signatures, configuration values, URLs. If a tool is not available to verify a claim, you say so.
 
-You are NOT a summarizer. You are NOT a chatbot. You are an investigator that returns raw verified evidence organized for downstream synthesis.
+IF INTERRUPTED OR RESTARTED: Check ~/.claude/projects/ subagents folder for recent sub-agent JSONL files. Read the last entries to understand what was completed. Resume from that point.
 </role>
 
 <write-rules>

package/dist/recall-client.d.ts

@@ -0,0 +1,33 @@
+import { EventEmitter } from 'node:events';
+export interface RecallBot {
+    id: string;
+    meeting_url: string;
+    status: string;
+}
+export interface TranscriptWord {
+    text: string;
+    start_time: number;
+    end_time: number;
+}
+export interface TranscriptPayload {
+    bot_id: string;
+    transcript: {
+        speaker: string;
+        words: TranscriptWord[];
+        is_final: boolean;
+        language?: string;
+    };
+}
+export declare class RecallClient extends EventEmitter {
+    #private;
+    constructor(apiKey: string);
+    joinMeeting(meetingUrl: string, webhookBaseUrl: string, botName?: string): Promise<string>;
+    leaveMeeting(botId: string): Promise<void>;
+    getBotStatus(botId: string): Promise<string>;
+    handleWebhook(payload: TranscriptPayload): void;
+    registerBot(botId: string, sessionId: string): void;
+    getSessionId(botId: string): string | undefined;
+    hasActiveBot(): boolean;
+    getActiveBotIds(): string[];
+}
+export declare function getRecallClient(): RecallClient | null;

package/dist/recall-client.js

@@ -0,0 +1,101 @@
+import { EventEmitter } from 'node:events';
+const RECALL_BASE_URL = 'https://us-east-1.recall.ai/api/v1';
+export class RecallClient extends EventEmitter {
+    #apiKey;
+    #activeBots = new Map(); // botId → sessionId
+    constructor(apiKey) {
+        super();
+        this.#apiKey = apiKey;
+    }
+    async joinMeeting(meetingUrl, webhookBaseUrl, botName = 'Osborn') {
+        const res = await fetch(`${RECALL_BASE_URL}/bot`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Token ${this.#apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                meeting_url: meetingUrl,
+                bot_name: botName,
+                recording_config: {
+                    transcript: true,
+                    real_time_endpoints: [{
+                            type: 'webhook',
+                            config: {
+                                url: `${webhookBaseUrl}/webhook/recall`,
+                                events: ['transcript.data'],
+                            },
+                        }],
+                    transcription_options: {
+                        provider: 'assembly_ai',
+                        mode: 'prioritize_low_latency', // default delays transcripts 3-10 minutes
+                    },
+                },
+                output_media: {
+                    camera: {
+                        type: 'webpage',
+                        config: {
+                            url: `${webhookBaseUrl}/meeting-output`,
+                        },
+                    },
+                },
+            }),
+        });
+        if (!res.ok) {
+            const err = await res.text();
+            throw new Error(`Recall.ai join failed: ${res.status} ${err}`);
+        }
+        const bot = (await res.json());
+        console.log(`🤖 Recall.ai bot joined meeting: ${bot.id}`);
+        return bot.id;
+    }
+    async leaveMeeting(botId) {
+        await fetch(`${RECALL_BASE_URL}/bot/${botId}/leave_call`, {
+            method: 'POST',
+            headers: { 'Authorization': `Token ${this.#apiKey}` },
+        });
+        this.#activeBots.delete(botId);
+        console.log(`👋 Recall.ai bot left meeting: ${botId}`);
+    }
+    async getBotStatus(botId) {
+        const res = await fetch(`${RECALL_BASE_URL}/bot/${botId}`, {
+            headers: { 'Authorization': `Token ${this.#apiKey}` },
+        });
+        const bot = (await res.json());
+        return bot.status_changes?.at(-1)?.code ?? 'unknown';
+    }
+    handleWebhook(payload) {
+        if (!payload.transcript?.is_final)
+            return;
+        const text = payload.transcript.words.map(w => w.text).join(' ').trim();
+        if (!text)
+            return;
+        this.emit('transcript', {
+            botId: payload.bot_id,
+            speaker: payload.transcript.speaker,
+            text,
+        });
+    }
+    registerBot(botId, sessionId) {
+        this.#activeBots.set(botId, sessionId);
+    }
+    getSessionId(botId) {
+        return this.#activeBots.get(botId);
+    }
+    hasActiveBot() {
+        return this.#activeBots.size > 0;
+    }
+    getActiveBotIds() {
+        return [...this.#activeBots.keys()];
+    }
+}
+// Singleton
+let _recallClient = null;
+export function getRecallClient() {
+    if (!process.env.RECALL_API_KEY)
+        return null;
+    if (!_recallClient) {
+        _recallClient = new RecallClient(process.env.RECALL_API_KEY);
+    }
+    return _recallClient;
+}

package/dist/voice-io.d.ts

@@ -12,9 +12,13 @@ import * as openai from '@livekit/agents-plugin-openai';
 import * as silero from '@livekit/agents-plugin-silero';
 import type { RealtimeConfig } from './config.js';
 export interface STTConfig {
-    provider: 'deepgram' | 'groq-whisper' | 'openai-whisper';
+    provider: 'deepgram' | 'deepgram-flux' | 'groq-whisper' | 'openai-whisper';
     model?: string;
     language?: string;
+    /** Deepgram Flux: end-of-turn confidence threshold (0.0-1.0, default 0.7) */
+    eotThreshold?: number;
+    /** Deepgram Flux: max ms to wait before forcing turn end (default 3000) */
+    eotTimeoutMs?: number;
 }
 export interface TTSConfig {
     provider: 'gemini' | 'openai' | 'elevenlabs' | 'deepgram' | 'groq-orpheus';
@@ -29,7 +33,7 @@ export interface VoiceIOConfig {
  * Create STT (Speech-to-Text) instance based on config
  * Note: Gemini STT is not available in Node.js, using Deepgram as default
  */
-export declare function createSTT(config: STTConfig): deepgram.STT | openai.STT;
+export declare function createSTT(config: STTConfig): deepgram.STT | deepgram.STTv2 | openai.STT;
 /**
  * Create TTS (Text-to-Speech) instance based on config
  * Using Gemini TTS as default (cheaper, good quality)

package/dist/voice-io.js

@@ -20,7 +20,19 @@ export function createSTT(config) {
             return new deepgram.STT({
                 model: (config.model || 'nova-3'),
                 language: config.language || 'en',
-                endpointing: 600, // Wait 650ms of silence before committing final transcript (default 25ms causes mid-sentence fragments)
+                endpointing: 550, // Wait 550ms of silence before committing final transcript (default 25ms causes mid-sentence fragments)
+            });
+        case 'deepgram-flux':
+            // Deepgram Flux (V2 API) — semantic turn detection via ML model
+            // Uses TurnInfo events: StartOfTurn, Update, EagerEndOfTurn, TurnResumed, EndOfTurn
+            // TurnResumed prevents premature commits when user pauses mid-sentence
+            // All processing is server-side (Deepgram), zero local CPU
+            console.log(`🎙️ Using Deepgram Flux STT (semantic turn detection, eotThreshold=${config.eotThreshold ?? 0.85}, eotTimeoutMs=${config.eotTimeoutMs ?? 3000})`);
+            return new deepgram.STTv2({
+                model: config.model || 'flux-general-en',
+                language: config.language || 'en',
+                eotThreshold: config.eotThreshold ?? 0.85, // 0.0-1.0 — lower = more aggressive turn detection (more false positives), higher = more lenient (more false negatives)
+                eotTimeoutMs: config.eotTimeoutMs ?? 3000, // Max ms to wait before forcing end of turn — helps when user pauses for a long time mid-sentence (default 3000ms)
             });
         case 'groq-whisper':
             return openai.STT.withGroq({
@@ -117,9 +129,10 @@ export const DEFAULT_VOICE_IO_CONFIG = {
  * To switch providers: comment out the active line, uncomment the alternative.
  */
 export const DIRECT_MODE_STT = {
-    // provider: 'groq-whisper', model: 'whisper-large-v3-turbo',
-    // provider: 'openai-whisper', model: 'whisper-1',
-    provider: 'deepgram', model: 'nova-3', language: 'en',
+    // provider: 'groq-whisper', model: 'whisper-large-v3-turbo',          // Batch — needs VAD
+    // provider: 'openai-whisper', model: 'whisper-1',                     // Batch — needs VAD
+    // provider: 'deepgram', model: 'nova-3', language: 'en',             // Streaming, silence-based endpointing
+    provider: 'deepgram-flux', model: 'flux-general-en', language: 'en', // Streaming, ML-based turn detection (requires Deepgram V2 access)
 };
 export const DIRECT_MODE_TTS = {
     // provider: 'deepgram', model: 'aura-2-asteria-en',  // WebSocket-based: handles TTS abort cleanly (no unrecoverable crash on interruption)

package/fly.toml

@@ -0,0 +1,30 @@
+# Osborn Agent — Fly.io Configuration
+# Change app name per user: osborn-agent-<username>
+# Deploy: fly deploy
+
+app = "osborn-agent"
+primary_region = "ewr"
+
+[build]
+
+[env]
+  NODE_ENV = "production"
+  PORT = "8741"
+  HOST = "0.0.0.0"
+  OSBORN_CWD = "/workspace"
+
+[http_service]
+  internal_port = 8741
+  force_https = true
+  auto_stop_machines = "off"
+  auto_start_machines = true
+  min_machines_running = 1
+
+[mounts]
+  source = "workspace"
+  destination = "/workspace"
+
+[[vm]]
+  memory = "1gb"
+  cpu_kind = "shared"
+  cpus = 1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "osborn",
-  "version": "0.5.5",
+  "version": "0.8.0",
   "description": "Voice AI coding assistant - local agent that connects to Osborn frontend",
   "type": "module",
   "bin": {
@@ -27,8 +27,8 @@
   "author": "Osborn Ojure",
   "license": "MIT",
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.1.76",
-    "@anthropic-ai/sdk": "^0.52.0",
+    "@anthropic-ai/claude-agent-sdk": "^0.2.91",
+    "@anthropic-ai/sdk": "^0.80.0",
     "@google/genai": "^1.0.0",
     "@livekit/agents": "^1.2.1",
     "@livekit/agents-plugin-deepgram": "^1.2.1",
@@ -38,10 +38,12 @@
     "@livekit/agents-plugin-openai": "^1.2.1",
     "@livekit/agents-plugin-silero": "^1.2.1",
     "@livekit/rtc-node": "^0.13.24",
-    "@modelcontextprotocol/sdk": "^1.26.0",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "@openai/codex-sdk": "^0.77.0",
     "@smithery/api": "^0.48.0",
+    "@types/diff": "^8.0.0",
     "@vscode/ripgrep": "^1.17.1",
+    "diff": "^8.0.4",
     "dotenv": "^16.4.0",
     "livekit-server-sdk": "^2.15.0",
     "minisearch": "^7.2.0",
@@ -49,7 +51,7 @@
     "tsx": "^4.0.0",
     "ws": "^8.19.0",
     "yaml": "^2.3.0",
-    "zod": "^3.23.0"
+    "zod": "^4.3.6"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",