homarus 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Max Ross
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,114 @@
+# HomarUS
+
+> **Why "HomarUS"?** *Homarus* is the genus of true clawed lobsters — the evolved successor to the claw. The **US** isn't just taxonomy. It's the whole point: human and AI, working together. There is no artificial intelligence without *us*.
+
+Event-driven AI agent coordinator. Receives events from channels, skills, timers, and webhooks — spawns parallel agents to handle the work.
+
+Model-agnostic. Skill-based. Built for people who want to run their own AI infrastructure.
+
+## What it does
+
+```
+Channels (Telegram, Discord, CLI, ...)
+Skills (web UIs, scripts, services)         →  Event Loop  →  Agents (parallel)
+Timers (cron, intervals, one-shots)                           ↓
+Webhooks (HTTP callbacks)                                  Tools, Memory, Models
+```
+
+The loop is a **scheduler and router**, not an AI agent. It receives events, decides what work needs to happen, spawns agents to do it, and handles the results. Agents run in parallel with configurable concurrency, backpressure, and failover.
+
+## Install
+
+```bash
+npm install -g homarus
+```
+
+Or use without installing:
+
+```bash
+npx homarus init
+npx homarus start
+```
+
+## Quick start
+
+```bash
+homarus init        # Interactive wizard: pick provider, enter API key, configure Telegram
+homarus start       # Start the event loop
+```
+
+The setup wizard walks you through provider selection (Anthropic, OpenAI, OpenRouter, or Ollama), API key entry, default model choice, and optional Telegram bot setup. Your config is ready to use immediately — no manual JSON editing required.
+
+Use `--no-wizard` to skip the wizard and generate a default config for manual editing.
+
+See the **[Setup & Usage Guide](docs/guide.md)** for detailed configuration and more.
+
+## Architecture
+
+- **Homarus** — central event loop, single-threaded coordinator
+- **EventBus / EventQueue** — typed pub/sub with priority ordering and backpressure
+- **AgentManager / Agent** — spawns and tracks parallel AI agents
+- **ModelRouter / ModelProvider** — model-agnostic with failover chains (Anthropic, OpenAI, OpenRouter, Ollama, any OpenAI-compatible endpoint)
+- **SkillManager / Skill** — open plugin system via HTTP, stdio, or in-process transports
+- **ChannelManager / ChannelAdapter** — normalized message ingestion from any platform
+- **MemoryIndex** — vector + full-text hybrid search for long-term memory
+- **IdentityManager** — layered soul/user/overlay identity system
+- **TimerService** — cron expressions, intervals, one-shots via croner
+- **HttpApi** — REST API for status, skill callbacks, and external integrations
+- **BrowserManager** — optional Playwright-based headless browser (lazy-loaded, requires `npm install playwright`)
+- **Config** — JSON config with JSON Schema validation and hot reload
+
+## CLI
+
+```
+homarus start [config]      Start the event loop (foreground)
+homarus init [--no-wizard]  Interactive setup wizard (or defaults)
+homarus status [port]       Show status of running instance
+homarus config [config]     Validate config file
+homarus skills              List loaded skills
+homarus install-daemon      Install systemd or launchd service
+```
+
+## Config
+
+Primary: `~/.homarus/config.json`
+Per-project override: `./homarus.json`
+
+Skills go in `~/.homarus/skills/` or `./skills/`.
+Identity files in `~/.homarus/identity/`.
+Memory index at `~/.homarus/memory/`.
+
+## Built-in tools
+
+Agents get access to: `bash`, `read`, `write`, `edit`, `glob`, `grep`, `git`, `web_fetch`, `web_search`, `lsp`, `memory_search`, `memory_get`, `memory_store`, and optionally `browser`.
+
+Browser support requires Playwright as an optional dependency:
+
+```bash
+npm install playwright    # only needed if browser.enabled is set in config
+```
+
+## Requirements
+
+- Node.js >= 22
+- Unix-like system (Linux, macOS)
+
+## Built with mini-spec
+
+HomarUS was designed and implemented using [mini-spec](https://github.com/zot/mini-spec), an 8-phase methodology for AI-assisted software development. Every source file traces back through the full chain: reference materials → natural language specs → requirements → CRC cards → sequence diagrams → code with traceability comments.
+
+The `refs/`, `specs/`, and `design/` directories are the living design artifacts, not just documentation.
+
+## Status
+
+Core architecture implemented (19 source files, 70 requirements, 20 CRC cards, 7 sequence diagrams, 37 tests passing across 5 test suites). Built-in tool suite complete. Currently pre-release.
+
+## Roadmap
+
+- [ ] npm publish + SEA binaries + Homebrew tap
+- [ ] OAuth support for Google/Gemini (the only major provider with third-party OAuth)
+- [x] ~~`homarus auth` onboarding command~~ (shipped as interactive `homarus init` wizard)
+
+## License
+
+[MIT](LICENSE)

package/dist/agent-manager.d.ts

@@ -0,0 +1,35 @@
+import type { AgentConfig, Event, ExecutionStrategyType, Logger } from "./types.js";
+import { Agent } from "./agent.js";
+import type { ModelRouter } from "./model-router.js";
+import type { ToolRegistry } from "./tool-registry.js";
+import type { IdentityManager } from "./identity-manager.js";
+export declare class AgentManager {
+    private agents;
+    private maxConcurrent;
+    private defaultTimeout;
+    private defaultMaxTurns;
+    private defaultExecutionStrategy;
+    private modelRouter;
+    private toolRegistry;
+    private identityManager;
+    private logger;
+    private emitFn;
+    private strategies;
+    constructor(logger: Logger, modelRouter: ModelRouter, toolRegistry: ToolRegistry, identityManager: IdentityManager, options?: {
+        maxConcurrent?: number;
+        defaultTimeout?: number;
+        defaultMaxTurns?: number;
+        defaultExecutionStrategy?: ExecutionStrategyType;
+    });
+    setEmitter(fn: (event: Event) => void): void;
+    spawn(config: AgentConfig): Promise<string>;
+    cancel(agentId: string): void;
+    cancelAll(): void;
+    getAgent(agentId: string): Agent | undefined;
+    getActive(): Agent[];
+    activeCount(): number;
+    canSpawn(): boolean;
+    waitForAll(timeout?: number): Promise<void>;
+    private onAgentComplete;
+}
+//# sourceMappingURL=agent-manager.d.ts.map

package/dist/agent-manager.js

@@ -0,0 +1,127 @@
+import { EmbeddedStrategy } from "./execution-strategy.js";
+import { SubprocessStrategy } from "./subprocess-strategy.js";
+export class AgentManager {
+    agents = new Map();
+    maxConcurrent;
+    defaultTimeout;
+    defaultMaxTurns;
+    defaultExecutionStrategy;
+    modelRouter;
+    toolRegistry;
+    identityManager;
+    logger;
+    emitFn = null;
+    strategies = {
+        embedded: new EmbeddedStrategy(),
+        subprocess: new SubprocessStrategy(),
+    };
+    constructor(logger, modelRouter, toolRegistry, identityManager, options) {
+        this.logger = logger;
+        this.modelRouter = modelRouter;
+        this.toolRegistry = toolRegistry;
+        this.identityManager = identityManager;
+        this.maxConcurrent = options?.maxConcurrent ?? 5;
+        this.defaultTimeout = options?.defaultTimeout ?? 300_000;
+        this.defaultMaxTurns = options?.defaultMaxTurns ?? 20;
+        this.defaultExecutionStrategy = options?.defaultExecutionStrategy ?? "embedded";
+    }
+    setEmitter(fn) {
+        this.emitFn = fn;
+    }
+    // CRC: crc-AgentManager.md — spawn()
+    async spawn(config) {
+        if (!this.canSpawn()) {
+            throw new Error(`Max concurrent agents reached (${this.maxConcurrent})`);
+        }
+        const agentConfig = {
+            ...config,
+            timeout: config.timeout ?? this.defaultTimeout,
+            maxTurns: config.maxTurns ?? this.defaultMaxTurns,
+        };
+        const strategyType = config.executionStrategy ?? this.defaultExecutionStrategy;
+        const strategy = this.strategies[strategyType];
+        const handle = strategy.execute(agentConfig, {
+            modelRouter: this.modelRouter,
+            toolRegistry: this.toolRegistry,
+            identityManager: this.identityManager,
+            logger: this.logger,
+        });
+        if (this.emitFn) {
+            handle.onEvent(this.emitFn);
+        }
+        const activeAgent = {
+            handle,
+            cancel: () => handle.cancel(),
+            agent: handle.agent,
+        };
+        this.agents.set(handle.agentId, activeAgent);
+        this.logger.info("Spawning agent", {
+            id: handle.agentId,
+            model: config.model,
+            strategy: strategyType,
+        });
+        // Run async — don't await, let it complete in background
+        handle.result
+            .then((result) => this.onAgentComplete(handle.agentId, result))
+            .catch((err) => {
+            this.logger.error("Agent run failed", { id: handle.agentId, error: String(err) });
+            this.agents.delete(handle.agentId);
+        });
+        return handle.agentId;
+    }
+    // CRC: crc-AgentManager.md — cancel()
+    cancel(agentId) {
+        const active = this.agents.get(agentId);
+        if (!active)
+            return;
+        active.cancel();
+        this.logger.info("Agent cancel requested", { id: agentId });
+    }
+    // CRC: crc-AgentManager.md — cancelAll()
+    cancelAll() {
+        for (const active of this.agents.values()) {
+            active.cancel();
+        }
+        this.logger.info("All agents cancel requested", { count: this.agents.size });
+    }
+    // CRC: crc-AgentManager.md — getAgent() — returns undefined for subprocess agents
+    getAgent(agentId) {
+        return this.agents.get(agentId)?.agent;
+    }
+    // CRC: crc-AgentManager.md — getActive()
+    getActive() {
+        return [...this.agents.values()]
+            .filter((a) => a.agent?.getState() === "running")
+            .map((a) => a.agent);
+    }
+    // CRC: crc-AgentManager.md — activeCount()
+    activeCount() {
+        return this.agents.size;
+    }
+    // CRC: crc-AgentManager.md — canSpawn()
+    canSpawn() {
+        return this.activeCount() < this.maxConcurrent;
+    }
+    // CRC: crc-AgentManager.md — waitForAll()
+    async waitForAll(timeout = 30_000) {
+        const start = Date.now();
+        while (this.agents.size > 0) {
+            if (Date.now() - start > timeout) {
+                this.logger.warn("Wait for agents timed out, force cancelling", { remaining: this.agents.size });
+                this.cancelAll();
+                return;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+    }
+    // CRC: crc-AgentManager.md — onAgentComplete()
+    onAgentComplete(agentId, result) {
+        this.agents.delete(agentId);
+        this.logger.info("Agent complete", {
+            id: agentId,
+            toolCalls: result.toolCalls.length,
+            tokens: result.usage.inputTokens + result.usage.outputTokens,
+        });
+    }
+}
+//# sourceMappingURL=agent-manager.js.map

package/dist/agent-worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=agent-worker.d.ts.map

package/dist/agent-worker.js

@@ -0,0 +1,141 @@
+// CRC: design.md O4 — Agent subprocess worker entry point
+// This file runs as a child process forked by SubprocessStrategy.
+// It receives an init message, reconstructs deps, runs an Agent, and reports back via IPC.
+import { v4 as uuid } from "uuid";
+import { Agent } from "./agent.js";
+import { ModelRouter } from "./model-router.js";
+import { OpenAICompatibleProvider } from "./model-provider.js";
+// Minimal logger that writes to stderr (stdout is reserved for IPC)
+const logger = {
+    debug: (msg, meta) => console.error(`[worker:debug] ${msg}`, meta ?? ""),
+    info: (msg, meta) => console.error(`[worker:info] ${msg}`, meta ?? ""),
+    warn: (msg, meta) => console.error(`[worker:warn] ${msg}`, meta ?? ""),
+    error: (msg, meta) => console.error(`[worker:error] ${msg}`, meta ?? ""),
+};
+// Pending tool requests awaiting parent response
+const pendingToolCalls = new Map();
+let agent = null;
+function send(msg) {
+    process.send(msg);
+}
+// Build a proxy ToolRegistry that delegates execution to the parent via IPC
+function buildProxyToolRegistry(toolSchemas) {
+    const proxyTools = new Map();
+    for (const schema of toolSchemas) {
+        proxyTools.set(schema.name, {
+            name: schema.name,
+            description: schema.description,
+            parameters: schema.parameters,
+            source: "subprocess-proxy",
+            execute: async (params, context) => {
+                const callId = uuid();
+                return new Promise((resolve, reject) => {
+                    pendingToolCalls.set(callId, { resolve, reject });
+                    send({
+                        type: "tool_request",
+                        callId,
+                        toolName: schema.name,
+                        params,
+                        agentId: context.agentId,
+                        sandbox: context.sandbox,
+                    });
+                });
+            },
+        });
+    }
+    // Return an object that satisfies the ToolRegistry interface used by Agent
+    return {
+        getForAgent(_allowedTools) {
+            return [...proxyTools.values()];
+        },
+        execute: async (name, params, context) => {
+            const tool = proxyTools.get(name);
+            if (!tool)
+                return { output: "", error: `Unknown tool: ${name}` };
+            return tool.execute(params, context);
+        },
+        // Stubs for interface compliance — not used by Agent.run()
+        register() { },
+        unregister() { },
+        get(name) { return proxyTools.get(name); },
+        getAll() { return [...proxyTools.values()]; },
+        registerGroup() { },
+        resolveGroup() { return []; },
+        addPolicy() { },
+        checkPolicy() { return true; },
+        toSchemas() {
+            return [...proxyTools.values()].map((t) => ({
+                name: t.name, description: t.description, parameters: t.parameters,
+            }));
+        },
+    };
+}
+// Build a minimal IdentityManager that returns the pre-built system prompt
+function buildProxyIdentityManager(systemPrompt) {
+    return {
+        buildSystemPrompt: () => systemPrompt,
+        load() { },
+        reload() { },
+        getSoul() { return ""; },
+        getUser() { return ""; },
+        getOverlay() { return undefined; },
+        getWorkspaceFile() { return undefined; },
+        listOverlays() { return []; },
+    };
+}
+// Build a ModelRouter from serialized provider configs
+function buildModelRouter(providers, defaultModel, aliases, fallbackChain) {
+    const router = new ModelRouter(logger, defaultModel);
+    for (const pc of providers) {
+        const provider = new OpenAICompatibleProvider(pc.id, pc.baseUrl, { apiKey: pc.apiKey }, logger);
+        router.registerProvider(provider);
+    }
+    router.setAliases(aliases);
+    router.setFallbackChain(fallbackChain);
+    return router;
+}
+async function handleInit(msg) {
+    const modelRouter = buildModelRouter(msg.providerConfigs, msg.defaultModel, msg.aliases, msg.fallbackChain);
+    const toolRegistry = buildProxyToolRegistry(msg.toolSchemas);
+    const identityManager = buildProxyIdentityManager(msg.systemPrompt);
+    agent = new Agent(msg.agentConfig, modelRouter, toolRegistry, identityManager, logger);
+    agent.setEmitter((event) => {
+        send({ type: "event", event });
+    });
+    try {
+        const result = await agent.run();
+        send({ type: "result", result });
+        process.exit(0);
+    }
+    catch (err) {
+        send({ type: "error", error: String(err.message ?? err) });
+        process.exit(1);
+    }
+}
+process.on("message", (msg) => {
+    switch (msg.type) {
+        case "init":
+            handleInit(msg).catch((err) => {
+                send({ type: "error", error: String(err) });
+                process.exit(1);
+            });
+            break;
+        case "tool_result": {
+            const pending = pendingToolCalls.get(msg.callId);
+            if (pending) {
+                pendingToolCalls.delete(msg.callId);
+                pending.resolve(msg.result);
+            }
+            break;
+        }
+        case "cancel":
+            agent?.cancel();
+            break;
+    }
+});
+// Clean exit on disconnect
+process.on("disconnect", () => {
+    agent?.cancel();
+    process.exit(0);
+});
+//# sourceMappingURL=agent-worker.js.map

package/dist/agent.d.ts

@@ -0,0 +1,33 @@
+import type { AgentConfig, AgentState, AgentResult, Event, Logger } from "./types.js";
+import type { ModelRouter } from "./model-router.js";
+import type { ToolRegistry } from "./tool-registry.js";
+import type { IdentityManager } from "./identity-manager.js";
+export declare class Agent {
+    readonly id: string;
+    private state;
+    private config;
+    private turns;
+    private startTime;
+    private result;
+    private cancelled;
+    private totalUsage;
+    private toolCallLog;
+    private modelRouter;
+    private toolRegistry;
+    private identityManager;
+    private logger;
+    private emitFn;
+    constructor(config: AgentConfig, modelRouter: ModelRouter, toolRegistry: ToolRegistry, identityManager: IdentityManager, logger: Logger);
+    setEmitter(fn: (event: Event) => void): void;
+    getState(): AgentState;
+    getResult(): AgentResult | null;
+    run(): Promise<AgentResult>;
+    cancel(): void;
+    isTimedOut(): boolean;
+    isOverTurns(): boolean;
+    private buildResult;
+    private emitProgress;
+    private emitResult;
+    private emitError;
+}
+//# sourceMappingURL=agent.d.ts.map

package/dist/agent.js

@@ -0,0 +1,197 @@
+// CRC: crc-Agent.md | Seq: seq-agent-execution.md
+import { v4 as uuid } from "uuid";
+export class Agent {
+    id;
+    state = "pending";
+    config;
+    turns = 0;
+    startTime = 0;
+    result = null;
+    cancelled = false;
+    totalUsage = { inputTokens: 0, outputTokens: 0 };
+    toolCallLog = [];
+    modelRouter;
+    toolRegistry;
+    identityManager;
+    logger;
+    emitFn = null;
+    constructor(config, modelRouter, toolRegistry, identityManager, logger) {
+        this.id = uuid();
+        this.config = config;
+        this.modelRouter = modelRouter;
+        this.toolRegistry = toolRegistry;
+        this.identityManager = identityManager;
+        this.logger = logger;
+    }
+    setEmitter(fn) {
+        this.emitFn = fn;
+    }
+    getState() {
+        return this.state;
+    }
+    getResult() {
+        return this.result;
+    }
+    // CRC: crc-Agent.md — run()
+    async run() {
+        this.state = "running";
+        this.startTime = Date.now();
+        this.emitProgress("started");
+        const maxTurns = this.config.maxTurns ?? 20;
+        const systemPrompt = this.identityManager.buildSystemPrompt({
+            channel: this.config.channel,
+            taskOverlay: this.config.taskOverlay,
+            taskPrompt: this.config.systemPrompt,
+        });
+        const messages = [
+            { role: "system", content: systemPrompt },
+            { role: "user", content: this.config.prompt },
+        ];
+        const tools = this.toolRegistry.getForAgent(this.config.tools);
+        const toolSchemas = tools.length > 0
+            ? tools.map((t) => ({ name: t.name, description: t.description, parameters: t.parameters }))
+            : undefined;
+        try {
+            while (this.turns < maxTurns && !this.cancelled) {
+                if (this.isTimedOut()) {
+                    this.state = "failed";
+                    this.emitError("Agent timed out");
+                    return this.buildResult("Agent timed out after " + (this.config.timeout ?? 300_000) + "ms");
+                }
+                this.turns++;
+                let fullContent = "";
+                const pendingToolCalls = [];
+                // Stream inference
+                for await (const chunk of this.modelRouter.chat({
+                    model: this.modelRouter.resolve(this.config.model),
+                    messages,
+                    tools: toolSchemas,
+                    maxTokens: 4096,
+                })) {
+                    if (chunk.content)
+                        fullContent += chunk.content;
+                    if (chunk.toolCalls)
+                        pendingToolCalls.push(...chunk.toolCalls);
+                    if (chunk.usage) {
+                        this.totalUsage.inputTokens += chunk.usage.inputTokens;
+                        this.totalUsage.outputTokens += chunk.usage.outputTokens;
+                    }
+                }
+                // No tool calls — agent is done
+                if (pendingToolCalls.length === 0) {
+                    this.state = "complete";
+                    this.result = this.buildResult(fullContent);
+                    this.emitResult();
+                    return this.result;
+                }
+                // Record assistant message with tool calls
+                messages.push({
+                    role: "assistant",
+                    content: fullContent,
+                    toolCalls: pendingToolCalls,
+                });
+                // Execute tool calls
+                for (const tc of pendingToolCalls) {
+                    if (this.cancelled)
+                        break;
+                    const start = Date.now();
+                    let params;
+                    try {
+                        params = JSON.parse(tc.arguments);
+                    }
+                    catch {
+                        params = tc.arguments;
+                    }
+                    const result = await this.toolRegistry.execute(tc.name, params, {
+                        agentId: this.id,
+                        sandbox: this.config.sandbox ?? false,
+                        workingDir: process.cwd(),
+                    });
+                    this.toolCallLog.push({
+                        tool: tc.name,
+                        params,
+                        result: result.error ?? result.output,
+                        durationMs: Date.now() - start,
+                    });
+                    messages.push({
+                        role: "tool",
+                        content: result.error ?? result.output,
+                        toolCallId: tc.id,
+                    });
+                }
+                this.emitProgress(`turn ${this.turns}/${maxTurns}`);
+            }
+            // Exhausted turns
+            if (this.cancelled) {
+                this.state = "cancelled";
+                this.result = this.buildResult("Agent cancelled");
+            }
+            else {
+                this.state = "complete";
+                this.result = this.buildResult("Agent reached max turns");
+            }
+            this.emitResult();
+            return this.result;
+        }
+        catch (err) {
+            this.state = "failed";
+            const errorMsg = String(err.message ?? err);
+            this.emitError(errorMsg);
+            return this.buildResult(errorMsg);
+        }
+    }
+    // CRC: crc-Agent.md — cancel()
+    cancel() {
+        this.cancelled = true;
+        this.logger.info("Agent cancellation requested", { id: this.id });
+    }
+    // CRC: crc-Agent.md — isTimedOut()
+    isTimedOut() {
+        if (!this.config.timeout)
+            return false;
+        return Date.now() - this.startTime > this.config.timeout;
+    }
+    // CRC: crc-Agent.md — isOverTurns()
+    isOverTurns() {
+        return this.turns >= (this.config.maxTurns ?? 20);
+    }
+    buildResult(output) {
+        return {
+            output,
+            toolCalls: [...this.toolCallLog],
+            usage: { ...this.totalUsage },
+        };
+    }
+    // CRC: crc-Agent.md — emitProgress()
+    emitProgress(progress) {
+        this.emitFn?.({
+            id: uuid(),
+            type: "agent_progress",
+            source: `agent:${this.id}`,
+            timestamp: Date.now(),
+            payload: { agentId: this.id, progress, turns: this.turns },
+        });
+    }
+    // CRC: crc-Agent.md — emitResult()
+    emitResult() {
+        this.emitFn?.({
+            id: uuid(),
+            type: "agent_complete",
+            source: `agent:${this.id}`,
+            timestamp: Date.now(),
+            replyTo: this.config.replyTo,
+            payload: { agentId: this.id, result: this.result, state: this.state },
+        });
+    }
+    // CRC: crc-Agent.md — emitError()
+    emitError(error) {
+        this.emitFn?.({
+            id: uuid(),
+            type: "agent_error",
+            source: `agent:${this.id}`,
+            timestamp: Date.now(),
+            payload: { agentId: this.id, error },
+        });
+    }
+}
+//# sourceMappingURL=agent.js.map