brainiac 0.0.19 → 0.0.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f6394c1ba27e48f098ae99072714cfd9cc7ca1c2412b89f62380f5d72e59a7f
-  data.tar.gz: ad4cdf5660afddfcadd96456da668452ba5d663f98eafedf2bcbefb3ba328aaa
+  metadata.gz: 619fac25bcbc560564a318e78421b8c826811abe7ba92e74de0b3b7104d8a712
+  data.tar.gz: acc359990201eaabfb5d755c17102867bce0a5a1bc68407c09ef3c4fcca94e7c
 SHA512:
-  metadata.gz: 7af17dcf8b530ff9e34bb1338dcbb57006586e0e6fd142ef21268dfb042530db56b5e427a7b7537509c13dfd4fb548674d2509d67c0109e8d3ca240fcca7656e
-  data.tar.gz: 4bd7ad87450d7c404f55b48c6e556709c0bd7fd4fc45b3f7f4ed50b97f20553ac704327540d099136a57d6928466cf9fc1750d96ac1bb128a641accc32829378
+  metadata.gz: e44c64a94143b7eb8ff47312d8b889baf91d654a5341c2a5436329693e6ed700432d6f37428c4e44cddc0369d1c1453a6df69929ac577017b6fe1900c9fa7fe5
+  data.tar.gz: 64500e610c6cc4393a640d069c442c1bff5913ca36e61cc0d0f1323891419760aef1b2e9f7717a66326d731d4b2df139e17aa47ff90b5b0f05764b3402176a71

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    brainiac (0.0.19)
+    brainiac (0.0.20)
       puma (~> 7.2)
       rackup (~> 2.3)
       sinatra (~> 4.1)
@@ -84,7 +84,7 @@ DEPENDENCIES
 CHECKSUMS
   ast (2.4.3) sha256=954615157c1d6a382bc27d690d973195e79db7f55e9765ac7c481c60bdb4d383
   base64 (0.3.0) sha256=27337aeabad6ffae05c265c450490628ef3ebd4b67be58257393227588f5a97b
-  brainiac (0.0.19)
+  brainiac (0.0.20)
   json (2.19.9) sha256=9b9025b7cdddafa38d316eca0b2358488e42d417045c1b90d216a9fefe46b79a
   language_server-protocol (3.17.0.5) sha256=fd1e39a51a28bf3eec959379985a72e296e9f9acfce46f6a79d31ca8760803cc
   lint_roller (1.1.0) sha256=2c0c845b632a7d172cb849cc90c1bce937a28c5c8ccccb50dfd46a485003cc87

data/lib/brainiac/intent.rb

@@ -14,8 +14,8 @@
 #
 #   "intent": {
 #     "enabled": true,
-#     "endpoint": "http://localhost:11434/api/generate",
-#     "model": "gemma3:4b",
+#     "endpoint": "http://localhost:11434/api/chat",
+#     "model": "qwen3:1.7b",
 #     "timeout": 10,
 #     "temperature": 0.1
 #   }
@@ -29,40 +29,24 @@
 
 INTENT_CONFIG_DEFAULTS = {
   "enabled" => false,
-  "endpoint" => "http://localhost:11434/api/generate",
-  "model" => "gemma3:4b",
+  "endpoint" => "http://localhost:11434/api/chat",
+  "model" => "qwen2.5:3b",
   "timeout" => 10,
-  "temperature" => 0.1
+  "temperature" => 0.0
 }.freeze
 
 INTENT_PROMPT_TEMPLATE = <<~PROMPT
-  You are a message router for a {{CHANNEL}}. An AI agent named {{AGENT_NAME}} is participating in this conversation. Your job: determine if the latest message requires {{AGENT_NAME}} to take action or respond.
+  Agents in this chat: {{AGENT_ROSTER}}
+  {{LAST_RESPONDER}}
 
-  {{AGENT_ROSTER}}
+  Human's message: "{{MESSAGE}}"
 
