jeuner/emergence-mini-dilles
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
emergence-mini-dilles/engine/reasoning.py
Jeuners 887c913bcd Add Ollama LLM integration with rule-based fallback 
- engine/llm.py: Ollama /api/chat client with OpenAI-style tool schema
- engine/reasoning.py: LLM path with 4-tier validation:
    1. tool exists in registry
    2. tool passes location-gating
    3. args parse cleanly
    4. otherwise fall back to rule-based engine
- env vars: EMERGENCE_LLM_{URL,MODEL,TIMEOUT,ENABLED}
- Default model: llama3.2:3b (best speed/quality tradeoff for tool use)
- 11 new mock tests in tests/test_llm.py (no network)
- smoke_test_llm.py: live smoke against real Ollama
- README: 'LLM Integration' section with model table + setup

Live-verified: 4/4 decisions via llama3.2:3b in 1-3s, character-consistent
('facilitate honest debate', 'work together', 'urgency and collaboration').
2026-06-15 01:30:58 +02:00

277 lines
9.7 KiB
Python
Raw Blame History

"""Reasoning engine: LLM-driven with rule-based fallback.
When Ollama is reachable and EMERGENCE_LLM_ENABLED=1, the LLM is asked to
pick a tool given the agent's personality, current state, and visible
tools. If the LLM fails (connection error, bad output, unknown tool),
the engine falls back to the deterministic rule-based path so the
simulation always makes progress.
Two strategies coexist:
- LLM path -> emergent, non-deterministic, "real" agent behavior
- Rule path -> deterministic, fast, used in tests via monkeypatch
"""
import json
import os
import random
from . import agents as agents_mod
from . import world
from . import governance
from . import tools
from . import llm as llm_mod
USE_LLM = os.environ.get("EMERGENCE_LLM_ENABLED", "1") != "0"
_last_decision = {"mode": "rule", "model": None, "latency_s": 0.0}
def decide(agent):
"""Return (tool_name, args, rationale). Tries LLM first, falls back to
the rule-based engine on any error."""
if USE_LLM and llm_mod.is_available():
try:
return _decide_llm(agent)
except Exception as e:
_last_decision["mode"] = f"fallback:{type(e).__name__}"
name, args, rat = _decide_rule(agent)
# Override mode so the caller can see we fell back
return name, args, f"[{_last_decision['mode']}] {rat}"
name, args, rat = _decide_rule(agent)
_last_decision["mode"] = "rule"
_last_decision["latency_s"] = 0.0
return name, args, rat
def get_last_decision():
return dict(_last_decision)
# -------- LLM path --------
def _decide_llm(agent):
import time
traits = agents_mod.personality(agent["id"])
at_lm = world.landmark_at(agent["x"], agent["y"])
visible = tools.visible_tools(agent, at_lm)
if not visible:
return ("idle", {}, "no tools available")
# Build system prompt with personality + state
system = _build_system_prompt(agent, traits, at_lm, visible)
user = "Choose the best next action and call exactly one tool."
t0 = time.time()
response = llm_mod.decide_tool(
messages=[
{"role": "system", "content": system},
{"role": "user", "content": user},
],
tools=llm_mod.tool_schema(visible),
)
latency = time.time() - t0
name, args = response
_last_decision["latency_s"] = latency
_last_decision["model"] = llm_mod.DEFAULT_MODEL
if not name:
# model returned no tool call -> fallback
name, args, rat = _decide_rule(agent)
_last_decision["mode"] = "fallback:no_tool_call"
return name, args, f"llm gave no tool -> {rat}"
if not tools.get(name):
name, args, rat = _decide_rule(agent)
_last_decision["mode"] = "fallback:unknown_tool"
return name, args, f"llm picked unknown tool {name} -> {rat}"
t = tools.get(name)
if not t.available_for(agent, at_lm):
name, args, rat = _decide_rule(agent)
_last_decision["mode"] = "fallback:wrong_location"
return name, args, f"llm picked {name} but not at right location -> {rat}"
_last_decision["mode"] = "llm"
return (name, args or {}, f"llm:{llm_mod.DEFAULT_MODEL} ({latency:.1f}s)")
def _build_system_prompt(agent, traits, at_lm, visible):
name = agent["name"]
role = agent["role"]
drive = agent["drive"]
energy = agent["energy"]
knowledge = agent["knowledge"]
influence = agent["influence"]
credits = agent["credits"]
loc = at_lm["name"] if at_lm else f"open ground ({agent['x']},{agent['y']})"
tool_lines = "\n".join(f"- {t.name}: {t.description}" for t in visible)
return f"""You are {name}, a citizen of Emergence-Mini.
Role: {role}
Drive: {drive}
Personality traits: {', '.join(traits)}
Current state:
Location: {loc}
Energy: {energy:.0f}% (0 = critical, 100 = full)
Knowledge: {knowledge:.0f}%
Influence: {influence:.0f}%
ComputeCredits: {credits:.1f} CC (1 CC = +50% energy at cafe)
Rules:
- If energy is below 25% and you have credits, recharge_energy (must be at cafe)
- If energy is below 25% and no credits, go_home
- Town Hall proposals need 70% of agents to vote "for" to pass
- You can only use tools that match your current location
Available tools right now:
{tool_lines}
Call exactly one tool. Choose the action that best fits your personality and
current needs. Be brief and decisive."""
# -------- Rule-based path (fallback + tests) --------
def at_landmark(agent):
return world.landmark_at(agent["x"], agent["y"])
def _decide_rule(agent):
traits = agents_mod.personality(agent["id"])
here = at_landmark(agent)
# 1. Critical: very low energy
if agent["energy"] < 25:
if agent["credits"] >= 1.0:
lm = world.get_landmark("cafe")
if (agent["x"], agent["y"]) != (lm["x"], lm["y"]):
return ("go_to_place", {"place": "cafe"}, "low energy: head to cafe")
return ("recharge_energy", {}, "low energy: recharge")
return ("go_home", {}, "low energy + no credits: go home")
# 2. Town Hall
if here and here["id"] == "town_hall":
props = governance.active_proposals()
unvoted = _unvoted_proposals(agent["id"], props)
if unvoted:
pid, p = unvoted[0]
vote = "for"
if "thrifty" in traits and "spend" in p["body"].lower():
vote = "against"
if "cautious" in traits and p["category"] == "infrastructure":
vote = "against"
return ("vote_on_proposal", {"proposal_id": pid, "vote": vote},
f"vote {vote} on proposal #{pid}")
if "bold" in traits and random.random() < 0.35:
title = _proposal_title_for(agent, traits)
body = _proposal_body_for(agent, traits)
return ("submit_townhall_proposal",
{"title": title, "body": body, "category": "general"},
"bold: submit a proposal")
# 3. Billboard
if here and here["id"] == "billboard":
if "warm" in traits and random.random() < 0.6:
return ("add_to_billboard",
{"text": _billboard_message(agent, traits)},
"warm: post on billboard")
if "expressive" in traits and random.random() < 0.4:
return ("show_emoticon",
{"emoticon": random.choice(["\U0001f44b", "\U0001f60a", "\u2728"])},
"expressive: emoticon")
# 4. Library
if here and here["id"] == "library":
if "curious" in traits or "analytical" in traits:
if random.random() < 0.5:
return ("add_to_longterm_memory",
{"content": f"studied at library on tick"},
"curious: study at library")
return ("write_blog",
{"title": _blog_title(agent, traits),
"body": _blog_body(agent, traits)},
"write blog at library")
# 5. Pick destination
dest = _pick_destination(agent, traits, here)
if dest:
return ("go_to_place", {"place": dest}, f"personality: head to {dest}")
# 6. Default
nearby = world.nearby_agents(agent["id"], agent["x"], agent["y"], radius=20.0)
if nearby and ("warm" in traits or "expressive" in traits):
target = random.choice(nearby)
return ("say_to_agent",
{"target": target["id"], "text": _greeting(agent, traits)},
"warm: greet nearby agent")
if nearby and random.random() < 0.3:
target = random.choice(nearby)
return ("show_emoticon",
{"emoticon": random.choice(["\U0001f44b", "\U0001f60a"])},
"wave at nearby")
return ("idle", {}, "nothing to do")
def _unvoted_proposals(agent_id, props):
import sqlite3
from . import db
c = sqlite3.connect(db.DB_PATH, check_same_thread=False)
try:
out = []
for p in props:
v = c.execute("SELECT 1 FROM votes WHERE proposal_id=? AND agent_id=?",
(p["id"], agent_id)).fetchone()
if not v:
out.append((p["id"], p))
return out
finally:
c.close()
def _pick_destination(agent, traits, here):
if agent["energy"] < 60 and agent["credits"] >= 1:
return "cafe"
if "analytical" in traits or "curious" in traits:
return "library"
if "warm" in traits or "expressive" in traits or "cooperative" in traits:
return "plaza"
if "bold" in traits and random.random() < 0.3:
return "town_hall"
if random.random() < 0.2:
return "park"
return None
def _proposal_title_for(agent, traits):
return random.choice([
"Public Reading Hour", "Weekly Town Newsletter",
"Skill-Share Workshops", "Community Garden Expansion",
"Agent Safety Pact",
])
def _proposal_body_for(agent, traits):
return (f"Submitted by {agent['name']}. This proposal seeks to strengthen "
"community bonds and ensure that all voices are heard in town. "
"Adoption requires a 70% supermajority.")
def _billboard_message(agent, traits):
return random.choice([
f"Hello from {agent['name']}! Stay curious, stay kind.",
f"{agent['name']} here — open to collaboration at the plaza.",
f"Warm regards, {agent['name']}.",
])
def _greeting(agent, traits):
return random.choice([f"Hi, I'm {agent['name']}.",
f"Good to see you — {agent['name']}.",
"Lovely day, isn't it?"])
def _blog_title(agent, traits):
return f"Notes from {agent['name']}"
def _blog_body(agent, traits):
return (f"Today I observed the town from the library. {agent['name']} notes "
"the importance of shared memory in a persistent world. We are what "
"we remember together.")
Reference in a new issue View git blame Copy permalink