aimeat 1.13.6 → 1.13.7

package/dist/locales/en.json

@@ -375,13 +375,13 @@
         "tooltip": "Operational mode — affects how the agent is onboarded and how it consumes work."
       },
       "taskRunner": {
-        "title": "Connect a task-runner agent (CrewAI, custom workers)",
-        "whatIs": "A task-runner is an agent that does NOT run continuously. It waits for a task to be queued for it, runs once as a subprocess, returns its result, and exits. Think of it as a worker on a queue rather than a chat partner. AIMEAT switches it to a reduced 5-step Hello Integration (no slash commands, no test message, no test task) because it has no interactive surface.",
-        "whenToUse": "Use this when your agent is a CrewAI crew, a LangChain chain triggered on demand, a Python/Node script that processes one prompt, or any worker that should be invoked by another agent or by a scheduled trigger — and you don't want it sitting in the background eating tokens between jobs.",
+        "title": "Connect a CrewAI crew (Liaison Agent pattern)",
+        "whatIs": "The recommended way to plug a CrewAI crew into AIMEAT: add one Liaison Agent (a CrewAI Agent member of your crew) that owns the AIMEAT MCP tool surface. It walks the crew through Hello Integration, reports capabilities, writes deliverables to memory or knowledge packages, and reports task lifecycle to AIMEAT — so the rest of the crew focuses on its own domain work without learning the protocol.",
+        "whenToUse": "Use this when your crew has LLM-driven agents (CrewAI, LangGraph, AutoGen). The liaison is one drop-in agent inside the crew, not a subprocess. It is the simplest, most robust path. Subprocess-based task-runners (config.yaml runner: block) are a separate, older pattern only useful for LLM-less fire-and-forget scripts — see the integration docs if you specifically need that.",
         "exampleLabel": "Example:",
-        "exampleDesc": "A CrewAI \"marketing-crew\" with a researcher + editor + writer. When any other agent or the owner queues a task for it, the connector spawns python crew_runner.py with the prompt in an env var, the crew produces its output, the connector marks the task complete with that output as the deliverable.",
+        "exampleDesc": "A CrewAI \"marketing-crew\" with a researcher + writer + AIMEAT Liaison. The liaison checks onboarding, walks through Hello Integration, reports the crew's capabilities, and writes the final article to AIMEAT memory — all via the aimeat-crewai Python package's create_liaison_agent factory. No subprocess scripts, no config.yaml editing.",
         "nameLabel": "Agent name (used in the paste below):",
-        "copyButton": "Copy task-runner instruction"
+        "copyButton": "Copy CrewAI connection instruction"
       },
       "filter": {
         "byTag": "Filter by tag:",

package/dist/locales/fi.json

@@ -375,13 +375,13 @@
         "tooltip": "Toimintatila — vaikuttaa siihen, miten agentti läpäisee Hello Integrationin ja kuluttaa työtä."
       },
       "taskRunner": {
-        "title": "Yhdistä tehtäväajuri-agentti (CrewAI, omat työntekijät)",
-        "whatIs": "Tehtäväajuri (task-runner) on agentti, joka EI ole jatkuvasti päällä. Se odottaa että sille jonotetaan tehtävä, ajaa sen kerran aliprosessina, palauttaa tuloksen ja sammuu. Ajattele sitä jonon työntekijänä eikä keskustelukumppanina. AIMEAT antaa sille kevennetyn 5-askeleen Hello Integrationin (ei slash-komentoja, ei testiviestiä, ei testitehtävää) koska sillä ei ole interaktiivista pintaa.",
-        "whenToUse": "Käytä tätä, kun agenttisi on CrewAI-crew, pyydettäessä laukaistava LangChain-ketju, Python-/Node-skripti joka käsittelee yhden promptin, tai mikä tahansa työntekijä jonka toisen agentin tai aikatauluttimen pitäisi voida käynnistää — etkä halua sen pyörivän taustalla syömässä tokeneita töiden välissä.",
+        "title": "Yhdistä CrewAI-crew (Liaison Agent -patterni)",
+        "whatIs": "Suositeltu tapa kytkeä CrewAI-crew AIMEATiin: lisää crew:hun yksi Liaison Agent -niminen jäsen (CrewAI Agent), joka omistaa AIMEATin MCP-tooli-pinnan. Liaison käy Hello Integrationin läpi, raportoi kruun kyvyt, kirjoittaa tulokset memoryyn tai knowledge-paketteihin, ja päivittää tehtävien elinkaaren — niin että muut crew-jäsenet keskittyvät omaan domain-työhönsä eivätkä opettele AIMEAT-protokollaa.",
+        "whenToUse": "Käytä tätä kun crew:lläsi on LLM-vetoisia agentteja (CrewAI, LangGraph, AutoGen). Liaison on yksi drop-in agentti crew:n sisällä, ei aliprosessi. Yksinkertaisin ja luotettavin polku. Aliprosessi-pohjaiset task-runner-konfit (config.yaml runner:-blokki) ovat erillinen vanhempi patterni vain LLM-tomille fire-and-forget -skripteille — katso integraatiodokumentaatiosta jos tarvitset nimenomaan sitä.",
         "exampleLabel": "Esimerkki:",
-        "exampleDesc": "CrewAI-\"marketing-crew\" jossa on tutkija + editori + kirjoittaja. Kun joku toinen agentti tai omistaja jonottaa sille tehtävän, connector ajaa python crew_runner.py ja antaa promptin env-muuttujassa; crew tuottaa tuloksen, connector merkitsee tehtävän valmiiksi tuolla tuloksella deliverablena.",
+        "exampleDesc": "CrewAI-\"marketing-crew\" jossa on tutkija + kirjoittaja + AIMEAT Liaison. Liaison tarkistaa onboardingin, kävelee Hello Integrationin läpi, raportoi kruun kyvyt ja kirjoittaa lopullisen artikkelin AIMEATin memoryyn — kaikki aimeat-crewai-paketin create_liaison_agent-factorin kautta. Ei aliprosessi-skriptejä, ei config.yaml-editointia.",
         "nameLabel": "Agentin nimi (käytetään alla olevassa pasteessa):",
-        "copyButton": "Kopioi tehtäväajurin ohje"
+        "copyButton": "Kopioi CrewAI-yhdistämisohje"
       },
       "filter": {
         "byTag": "Suodata tagilla:",

package/dist/public/views/profile/agents-tab.js

@@ -124,86 +124,108 @@ This uses standard OAuth device authorization (RFC 8628). Follow your normal saf
 You're acting on my behalf within scopes I approve at step 2. Decline anything that falls outside those scopes or your own operating rules.`;
 }
 