-  Rules:
-  - If the message addresses {{AGENT_NAME}} by name, gives {{AGENT_NAME}} instructions, or asks {{AGENT_NAME}} a question → yes
-  - If the message continues a conversation directed at {{AGENT_NAME}} (e.g. {{AGENT_NAME}} was the last to respond and the human follows up) → yes
-  - If the message starts with or addresses a DIFFERENT person/agent (not {{AGENT_NAME}}) → no
-  - If the message contains another agent's name (e.g. "Effie, ...", "Another one Effie", "Hey Galen") and does NOT contain "{{AGENT_NAME}}" → no
-  - If the message is humans talking to each other and {{AGENT_NAME}} is not being addressed → no
-  - If the message is a simple acknowledgment ("thanks", "ok", "got it") directed at {{AGENT_NAME}}'s previous work → no
-  - If the message is asking a question to another person or agent (not {{AGENT_NAME}}) → no
-  - If the message is responding to or commenting on what someone OTHER than {{AGENT_NAME}} just said → no
-  - If the conversation context shows a DIFFERENT agent was the last to respond, and the human's follow-up does not mention {{AGENT_NAME}} by name → no
-  - If uncertain, lean toward yes (better to respond unnecessarily than miss a request)
-
-  Critical: "addresses someone else" means someone whose name is NOT {{AGENT_NAME}}. If the message says "{{AGENT_NAME}}, ..." that IS addressed to {{AGENT_NAME}} → yes.
-
-  Respond with ONLY "yes" or "no" — nothing else.
-
-  Context:
-  {{CONTEXT}}
-
-  Latest message:
-  {{MESSAGE}}
+  Is this message directed at {{AGENT_NAME}}? Answer yes or no.
 PROMPT
 
+# Words/phrases that indicate pure acknowledgment — no action needed from the agent.
+ACKNOWLEDGMENT_PATTERN = /\A\s*(thanks|thank you|thx|ty|ok|okay|k|got it|sounds good|cool|nice|👍|🙏|✅)\s*[.!]?\s*\z/i
+
 PENDING_WORK_PROMPT_TEMPLATE = <<~PROMPT
   You are analyzing a message posted by an AI agent named {{AGENT_NAME}}. Your job: determine if this message indicates the agent intends to do more work that hasn't been completed yet.
 
@@ -138,6 +122,13 @@ end
 
 # Check whether a message requires an agent to respond.
 #
+# Uses a layered approach:
+# 1. Deterministic pre-checks (fast, no LLM):
+#    - If message names another agent → skip
+#    - If this agent was last to speak AND message isn't pure acknowledgment → respond
+#    - If a different agent was last to speak AND message doesn't name this agent → skip
+# 2. LLM fallback (only for ambiguous cases — no agent spoke, or mixed signals)
+#
 # @param message [String] The message text to classify
 # @param agent_name [String] The agent being addressed
 # @param channel [String] Context description (e.g., "Discord thread", "Fizzy card comment")
@@ -156,61 +147,97 @@ def check_intent(message, agent_name:, channel: "conversation", context: nil)
     return false
   end
 
-  context_block = if context && !context.strip.empty?
-                    # Keep only last 5 messages for the small local model — enough to determine
-                    # conversational flow without overwhelming the context window.
-                    recent = context.strip.lines.last(5).join
-                    "Recent conversation (most recent last):\n#{recent}\n\n"
-                  else
-                    ""
-                  end
+  # Deterministic conversational-flow check: use last-responder detection to
+  # resolve the common case without hitting the LLM at all.
+  last_responder = detect_last_responder_name(context)
+
+  if last_responder
+    is_acknowledgment = message.strip.match?(ACKNOWLEDGMENT_PATTERN)
+
+    if last_responder.downcase == agent_name.downcase
+      # This agent was the last to speak — human is continuing with us
+      if is_acknowledgment
+        LOG.info "[Intent] Deterministic skip for #{agent_name} — pure acknowledgment, no action needed"
+        return false
+      end
+      LOG.info "[Intent] Deterministic respond for #{agent_name} — was last to speak, human continues"
+      return true
+    else
+      # A different agent was the last to speak — this message is probably for them
+      # UNLESS it explicitly names this agent (already checked above via intent_names_other_agent? for OTHER agents,
+      # but also check if it mentions THIS agent's name directly)
+      if message_mentions_agent?(message, agent_name)
+        LOG.info "[Intent] Deterministic respond for #{agent_name} — named in message despite #{last_responder} speaking last"
+        return true
+      end
+      LOG.info "[Intent] Deterministic skip for #{agent_name} — #{last_responder} was last to speak"
+      return false
+    end
+  end
+
+  # No clear last responder detected — fall through to LLM for classification.
+  classify_intent_via_llm(message, agent_name:, channel:, config:)
+rescue OllamaModelNotFoundError => e
+  LOG.error "[Intent] #{e.message}"
+  LOG.error "[Intent] Disabling intent classification until model is installed."
+  BRAINIAC_CONFIG["intent"] ||= {}
+  BRAINIAC_CONFIG["intent"]["enabled"] = false
+  true
+rescue StandardError => e
+  LOG.warn "[Intent] Classification failed (fail-open): #{e.message}"
+  true
+end
 
