Slow Tool Silence

class ToolAcknowledgmentManager:
    """Manage acknowledgments for tool calls"""
    
    # Pre-configured acknowledgments (instant playback, no LLM)
    TOOL_ACKNOWLEDGMENTS = {
        "order_lookup": {
            "start": "Let me pull up your order...",
            "long": "Still checking, one moment...",
            "error": "I'm having trouble finding that. Let me try again."
        },
        "account_balance": {
            "start": "Checking your balance...",
            "long": "Just a moment...",
            "error": "I couldn't access your account. Let me try another way."
        },
        "knowledge_search": {
            "start": "Let me find that information...",
            "long": "Searching our database...",
            "error": "I'm not finding that. Let me rephrase."
        },
        "shipping_update": {
            "start": "Updating your shipping...",
            "long": "Processing that change...",
            "error": "The update didn't go through. Let me try again."
        },
        "default": {
            "start": "Let me check on that...",
            "long": "One moment...",
            "error": "Let me try that again."
        }
    }
    
    LONG_THRESHOLD_MS = 3000  # When to play "long" message
    
    def __init__(self, tts_player):
        self.tts = tts_player
        self.active_tools = {}
    
    def on_tool_start(self, tool_name: str, call_id: str):
        """Play acknowledgment when tool starts"""
        ack_config = self.TOOL_ACKNOWLEDGMENTS.get(
            tool_name, 
            self.TOOL_ACKNOWLEDGMENTS["default"]
        )
        
        # Play start acknowledgment immediately
        self.tts.play_instant(ack_config["start"])
        
        # Schedule long-running acknowledgment
        self.active_tools[call_id] = {
            "tool": tool_name,
            "start_time": time.time(),
            "long_played": False
        }
        
        # Schedule timeout check
        self.schedule_long_check(call_id, ack_config["long"])
    
    def schedule_long_check(self, call_id: str, long_message: str):
        """Schedule check for long-running tool"""
        async def check_and_play():
            await asyncio.sleep(self.LONG_THRESHOLD_MS / 1000)
            
            if call_id in self.active_tools:
                tool_state = self.active_tools[call_id]
                if not tool_state["long_played"]:
                    self.tts.play_instant(long_message)
                    tool_state["long_played"] = True
        
        asyncio.create_task(check_and_play())
    
    def on_tool_complete(self, call_id: str, success: bool):
        """Handle tool completion"""
        if call_id in self.active_tools:
            tool_state = self.active_tools.pop(call_id)
            
            if not success:
                tool_name = tool_state["tool"]
                ack_config = self.TOOL_ACKNOWLEDGMENTS.get(
                    tool_name,
                    self.TOOL_ACKNOWLEDGMENTS["default"]
                )
                self.tts.play_instant(ack_config["error"])


class InstantTTSPlayer:
    """Play pre-synthesized TTS instantly"""
    
    def __init__(self):
        # Pre-synthesize common acknowledgments
        self.cache = {}
        self.preload_acknowledgments()
    
    def preload_acknowledgments(self):
        """Pre-synthesize all acknowledgment audio"""
        all_acks = []
        for config in ToolAcknowledgmentManager.TOOL_ACKNOWLEDGMENTS.values():
            all_acks.extend(config.values())
        
        for text in set(all_acks):
            self.cache[text] = self.synthesize(text)
    
    def synthesize(self, text: str) -> bytes:
        """Synthesize text to audio (cached)"""
        # TTS synthesis
        return tts_engine.synthesize(text)
    
    def play_instant(self, text: str):
        """Play cached audio instantly"""
        if text in self.cache:
            audio = self.cache[text]
        else:
            audio = self.synthesize(text)
            self.cache[text] = audio
        
        # Play immediately - no LLM latency
        self.audio_output.play(audio)


class ToolCallWrapper:
    """Wrapper to handle tool calls with acknowledgments"""
    
    def __init__(self, ack_manager: ToolAcknowledgmentManager):
        self.ack = ack_manager
    
    async def call_with_ack(self, tool_name: str, 
                             tool_func: callable, 
                             **kwargs) -> dict:
        """Call tool with automatic acknowledgment"""
        call_id = str(uuid.uuid4())
        
        # Play acknowledgment immediately
        self.ack.on_tool_start(tool_name, call_id)
        
        try:
            # Execute tool
            result = await tool_func(**kwargs)
            self.ack.on_tool_complete(call_id, success=True)
            return {"success": True, "result": result}
        
        except Exception as e:
            self.ack.on_tool_complete(call_id, success=False)
            return {"success": False, "error": str(e)}

instructions: |
  ## TOOL CALL HANDLING
  
  When you need to call a tool (lookup, API, search):
  
  1. DO NOT generate an acknowledgment yourself
     (This adds ~600ms latency on top of tool time)
  
  2. The system will automatically play:
     - "Let me check on that..." when tool starts
     - "One moment..." if tool takes > 3 seconds
     - Error message if tool fails
  
  3. Just call the tool - acknowledgment is automatic
  
  WRONG (adds latency):