LZH-YS1998
862 lines
35 KiB
Python
862 lines
35 KiB
Python
"""Agent Store — dynamic character registry with flexible office assignment.
|
|
|
|
Each agent is an individual character/person with appearance, office assignment,
|
|
and a backing OPC role for execution. Persisted in SQLite.
|
|
|
|
Tables:
|
|
agents — active agent registry (cleared & rebuilt on preset switch)
|
|
agent_appearances — visual identity cache (survives mode switches)
|
|
server_state — persists exec_mode/company_profile across restarts
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import time
|
|
from typing import Any
|
|
|
|
import aiosqlite
|
|
|
|
|
|
# Default office assignment for preset models
|
|
_CLASSIC_LAYOUT: list[dict[str, Any]] = [
|
|
{"role_id": "coordinator", "office_id": "office-0", "palette": 0, "seat_zone": "leaderOffice"},
|
|
{"role_id": "executor", "office_id": "office-1", "palette": 1, "seat_zone": "workspace"},
|
|
{"role_id": "reviewer", "office_id": "office-2", "palette": 2, "seat_zone": "workspace"},
|
|
]
|
|
|
|
|
|
class AgentStore:
|
|
"""Dynamic character registry with flexible office assignment.
|
|
|
|
SQLite table: agents
|
|
agent_id TEXT PK, name TEXT, description TEXT, opc_role_id TEXT,
|
|
office_id TEXT, palette INT, hue_shift INT, seat_zone TEXT,
|
|
specialties TEXT (JSON), status TEXT, created_at REAL
|
|
"""
|
|
|
|
def __init__(self, db: aiosqlite.Connection) -> None:
|
|
self._db = db
|
|
self._local_talent_cache: list[Any] | None = None
|
|
|
|
async def initialize(self) -> None:
|
|
"""Create tables if not exists."""
|
|
await self._db.execute("""
|
|
CREATE TABLE IF NOT EXISTS agents (
|
|
agent_id TEXT PRIMARY KEY,
|
|
name TEXT NOT NULL,
|
|
description TEXT DEFAULT '',
|
|
opc_role_id TEXT NOT NULL,
|
|
office_id TEXT DEFAULT 'office-0',
|
|
palette INTEGER DEFAULT 0,
|
|
hue_shift INTEGER DEFAULT 0,
|
|
seat_zone TEXT DEFAULT 'workspace',
|
|
desk_id TEXT DEFAULT NULL,
|
|
specialties TEXT DEFAULT '[]',
|
|
status TEXT DEFAULT 'idle',
|
|
created_at REAL NOT NULL
|
|
)
|
|
""")
|
|
# Appearance memory: persists visual identity across mode switches
|
|
await self._db.execute("""
|
|
CREATE TABLE IF NOT EXISTS agent_appearances (
|
|
role_id TEXT PRIMARY KEY,
|
|
palette INTEGER DEFAULT 0,
|
|
hue_shift INTEGER DEFAULT 0,
|
|
seat_zone TEXT DEFAULT 'workspace',
|
|
office_id TEXT DEFAULT 'office-0',
|
|
desk_id TEXT DEFAULT NULL
|
|
)
|
|
""")
|
|
# Persistent server state (exec_mode, company_profile)
|
|
await self._db.execute("""
|
|
CREATE TABLE IF NOT EXISTS server_state (
|
|
key TEXT PRIMARY KEY,
|
|
value TEXT NOT NULL
|
|
)
|
|
""")
|
|
# Migration: add desk_id column if missing (existing DBs)
|
|
try:
|
|
await self._db.execute("SELECT desk_id FROM agents LIMIT 1")
|
|
except Exception:
|
|
await self._db.execute("ALTER TABLE agents ADD COLUMN desk_id TEXT DEFAULT NULL")
|
|
# Migration: add employee_id column if missing (existing DBs)
|
|
try:
|
|
await self._db.execute("SELECT employee_id FROM agents LIMIT 1")
|
|
except Exception:
|
|
await self._db.execute("ALTER TABLE agents ADD COLUMN employee_id TEXT DEFAULT NULL")
|
|
# Shadow copy of custom-mode agents: survives non-custom preset switches.
|
|
# Written on every custom-mode agent mutation; read when re-entering custom.
|
|
await self._db.execute("""
|
|
CREATE TABLE IF NOT EXISTS custom_agents_shadow (
|
|
agent_id TEXT PRIMARY KEY,
|
|
name TEXT NOT NULL,
|
|
description TEXT DEFAULT '',
|
|
opc_role_id TEXT NOT NULL,
|
|
office_id TEXT DEFAULT 'office-0',
|
|
palette INTEGER DEFAULT 0,
|
|
hue_shift INTEGER DEFAULT 0,
|
|
seat_zone TEXT DEFAULT 'workspace',
|
|
desk_id TEXT DEFAULT NULL,
|
|
employee_id TEXT DEFAULT NULL,
|
|
specialties TEXT DEFAULT '[]',
|
|
created_at REAL NOT NULL
|
|
)
|
|
""")
|
|
# Migration: drop legacy table from earlier iteration
|
|
await self._db.execute("DROP TABLE IF EXISTS custom_agents_backup")
|
|
await self._db.commit()
|
|
|
|
# ── Server state persistence ──────────────────────────────────────
|
|
|
|
async def get_server_state(self, key: str, default: str = "") -> str:
|
|
"""Read a persisted server state value."""
|
|
cursor = await self._db.execute(
|
|
"SELECT value FROM server_state WHERE key = ?", (key,)
|
|
)
|
|
row = await cursor.fetchone()
|
|
return row[0] if row else default
|
|
|
|
async def set_server_state(self, key: str, value: str) -> None:
|
|
"""Write a persisted server state value."""
|
|
await self._db.execute(
|
|
"INSERT OR REPLACE INTO server_state (key, value) VALUES (?, ?)",
|
|
(key, value),
|
|
)
|
|
await self._db.commit()
|
|
|
|
# ── Appearance persistence ────────────────────────────────────────
|
|
|
|
async def _save_appearances(self) -> None:
|
|
"""Persist current agents' visual identity to agent_appearances table."""
|
|
cursor = await self._db.execute(
|
|
"SELECT agent_id, palette, hue_shift, seat_zone, office_id, desk_id FROM agents"
|
|
)
|
|
rows = await cursor.fetchall()
|
|
for agent_id, palette, hue_shift, seat_zone, office_id, desk_id in rows:
|
|
await self._db.execute(
|
|
"INSERT OR REPLACE INTO agent_appearances "
|
|
"(role_id, palette, hue_shift, seat_zone, office_id, desk_id) "
|
|
"VALUES (?, ?, ?, ?, ?, ?)",
|
|
(agent_id, palette, hue_shift, seat_zone, office_id, desk_id),
|
|
)
|
|
await self._db.commit()
|
|
|
|
async def _restore_appearance(self, agent_id: str) -> dict[str, Any] | None:
|
|
"""Look up saved appearance for a role_id. Returns dict or None."""
|
|
cursor = await self._db.execute(
|
|
"SELECT palette, hue_shift, seat_zone, office_id, desk_id "
|
|
"FROM agent_appearances WHERE role_id = ?",
|
|
(agent_id,),
|
|
)
|
|
row = await cursor.fetchone()
|
|
if not row:
|
|
return None
|
|
return {
|
|
"palette": row[0],
|
|
"hue_shift": row[1],
|
|
"seat_zone": row[2],
|
|
"office_id": row[3],
|
|
"desk_id": row[4],
|
|
}
|
|
|
|
# ── Custom-mode shadow copy ──────────────────────────────────────
|
|
|
|
async def sync_custom_shadow(self) -> None:
|
|
"""Mirror the current agents table into custom_agents_shadow.
|
|
|
|
Call this after any mutation to agents while in custom mode so the
|
|
shadow is always up-to-date — even if the server crashes before a
|
|
clean mode switch.
|
|
"""
|
|
cursor = await self._db.execute(
|
|
"SELECT agent_id, name, description, opc_role_id, office_id, "
|
|
"palette, hue_shift, seat_zone, desk_id, employee_id, specialties, created_at "
|
|
"FROM agents"
|
|
)
|
|
rows = await cursor.fetchall()
|
|
await self._db.execute("DELETE FROM custom_agents_shadow")
|
|
for row in rows:
|
|
await self._db.execute(
|
|
"INSERT INTO custom_agents_shadow "
|
|
"(agent_id, name, description, opc_role_id, office_id, "
|
|
"palette, hue_shift, seat_zone, desk_id, employee_id, specialties, created_at) "
|
|
"VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
|
|
row,
|
|
)
|
|
await self._db.commit()
|
|
|
|
async def _restore_custom_shadow(self) -> list[dict[str, Any]]:
|
|
"""Restore agents from the shadow table. Returns agents or []."""
|
|
cursor = await self._db.execute(
|
|
"SELECT agent_id, name, description, opc_role_id, office_id, "
|
|
"palette, hue_shift, seat_zone, desk_id, employee_id, specialties, created_at "
|
|
"FROM custom_agents_shadow"
|
|
)
|
|
rows = await cursor.fetchall()
|
|
if not rows:
|
|
return []
|
|
await self._db.execute("DELETE FROM agents")
|
|
for row in rows:
|
|
await self._db.execute(
|
|
"INSERT OR REPLACE INTO agents "
|
|
"(agent_id, name, description, opc_role_id, office_id, "
|
|
"palette, hue_shift, seat_zone, desk_id, employee_id, specialties, status, created_at) "
|
|
"VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'idle', ?)",
|
|
row,
|
|
)
|
|
await self._db.commit()
|
|
return await self.get_all()
|
|
|
|
# ── Preset loading ────────────────────────────────────────────────
|
|
|
|
async def load_preset(self, model_name: str, org_engine: Any) -> list[dict[str, Any]]:
|
|
"""Load agents from a preset runtime model.
|
|
|
|
Returns list of agent dicts in UI AgentInfo format.
|
|
Supported presets: corporate, single, custom.
|
|
|
|
Custom mode: restore the saved custom team when available. If there
|
|
is no saved custom team yet, clear whatever preset agents are active
|
|
and start from a single custom leader.
|
|
Non-custom: save appearances, clear, rebuild from preset definition.
|
|
"""
|
|
if model_name == "custom":
|
|
# Shadow is authoritative when it exists because the agents
|
|
# table may contain leftover preset agents from a non-custom mode.
|
|
restored = await self._restore_custom_shadow()
|
|
if restored:
|
|
return restored
|
|
# No saved custom team yet — never inherit preset agents.
|
|
await self._save_appearances()
|
|
await self._db.execute("DELETE FROM agents")
|
|
await self._db.commit()
|
|
starter = await self._load_custom_starter(org_engine)
|
|
reconciled = await self.ensure_custom_role_agents(org_engine)
|
|
if reconciled:
|
|
return reconciled
|
|
await self.sync_custom_shadow()
|
|
return starter
|
|
|
|
# Non-custom preset: save appearances, clear, rebuild.
|
|
await self._save_appearances()
|
|
await self._db.execute("DELETE FROM agents")
|
|
|
|
# Single mode: only the executor
|
|
if model_name == "single":
|
|
return await self._load_single_agent(org_engine)
|
|
|
|
if model_name == "corporate":
|
|
try:
|
|
from opc.layer2_organization.company_runtime_profiles import get_builtin_roles
|
|
config = getattr(org_engine, "config", None)
|
|
org = getattr(config, "org", None)
|
|
configured_roles = getattr(org, "roles", None)
|
|
role_configs = get_builtin_roles(model_name, configured_roles=configured_roles)
|
|
roles = [
|
|
{"id": r.id, "name": r.name, "responsibility": r.responsibility or "",
|
|
"tools": list(r.tools) if r.tools else [],
|
|
"can_spawn": list(r.can_spawn) if r.can_spawn else [],
|
|
"reports_to": r.reports_to or ""}
|
|
for r in role_configs
|
|
]
|
|
except ImportError:
|
|
roles = []
|
|
else:
|
|
roles = []
|
|
|
|
if not roles:
|
|
# Use current org_engine roles as fallback
|
|
roles_info = org_engine.list_agents() if hasattr(org_engine, "list_agents") else []
|
|
if not roles_info:
|
|
# Fallback to hardcoded 3-agent layout
|
|
return await self._load_classic_fallback(org_engine)
|
|
return await self._load_from_role_infos(roles_info, model_name)
|
|
|
|
return await self._load_from_role_dicts(roles, model_name)
|
|
|
|
async def _load_single_agent(self, org_engine: Any) -> list[dict[str, Any]]:
|
|
"""Single-agent mode: only one executor in office-0."""
|
|
role = None
|
|
if hasattr(org_engine, "get_agent"):
|
|
role = org_engine.get_agent("executor")
|
|
name = role.name if role else "Executor"
|
|
description = role.responsibility if role else ""
|
|
specialties = list(role.tools) if role and role.tools else []
|
|
agent = await self._insert_agent(
|
|
agent_id="executor",
|
|
name=name,
|
|
description=description,
|
|
opc_role_id="executor",
|
|
office_id="office-0",
|
|
palette=1,
|
|
seat_zone="leaderOffice",
|
|
specialties=specialties,
|
|
)
|
|
return [agent]
|
|
|
|
async def _load_custom_starter(self, org_engine: Any) -> list[dict[str, Any]]:
|
|
"""Custom mode first-time bootstrap: 1 agent in leader desk."""
|
|
role = None
|
|
if hasattr(org_engine, "get_agent"):
|
|
role = org_engine.get_agent("coordinator")
|
|
if not role:
|
|
role = org_engine.get_agent("executor")
|
|
name = role.name if role else "My Agent"
|
|
description = role.responsibility if role else "Custom agent"
|
|
specialties = list(role.tools) if role and role.tools else []
|
|
agent = await self._insert_agent(
|
|
agent_id="custom-leader",
|
|
name=name,
|
|
description=description,
|
|
opc_role_id="coordinator",
|
|
office_id="office-0",
|
|
palette=0,
|
|
seat_zone="leaderOffice",
|
|
specialties=specialties,
|
|
restore_appearance=False,
|
|
)
|
|
return [agent]
|
|
|
|
async def ensure_custom_role_agents(self, org_engine: Any) -> list[dict[str, Any]]:
|
|
"""Make custom-mode visual agents match the active org roles."""
|
|
if not org_engine or not hasattr(org_engine, "list_agents"):
|
|
return await self.get_all()
|
|
|
|
roles = list(org_engine.list_agents() or [])
|
|
if not roles:
|
|
return await self.get_all()
|
|
|
|
role_ids = [self._role_id(role) for role in roles]
|
|
role_ids = [role_id for role_id in role_ids if role_id]
|
|
desired_role_ids = set(role_ids)
|
|
if not desired_role_ids:
|
|
return await self.get_all()
|
|
|
|
selected_by_role: dict[str, Any] = {}
|
|
for role_id in role_ids:
|
|
employees = []
|
|
if hasattr(org_engine, "list_employees"):
|
|
employees = list(org_engine.list_employees(role_id=role_id) or [])
|
|
if not employees and hasattr(org_engine, "ensure_default_employee_for_role"):
|
|
default_employee = org_engine.ensure_default_employee_for_role(role_id, persist=False)
|
|
if default_employee is not None:
|
|
employees = [default_employee]
|
|
if employees:
|
|
selected_by_role[role_id] = self._select_role_employee(employees)
|
|
|
|
desired_employee_ids = {
|
|
getattr(employee, "employee_id", "")
|
|
for employee in selected_by_role.values()
|
|
if getattr(employee, "employee_id", "")
|
|
}
|
|
|
|
existing_agents = await self.get_all()
|
|
for agent in existing_agents:
|
|
role_id = str(agent.get("opc_role_id") or agent.get("agent_id") or "")
|
|
employee_id = str(agent.get("employee_id") or "")
|
|
if role_id not in desired_role_ids:
|
|
await self.remove_agent(str(agent.get("agent_id") or ""))
|
|
continue
|
|
selected = selected_by_role.get(role_id)
|
|
selected_employee_id = str(getattr(selected, "employee_id", "") or "")
|
|
if selected_employee_id and employee_id and employee_id != selected_employee_id:
|
|
await self.remove_agent(str(agent.get("agent_id") or ""))
|
|
elif selected_employee_id and not employee_id:
|
|
await self.remove_agent(str(agent.get("agent_id") or ""))
|
|
|
|
offices = ["office-0", "office-1", "office-2"]
|
|
worker_idx = 0
|
|
for index, role in enumerate(roles):
|
|
role_id = self._role_id(role)
|
|
employee = selected_by_role.get(role_id)
|
|
employee_id = str(getattr(employee, "employee_id", "") or "")
|
|
if not employee_id:
|
|
continue
|
|
if await self._find_by_employee_id(employee_id):
|
|
continue
|
|
is_leader = self._is_leader_role(role, index)
|
|
office_id = "office-0" if is_leader else offices[1 + (worker_idx % 2)]
|
|
seat_zone = "leaderOffice" if is_leader else "workspace"
|
|
if not is_leader:
|
|
worker_idx += 1
|
|
await self.create_agent_from_employee(
|
|
self._employee_to_dict(employee),
|
|
office_id=office_id,
|
|
seat_zone=seat_zone,
|
|
)
|
|
|
|
for agent in await self.get_all():
|
|
employee_id = str(agent.get("employee_id") or "")
|
|
if employee_id and employee_id not in desired_employee_ids:
|
|
await self.remove_agent(str(agent.get("agent_id") or ""))
|
|
|
|
await self.sync_custom_shadow()
|
|
return await self.get_all()
|
|
|
|
@staticmethod
|
|
def _role_id(role: Any) -> str:
|
|
return str(getattr(role, "role_id", "") or getattr(role, "id", "") or "").strip()
|
|
|
|
@staticmethod
|
|
def _is_leader_role(role: Any, index: int) -> bool:
|
|
can_spawn = getattr(role, "can_spawn", None) or []
|
|
reports_to = getattr(role, "reports_to", None) or ""
|
|
return index == 0 or (bool(can_spawn) and reports_to in ("", "owner"))
|
|
|
|
@staticmethod
|
|
def _select_role_employee(employees: list[Any]) -> Any:
|
|
for employee in employees:
|
|
metadata = dict(getattr(employee, "metadata", {}) or {})
|
|
if not metadata.get("is_default_employee"):
|
|
return employee
|
|
return employees[0]
|
|
|
|
@staticmethod
|
|
def _employee_to_dict(employee: Any) -> dict[str, Any]:
|
|
return {
|
|
"employee_id": getattr(employee, "employee_id", ""),
|
|
"name": getattr(employee, "name", ""),
|
|
"role_id": getattr(employee, "role_id", ""),
|
|
"category": getattr(employee, "category", ""),
|
|
"domains": list(getattr(employee, "domains", []) or []),
|
|
"tags": list(getattr(employee, "tags", []) or []),
|
|
}
|
|
|
|
async def _load_classic_fallback(self, org_engine: Any) -> list[dict[str, Any]]:
|
|
"""Fallback: create classic agents from hardcoded layout."""
|
|
agents = []
|
|
for layout in _CLASSIC_LAYOUT:
|
|
role_id = layout["role_id"]
|
|
# Try to get role info from org_engine
|
|
role = None
|
|
if hasattr(org_engine, "get_agent"):
|
|
role = org_engine.get_agent(role_id)
|
|
|
|
name = role.name if role else role_id.capitalize()
|
|
description = role.responsibility if role else ""
|
|
specialties = list(role.tools) if role and role.tools else []
|
|
|
|
agent = await self._insert_agent(
|
|
agent_id=role_id,
|
|
name=name,
|
|
description=description,
|
|
opc_role_id=role_id,
|
|
office_id=layout["office_id"],
|
|
palette=layout["palette"],
|
|
seat_zone=layout["seat_zone"],
|
|
specialties=specialties,
|
|
)
|
|
agents.append(agent)
|
|
return agents
|
|
|
|
async def _load_from_role_infos(self, roles: list[Any], model_name: str) -> list[dict[str, Any]]:
|
|
"""Load from OPC AgentInfo objects.
|
|
|
|
Groups agents into offices: leaders in office-0, workers spread across office-1/2.
|
|
"""
|
|
agents = []
|
|
offices = ["office-0", "office-1", "office-2"]
|
|
worker_idx = 0
|
|
|
|
for i, role in enumerate(roles):
|
|
role_id = role.role_id if hasattr(role, "role_id") else str(role)
|
|
name = role.name if hasattr(role, "name") else role_id
|
|
description = role.responsibility if hasattr(role, "responsibility") else ""
|
|
specialties = list(role.tools) if hasattr(role, "tools") and role.tools else []
|
|
|
|
# Leaders go to office-0: first agent, or agents that report to
|
|
# "owner"/nobody (top of hierarchy)
|
|
can_spawn = getattr(role, "can_spawn", None) or []
|
|
reports_to = getattr(role, "reports_to", None) or ""
|
|
is_leader = i == 0 or (bool(can_spawn) and reports_to in ("", "owner"))
|
|
|
|
if is_leader:
|
|
office_id = "office-0"
|
|
seat_zone = "leaderOffice"
|
|
else:
|
|
# Workers spread across office-1 and office-2
|
|
office_id = offices[1 + (worker_idx % 2)]
|
|
seat_zone = "workspace"
|
|
worker_idx += 1
|
|
|
|
agent = await self._insert_agent(
|
|
agent_id=role_id,
|
|
name=name,
|
|
description=description,
|
|
opc_role_id=role_id,
|
|
office_id=office_id,
|
|
palette=i % 6,
|
|
seat_zone=seat_zone,
|
|
specialties=specialties,
|
|
)
|
|
agents.append(agent)
|
|
return agents
|
|
|
|
# Office layout maps for preset profiles
|
|
_OFFICE_MAPS: dict[str, dict[str, str]] = {
|
|
"corporate": {
|
|
"ceo": "office-0",
|
|
"cto": "office-1", "senior_engineer": "office-1", "devops_engineer": "office-1",
|
|
"cmo": "office-2", "coo": "office-2",
|
|
"content_specialist": "office-2", "designer": "office-2", "qa_analyst": "office-2",
|
|
},
|
|
}
|
|
_LEADER_SETS: dict[str, set[str]] = {
|
|
"corporate": {"ceo"},
|
|
}
|
|
|
|
async def _load_from_role_dicts(self, roles: list[dict[str, Any]], model_name: str) -> list[dict[str, Any]]:
|
|
"""Load from role config dicts.
|
|
|
|
Groups agents into offices using profile-specific layout maps:
|
|
corporate: office-0 CEO, office-1 Engineering, office-2 Business/Ops
|
|
"""
|
|
office_map = self._OFFICE_MAPS.get(model_name, {})
|
|
leaders = self._LEADER_SETS.get(model_name, set())
|
|
offices = ["office-0", "office-1", "office-2"]
|
|
|
|
agents = []
|
|
for i, role_dict in enumerate(roles):
|
|
role_id = role_dict.get("id", f"role-{i}")
|
|
name = role_dict.get("name", role_id)
|
|
description = role_dict.get("responsibility", "")
|
|
specialties = role_dict.get("tools", [])
|
|
|
|
office_id = office_map.get(role_id, offices[i % len(offices)])
|
|
seat_zone = "leaderOffice" if role_id in leaders else "workspace"
|
|
|
|
agent = await self._insert_agent(
|
|
agent_id=role_id,
|
|
name=name,
|
|
description=description,
|
|
opc_role_id=role_id,
|
|
office_id=office_id,
|
|
palette=i % 6,
|
|
seat_zone=seat_zone,
|
|
specialties=specialties,
|
|
)
|
|
agents.append(agent)
|
|
return agents
|
|
|
|
async def _insert_agent(
|
|
self,
|
|
agent_id: str,
|
|
name: str,
|
|
description: str,
|
|
opc_role_id: str,
|
|
office_id: str,
|
|
palette: int,
|
|
seat_zone: str,
|
|
specialties: list[str] | None = None,
|
|
hue_shift: int = 0,
|
|
desk_id: str | None = None,
|
|
employee_id: str | None = None,
|
|
restore_appearance: bool = True,
|
|
) -> dict[str, Any]:
|
|
"""Insert a single agent and return its UI AgentInfo dict.
|
|
|
|
If restore_appearance is True, checks agent_appearances table for
|
|
previously saved visual identity and uses it instead of defaults.
|
|
"""
|
|
# Restore saved appearance if available
|
|
if restore_appearance:
|
|
saved = await self._restore_appearance(agent_id)
|
|
if saved:
|
|
palette = saved["palette"]
|
|
hue_shift = saved["hue_shift"]
|
|
seat_zone = saved["seat_zone"]
|
|
office_id = saved["office_id"]
|
|
desk_id = saved["desk_id"]
|
|
|
|
now = time.time()
|
|
specs_json = json.dumps(specialties or [])
|
|
await self._db.execute(
|
|
"INSERT OR REPLACE INTO agents "
|
|
"(agent_id, name, description, opc_role_id, office_id, palette, hue_shift, seat_zone, desk_id, employee_id, specialties, status, created_at) "
|
|
"VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'idle', ?)",
|
|
(agent_id, name, description, opc_role_id, office_id, palette, hue_shift, seat_zone, desk_id, employee_id, specs_json, now),
|
|
)
|
|
await self._db.commit()
|
|
return self._to_ui_format(
|
|
agent_id, name, description, specialties or [], "idle", palette, hue_shift, seat_zone, office_id, desk_id, employee_id, opc_role_id
|
|
)
|
|
|
|
async def create_agent(
|
|
self,
|
|
name: str,
|
|
opc_role_id: str,
|
|
office_id: str,
|
|
org_engine: Any = None,
|
|
description: str = "",
|
|
specialties: list[str] | None = None,
|
|
tools: list[str] | None = None,
|
|
palette: int | None = None,
|
|
seat_zone: str = "workspace",
|
|
employee_id: str | None = None,
|
|
) -> dict[str, Any]:
|
|
"""User creates a new character in the UI.
|
|
|
|
Accepts optional custom fields. Falls back to org_engine role info
|
|
for anything not explicitly provided.
|
|
"""
|
|
# Merge with org_engine role info (use provided values first)
|
|
if org_engine and hasattr(org_engine, "get_agent"):
|
|
role = org_engine.get_agent(opc_role_id)
|
|
if role:
|
|
if not description:
|
|
description = role.responsibility or ""
|
|
if not specialties and not tools:
|
|
specialties = list(role.tools) if role.tools else []
|
|
|
|
# Merge tools into specialties for display
|
|
final_specialties = list(specialties or [])
|
|
if tools:
|
|
for t in tools:
|
|
if t not in final_specialties:
|
|
final_specialties.append(t)
|
|
|
|
# Auto-assign palette if not specified
|
|
if palette is None:
|
|
count = await self._count()
|
|
palette = count % 6
|
|
|
|
# Generate unique agent_id
|
|
agent_id = f"{opc_role_id}-{name.lower().replace(' ', '-')}"
|
|
# Ensure uniqueness
|
|
existing = await self._get_one(agent_id)
|
|
if existing:
|
|
agent_id = f"{agent_id}-{int(time.time()) % 10000}"
|
|
|
|
return await self._insert_agent(
|
|
agent_id=agent_id,
|
|
name=name,
|
|
description=description,
|
|
opc_role_id=opc_role_id,
|
|
office_id=office_id,
|
|
palette=palette,
|
|
seat_zone=seat_zone,
|
|
specialties=final_specialties,
|
|
employee_id=employee_id,
|
|
restore_appearance=False, # User-created agents: use explicit values
|
|
)
|
|
|
|
async def remove_agent(self, agent_id: str) -> dict[str, Any] | None:
|
|
"""Remove a character. Returns the agent dict for broadcasting."""
|
|
agent = await self._get_one(agent_id)
|
|
if not agent:
|
|
return None
|
|
await self._db.execute("DELETE FROM agents WHERE agent_id = ?", (agent_id,))
|
|
await self._db.commit()
|
|
return agent
|
|
|
|
async def move_agent(self, agent_id: str, office_id: str, seat_zone: str | None = None, desk_id: str | None = None) -> dict[str, Any] | None:
|
|
"""Move character to different office/desk. Purely visual."""
|
|
fields = ["office_id = ?"]
|
|
params: list[Any] = [office_id]
|
|
if seat_zone:
|
|
fields.append("seat_zone = ?")
|
|
params.append(seat_zone)
|
|
if desk_id is not None:
|
|
fields.append("desk_id = ?")
|
|
params.append(desk_id)
|
|
params.append(agent_id)
|
|
await self._db.execute(
|
|
f"UPDATE agents SET {', '.join(fields)} WHERE agent_id = ?",
|
|
tuple(params),
|
|
)
|
|
await self._db.commit()
|
|
return await self._get_one(agent_id)
|
|
|
|
async def update_status(self, agent_id: str, status: str) -> None:
|
|
"""Update character status from OPC events."""
|
|
if not agent_id:
|
|
return
|
|
await self._db.execute(
|
|
"UPDATE agents SET status = ? WHERE agent_id = ?",
|
|
(status, agent_id),
|
|
)
|
|
await self._db.commit()
|
|
|
|
async def get_all(self) -> list[dict[str, Any]]:
|
|
"""Return all agents in the EXACT format UI AgentInfo expects."""
|
|
cursor = await self._db.execute(
|
|
"SELECT agent_id, name, description, specialties, status, "
|
|
"palette, hue_shift, seat_zone, office_id, desk_id, employee_id, opc_role_id FROM agents ORDER BY created_at"
|
|
)
|
|
rows = await cursor.fetchall()
|
|
agents = []
|
|
for row in rows:
|
|
agent_id, name, description, specs_json, status, palette, hue_shift, seat_zone, office_id, desk_id, employee_id, opc_role_id = row
|
|
specialties = json.loads(specs_json) if specs_json else []
|
|
agents.append(self._to_ui_format(
|
|
agent_id, name, description, specialties, status, palette, hue_shift, seat_zone, office_id, desk_id, employee_id, opc_role_id
|
|
))
|
|
return agents
|
|
|
|
async def get_templates(self, org_engine: Any = None) -> list[dict[str, Any]]:
|
|
"""Generate agent templates for UI create-agent dialog.
|
|
|
|
Reads from OPC org_engine to get available roles.
|
|
"""
|
|
if not org_engine or not hasattr(org_engine, "list_agents"):
|
|
return []
|
|
|
|
templates = []
|
|
icon_map = {
|
|
"coordinator": "compass",
|
|
"executor": "hammer",
|
|
"reviewer": "magnifying-glass",
|
|
}
|
|
roles = org_engine.list_agents()
|
|
for role in roles:
|
|
role_id = role.role_id if hasattr(role, "role_id") else str(role)
|
|
name = role.name if hasattr(role, "name") else role_id
|
|
desc = role.responsibility if hasattr(role, "responsibility") else ""
|
|
tools = list(role.tools) if hasattr(role, "tools") and role.tools else []
|
|
templates.append({
|
|
"id": role_id,
|
|
"label": name,
|
|
"icon": icon_map.get(role_id, "person"),
|
|
"desc": desc[:60],
|
|
"tools": tools,
|
|
})
|
|
return templates
|
|
|
|
# ── Employee → Agent bridge ──────────────────────────────────────────
|
|
|
|
async def create_agent_from_employee(
|
|
self, employee: dict[str, Any], office_id: str = "office-0", seat_zone: str = "workspace",
|
|
) -> dict[str, Any]:
|
|
"""Create a visual agent linked to an org employee (idempotent)."""
|
|
emp_id = employee.get("employee_id", "")
|
|
existing = await self._find_by_employee_id(emp_id)
|
|
if existing:
|
|
return existing
|
|
|
|
agent_id = f"emp-{emp_id}"
|
|
name = employee.get("name", emp_id)
|
|
description = employee.get("category", "")
|
|
opc_role_id = employee.get("role_id", "executor")
|
|
domains = list(employee.get("domains", []))
|
|
tags = list(employee.get("tags", []))
|
|
specialties = domains + [t for t in tags if t not in domains]
|
|
|
|
count = await self._count()
|
|
palette = count % 6
|
|
|
|
return await self._insert_agent(
|
|
agent_id=agent_id,
|
|
name=name,
|
|
description=description,
|
|
opc_role_id=opc_role_id,
|
|
office_id=office_id,
|
|
palette=palette,
|
|
seat_zone=seat_zone,
|
|
specialties=specialties,
|
|
employee_id=emp_id,
|
|
restore_appearance=False,
|
|
)
|
|
|
|
async def _find_by_employee_id(self, employee_id: str) -> dict[str, Any] | None:
|
|
"""Find an agent linked to a given employee_id."""
|
|
cursor = await self._db.execute(
|
|
"SELECT agent_id, name, description, specialties, status, "
|
|
"palette, hue_shift, seat_zone, office_id, desk_id, employee_id, opc_role_id "
|
|
"FROM agents WHERE employee_id = ?",
|
|
(employee_id,),
|
|
)
|
|
row = await cursor.fetchone()
|
|
if not row:
|
|
return None
|
|
agent_id, name, description, specs_json, status, palette, hue_shift, seat_zone, office_id, desk_id, eid, opc_role_id = row
|
|
specialties = json.loads(specs_json) if specs_json else []
|
|
return self._to_ui_format(agent_id, name, description, specialties, status, palette, hue_shift, seat_zone, office_id, desk_id, eid, opc_role_id)
|
|
|
|
async def get_employee_agent_map(self) -> dict[str, str]:
|
|
"""Return {employee_id: agent_id} for all employee-linked agents."""
|
|
cursor = await self._db.execute(
|
|
"SELECT employee_id, agent_id FROM agents WHERE employee_id IS NOT NULL"
|
|
)
|
|
rows = await cursor.fetchall()
|
|
return {row[0]: row[1] for row in rows}
|
|
|
|
async def get_role_agent_map(self) -> dict[str, str]:
|
|
"""Return {opc_role_id: agent_id} for all agents.
|
|
|
|
Used by EventAdapter to resolve OPC role_id → UI agent_id.
|
|
If multiple agents share a role, last one wins (acceptable for status routing).
|
|
"""
|
|
cursor = await self._db.execute(
|
|
"SELECT opc_role_id, agent_id FROM agents"
|
|
)
|
|
rows = await cursor.fetchall()
|
|
return {row[0]: row[1] for row in rows}
|
|
|
|
async def update_status_by_role(self, role_id: str, status: str) -> None:
|
|
"""Update status for all agents with the given opc_role_id."""
|
|
if not role_id:
|
|
return
|
|
await self._db.execute(
|
|
"UPDATE agents SET status = ? WHERE opc_role_id = ?",
|
|
(status, role_id),
|
|
)
|
|
await self._db.commit()
|
|
|
|
# ── Private helpers ────────────────────────────────────────────────────
|
|
|
|
async def _get_one(self, agent_id: str) -> dict[str, Any] | None:
|
|
cursor = await self._db.execute(
|
|
"SELECT agent_id, name, description, specialties, status, "
|
|
"palette, hue_shift, seat_zone, office_id, desk_id, employee_id, opc_role_id FROM agents WHERE agent_id = ?",
|
|
(agent_id,),
|
|
)
|
|
row = await cursor.fetchone()
|
|
if not row:
|
|
return None
|
|
agent_id, name, description, specs_json, status, palette, hue_shift, seat_zone, office_id, desk_id, employee_id, opc_role_id = row
|
|
specialties = json.loads(specs_json) if specs_json else []
|
|
return self._to_ui_format(agent_id, name, description, specialties, status, palette, hue_shift, seat_zone, office_id, desk_id, employee_id, opc_role_id)
|
|
|
|
async def _count(self) -> int:
|
|
cursor = await self._db.execute("SELECT COUNT(*) FROM agents")
|
|
row = await cursor.fetchone()
|
|
return row[0] if row else 0
|
|
|
|
@staticmethod
|
|
def _to_ui_format(
|
|
agent_id: str,
|
|
name: str,
|
|
description: str,
|
|
specialties: list[str],
|
|
status: str,
|
|
palette: int,
|
|
hue_shift: int,
|
|
seat_zone: str,
|
|
office_id: str = "office-0",
|
|
desk_id: str | None = None,
|
|
employee_id: str | None = None,
|
|
opc_role_id: str | None = None,
|
|
) -> dict[str, Any]:
|
|
"""Convert to the EXACT format frontend AgentInfo expects."""
|
|
appearance: dict[str, Any] = {
|
|
"palette": palette,
|
|
"hue_shift": hue_shift,
|
|
"seat_zone": seat_zone,
|
|
}
|
|
if desk_id:
|
|
appearance["desk_id"] = desk_id
|
|
result: dict[str, Any] = {
|
|
"agent_id": agent_id,
|
|
"name": name,
|
|
"description": description,
|
|
"specialties": specialties,
|
|
"status": status,
|
|
"office_id": office_id,
|
|
"appearance": appearance,
|
|
"opc_role_id": opc_role_id or agent_id,
|
|
}
|
|
if employee_id:
|
|
result["employee_id"] = employee_id
|
|
return result
|