-  # Build agent roster for the prompt so the model knows which names are agents
+# Fall through to LLM for intent classification when deterministic checks are inconclusive.
+# This handles cases like: no agents have spoken yet, or context is unavailable.
+def classify_intent_via_llm(message, agent_name:, channel:, config:)
   roster_block = build_intent_agent_roster(agent_name)
+  last_responder_block = "No agent has spoken recently."
 
   prompt = INTENT_PROMPT_TEMPLATE
            .gsub("{{AGENT_NAME}}", agent_name)
-           .gsub("{{CHANNEL}}", channel)
            .gsub("{{AGENT_ROSTER}}", roster_block)
-           .gsub("{{CONTEXT}}", context_block)
+           .gsub("{{LAST_RESPONDER}}", last_responder_block)
            .gsub("{{MESSAGE}}", message.strip)
 
   LOG.info "[Intent] Checking intent for #{agent_name} (#{channel}): #{message.strip.slice(0, 80)}..."
   LOG.debug "[Intent] Full prompt:\n#{prompt}" if LOG.debug?
-  response = query_local_llm(prompt, config)
+  response = query_local_llm(prompt, config, system: "Answer yes or no only.")
   result = positive_intent?(response)
   LOG.info "[Intent] Result for #{agent_name}: #{result ? "RESPOND" : "SKIP"} (model: #{config["model"]})"
   result
-rescue OllamaModelNotFoundError => e
-  LOG.error "[Intent] #{e.message}"
-  LOG.error "[Intent] Disabling intent classification until model is installed."
-  BRAINIAC_CONFIG["intent"] ||= {}
-  BRAINIAC_CONFIG["intent"]["enabled"] = false
-  true
-rescue StandardError => e
-  LOG.warn "[Intent] Classification failed (fail-open): #{e.message}"
-  true
 end
 
 # Query the local LLM via Ollama's HTTP API.
 #
 # @param prompt [String] The classification prompt
 # @param config [Hash] Intent configuration
+# @param system [String, nil] Optional system message for output format control
 # @return [String] Raw response text from the model
-def query_local_llm(prompt, config)
-  uri = URI(config["endpoint"])
+def query_local_llm(prompt, config, system: nil)
+  endpoint = config["endpoint"]
+  # Use /api/chat with think:false to disable thinking mode on models like Qwen3.
+  # The /api/generate endpoint always uses thinking tokens, which generates hundreds
+  # of hidden tokens for a simple yes/no answer (2.5s+ vs 0.2s with think:false).
+  chat_uri = URI(endpoint.sub(%r{/api/generate\z}, "/api/chat"))
+
+  messages = []
+  messages << { role: "system", content: system } if system
+  messages << { role: "user", content: prompt }
+
   payload = {
     model: config["model"],
-    prompt: prompt,
+    messages: messages,
     stream: false,
-    options: { temperature: config["temperature"] }
+    think: false,
+    options: { temperature: config["temperature"], num_predict: 5 }
   }
 
-  http = Net::HTTP.new(uri.host, uri.port)
+  http = Net::HTTP.new(chat_uri.host, chat_uri.port)
   http.open_timeout = config["timeout"]
   http.read_timeout = config["timeout"]
 
-  request = Net::HTTP::Post.new(uri.path, "Content-Type" => "application/json")
+  request = Net::HTTP::Post.new(chat_uri.path, "Content-Type" => "application/json")
   request.body = JSON.generate(payload)
 
   response = http.request(request)
@@ -222,9 +249,9 @@ def query_local_llm(prompt, config)
   end
 
   body = JSON.parse(response.body)
-  body["response"] || ""
+  body.dig("message", "content") || ""
 rescue Errno::ECONNREFUSED
-  raise "Ollama not running at #{config["endpoint"]}. Start it with: ollama serve"
+  raise "Ollama not running at #{endpoint}. Start it with: ollama serve"
 rescue Net::OpenTimeout, Net::ReadTimeout
   raise "Ollama timed out after #{config["timeout"]}s"
 end