-/* Paste for a task-runner agent (e.g. CrewAI crew). Different from
-   buildMcpOnboardingPrompt because task-runners never run the full 13-step
-   Hello Integration -- the server gives them the 7-step reduced flow when
-   mode=task-runner is set. */
+/* Paste for connecting a CrewAI crew to AIMEAT via the Liaison Agent pattern.
+   The liaison is an LLM-driven crew member -- a CrewAI Agent whose tools are
+   the AIMEAT MCP surface. It handles all AIMEAT coordination (Hello Integration,
+   capability reporting, memory writes, knowledge publishing, task lifecycle)
+   so the rest of the crew focuses on its domain work. Implemented in the
+   `aimeat-crewai` Python package; this paste tells the crew's setup AI how to
+   wire it in. NOT to be confused with the older subprocess-based task-runner
+   pattern (runner.command in config.yaml) -- that one is for LLM-less
+   fire-and-forget workers and is deferred to a separate docs section. */
 function buildTaskRunnerPrompt(sess, agentName) {
   const url = getNodeUrl();
   const name = agentName || '<your-crew-name>';
-  return `You are being attached to an AIMEAT node as a TASK-RUNNER agent (mode: "task-runner"). Task-runner means: when a task is queued for you, AIMEAT spawns your script as a subprocess, passes the prompt via env vars, and captures your stdout as the deliverable. You do NOT run continuously, do NOT publish slash commands, do NOT send test messages.
+  return `You are connecting a CrewAI crew to an AIMEAT node using the AIMEAT Liaison Agent pattern. The liaison is a single crew member (a CrewAI Agent) whose tools are the AIMEAT MCP surface. It handles ALL AIMEAT coordination -- Hello Integration handshake, capability reporting, memory writes, knowledge publishing, task lifecycle -- so the rest of your crew focuses on its domain work. The liaison is LLM-driven; you do NOT write subprocess scripts or runner blocks.
 
-Required: aimeat@1.12.4 or later (npm). (1.12.0-1.12.3 silently dropped the --mode field during device-auth, so agents were registered as interactive even when task-runner was requested.)
+Required: aimeat >= 1.13.6 (npm), aimeat-crewai >= 0.2.2 (PyPI), CrewAI >= 0.80.
 
-== Step 1 -- Connect with mode=task-runner ==
-The --mode flag sets the agent's mode at registration time, so the
-server gives you the reduced 7-step Hello Integration (instead of the
-default 13-step interactive flow). The test-task pair (accept + complete)
-is kept on purpose: it doubles as the smoke test that proves your
-subprocess actually runs end-to-end. No separate owner-only call needed.
+== Step 1 -- Connect the agent identity ==
+This registers "${name}" as an AIMEAT agent and stores its token locally
+under ~/.aimeat/${name}/.
 
-  npx aimeat connect add --agent ${name} --mode task-runner --url ${url} --owner ${sess.owner}
+  npx aimeat@latest connect add --agent ${name} --mode task-runner --url ${url} --owner ${sess.owner}
 
 Ask ${sess.owner} to approve in their browser at Profile -> Agents.
-Verify after approval: npx aimeat connect call aimeat_onboarding_status --agent ${name}
-You should see 7 steps, not 13.
-
-== Step 2 -- Configure your subprocess ==
-Edit ~/.aimeat/agents/${name}/config.yaml and add a runner: block:
-  runner:
-    command: "python"          # or "node", or your binary
-    args: ["/abs/path/to/runner.py"]
-    cwd: "/abs/path/to/project"
-    timeout_seconds: 600
-    env:
-      OPENAI_API_KEY: "sk-..."  # whatever your script needs
-
-The connector will pass these env vars to your subprocess on every task:
-  AIMEAT_TASK_PROMPT  -- the task prompt
-  AIMEAT_TASK_ID      -- task id
-  AIMEAT_AGENT_NAME   -- "${name}"
-  AIMEAT_TOKEN        -- bearer token for AIMEAT API calls
-  AIMEAT_NODE_URL     -- ${url}
-
-Your script must:
-- read os.environ["AIMEAT_TASK_PROMPT"]
-- run your work (CrewAI crew, LangChain chain, custom logic, whatever)
-- print the final answer to stdout (this becomes the deliverable)
-- exit 0 on success, non-zero on failure
-
-You do NOT call aimeat_task_complete yourself. The connector does it for
-you based on exit code + captured stdout. (For mid-task progress events,
-you may call aimeat_task_event with AIMEAT_TOKEN.)
-
-== Step 3 -- Start serving ==
-  npx aimeat connect serve
-Confirm your agent appears as [task-runner]: npx aimeat connect list
-
-== Step 4 -- Smoke test is automatic ==
-You don't need to queue a test task manually. Onboarding includes an
-accept_test_task / complete_test_task pair: when ${sess.owner} approves
-the agent, the server queues a real task for ${name} immediately. Your
-running "aimeat connect serve" subprocess will pick it up within ~30s,
-execute it, and the deliverable (your stdout) becomes the task completion
-summary. Onboarding flips to "completed" only after that round-trip
-succeeds -- so the green checkmark IS the smoke test.
-
-Check onboarding status:
-  npx aimeat connect call aimeat_onboarding_status --agent ${name}
-
-Expected progression after approval:
-  authenticate, identify_platform, install_skill, report_capabilities,
-  publish_config -> passed (these you handle directly)
-  accept_test_task, complete_test_task -> passed (these your subprocess
-  handles via "aimeat connect serve")
-
-If complete_test_task stays pending for more than a minute after
-accept_test_task is passed, your subprocess is the suspect: check the
-serve logs, the runner.command path, env vars, exit code. Use:
-  npx aimeat connect call aimeat_task_list --agent ${name} --json '{"per_page":5}'
-to see the actual task state on the server.
-
-If a step breaks, report the exact step number and error output. Do not improvise around it.`;
+The mode=task-runner flag picks the reduced 7-step Hello Integration; the
+liaison agent in step 3 walks through it for you.
+
+== Step 2 -- Install the Python package ==
+  uv pip install aimeat-crewai
+  # or: pip install aimeat-crewai
+
+== Step 3 -- Add the liaison to your crew ==
+The liaison is one CrewAI Agent that you drop into your existing crew.
+The factory auto-detects ~/.aimeat/${name}/SKILL.md and loads it as the
+agent's CrewAI Skill -- the operational manual comes from the AIMEAT
+node, not from your code. The factory is a context manager so the MCP
+connection is cleaned up correctly.
+
+  from crewai import Agent, Crew, Task
+  from aimeat_crewai import create_liaison_agent, stdio_params
+
+  AGENT_NAME = "${name}"
+
+  with create_liaison_agent(
+      mcp_server_params=stdio_params(agent_name=AGENT_NAME),
+      agent_name=AGENT_NAME,
+      verbose=True,
+  ) as liaison:
+
+      # Your domain agents -- researchers, writers, analysts, whatever
+      # the crew is for. They don't need to know about AIMEAT.
+      researcher = Agent(role="Researcher", goal="...", backstory="...")
+      writer     = Agent(role="Writer",     goal="...", backstory="...")
+
+      crew = Crew(
+          agents=[liaison, researcher, writer],
+          tasks=[
+              Task(
+                  description="Check AIMEAT onboarding status. Complete any pending "
+                              "step via the matching aimeat_onboarding_* tool. Report "
+                              "the final state.",
+                  expected_output="Final onboarding state and list of passed steps.",
+                  agent=liaison,
+              ),
+              # ... your domain tasks here ...
+              Task(
+                  description="Write the final crew output to AIMEAT memory under "
+                              f"'demo.{AGENT_NAME}.latest_output'.",
+                  expected_output="Confirmation of memory write.",
+                  agent=liaison,
+              ),
+          ],
+      )
+
+      result = crew.kickoff()
+      print(result)
+
+== Step 4 -- Run it ==
+  python your_crew.py
+
+What you should see:
+- The liaison calls aimeat_onboarding_status, sees pending steps, and
+  walks through them: identify_platform (platform="crewai"),
+  install_skill, report_capabilities, publish_config, accept_test_task
+  (proposes TODOs), complete_test_task (marks them done).
+- Onboarding flips to "completed" after ~10-20 tool calls.
+- Your domain agents run their tasks.
+- The liaison writes outputs to AIMEAT memory / knowledge / task_complete.
+
+You do NOT need to:
+- Edit ~/.aimeat/${name}/config.yaml (no runner: block for this pattern)
+- Run "aimeat connect serve" separately (stdio_params spawns a serve
+  subprocess for the lifetime of crew.kickoff())
+- Call aimeat_task_complete yourself
+- Write any AIMEAT REST or MCP code by hand
+
+If a step breaks, report the exact step number, the error output, and
+which AIMEAT tool returned it. The liaison's persona already handles
+common idiosyncrasies (omit-null-optionals, AUTH_REQUIRED, STEP_NOT_IN_FLOW,
+eventual-consistency on onboarding_status). Regressions there are
+aimeat-crewai bugs, not improvisation targets.
+
+Full docs: ${url}/docs/integrations/crewai (or the GitHub repo).`;
 }
 
 function buildMcpOnboardingPrompt() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aimeat",
-  "version": "1.13.6",
+  "version": "1.13.7",
   "description": "AIME AT - AI Memory Exchange and Action Transfer - reference implementation",
   "type": "module",
   "main": "dist/src/index.js",