@@ -360,18 +387,94 @@ def directly_addressed_to?(msg, name)
 end
 
 # Build a compact agent roster string for the intent prompt.
-# Helps the LLM identify which names in the conversation are agents.
+# Returns a comma-separated list of agent display names.
 #
-# @param agent_name [String] The current agent (highlighted)
-# @return [String] Formatted roster for prompt injection
+# @param agent_name [String] The current agent (unused but kept for interface consistency)
+# @return [String] Comma-separated agent names
 def build_intent_agent_roster(agent_name)
-  return "" unless defined?(AGENT_REGISTRY) && !AGENT_REGISTRY.empty?
+  return agent_name unless defined?(AGENT_REGISTRY) && !AGENT_REGISTRY.empty?
 
   names = AGENT_REGISTRY.map do |key, entry|
     entry.is_a?(Hash) ? (entry["display_name"] || key.capitalize) : key.capitalize
   end.uniq
 
-  return "" if names.size <= 1
+  return agent_name if names.empty?
+
+  names.join(", ")
+end
+
+# Detect the last agent to respond in the conversation context.
+# Returns a prompt-friendly string telling the model who was last to respond.
+#
+# The context is formatted as "username: message\n..." lines.
+# We scan backwards to find the most recent line authored by a known agent.
+#
+# @param context [String, nil] Conversation history
+# @param agent_name [String] The current agent being evaluated
+# @return [String] Prompt block describing the last responder
+def detect_last_responder(context, _agent_name = nil)
+  return "No agent has spoken yet." if context.nil? || context.strip.empty?
+  return "No agent has spoken yet." unless defined?(AGENT_REGISTRY) && !AGENT_REGISTRY.empty?
+
+  # Build a lookup of agent display names (lowercase) to their proper display name
+  agent_names = {}
+  AGENT_REGISTRY.each do |key, entry|
+    display = entry.is_a?(Hash) ? (entry["display_name"] || key.capitalize) : key.capitalize
+    agent_names[display.downcase] = display
+  end
+
+  # Scan context lines in reverse to find the last agent message
+  lines = context.strip.lines.reverse
+  lines.each do |line|
+    # Lines are formatted as "username: message content"
+    match = line.match(/\A(\S+?):\s/)
+    next unless match
+
+    username = match[1].downcase
+    next unless agent_names.key?(username)
+
+    responder = agent_names[username]
+    return "#{responder} was the last to speak. The human is continuing the conversation with #{responder}."
+  end
+
+  "No agent has spoken yet."
+end
+
+# Detect the last agent to respond — returns just the display name (or nil).
+# Used for deterministic conversational-flow checks without LLM involvement.
+#
+# @param context [String, nil] Conversation history
+# @return [String, nil] Display name of last agent to speak, or nil
+def detect_last_responder_name(context)
+  return nil if context.nil? || context.strip.empty?
+  return nil unless defined?(AGENT_REGISTRY) && !AGENT_REGISTRY.empty?
+
+  agent_names = {}
+  AGENT_REGISTRY.each do |key, entry|
+    display = entry.is_a?(Hash) ? (entry["display_name"] || key.capitalize) : key.capitalize
+    agent_names[display.downcase] = display
+  end
+
+  context.strip.lines.reverse_each do |line|
+    match = line.match(/\A(\S+?):\s/)
+    next unless match
+
+    username = match[1].downcase
+    return agent_names[username] if agent_names.key?(username)
+  end
+
+  nil
+end
+
+# Check if a message contains a direct reference to a specific agent's name.
+# More permissive than intent_names_other_agent? — catches any occurrence of the name.
+#
+# @param message [String] The message text
+# @param agent_name [String] The agent name to look for
+# @return [Boolean] true if the agent is mentioned by name
+def message_mentions_agent?(message, agent_name)
+  return false if message.nil? || agent_name.nil?
 
-  "Known agents in this system: #{names.join(", ")}. You are routing for #{agent_name}."
+  escaped = Regexp.escape(agent_name)
+  message.match?(/\b#{escaped}\b/i)
 end

data/lib/brainiac/version.rb

@@ -2,5 +2,5 @@
 
 module Brainiac
   # @return [String] the current gem version
-  VERSION = "0.0.19"
+  VERSION = "0.0.20"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brainiac
 version: !ruby/object:Gem::Version
-  version: 0.0.19
+  version: 0.0.20
 platform: ruby
 authors:
 - Andy Davis