@kisev/agentomatic 11.0.2-dev.85.gb47f85ffc092 → 11.0.2-dev.87.g5a92e74c6754

package/dist/index.js

@@ -1,191 +1,115 @@
 import { z } from "zod";
-import { registerV2Hooks } from "./plugins/compatibility.js";
 import { CATEGORIES, RoutingGate, } from "./routing.js";
 import { rulesInjector } from "./plugins/rules-injector.js";
 import { rtk } from "./plugins/rtk.js";
 import { zedBell } from "./plugins/zed-bell.js";
+import { resultText, toolInput } from "./plugins/events.js";
 import { digest } from "./lifecycle.js";
+import { matchesWildcard } from "./opencode-config.js";
 export { rulesInjector, rtk, zedBell };
-const plugin = (async (input) => {
-    const gate = new RoutingGate();
-    const hostInventory = async () => {
-        if (!input.client?.app?.agents)
-            throw new Error("Resolved OpenCode agent inventory is unavailable");
-        const response = await input.client.app.agents({ query: { directory: input.directory } });
-        const raw = response.data;
-        if (!Array.isArray(raw))
-            throw new Error("Resolved OpenCode agent inventory is malformed");
-        const capabilities = {
-            mapper: ["read", "search"],
-            architect: ["read", "architecture"],
-            worker: ["read", "write", "verify"],
-            review: ["read", "review"],
-            critic: ["read", "review"],
-        };
-        const agents = raw.map((value) => {
-            const agent = value;
-            if (typeof agent.name !== "string" || !agent.name)
-                throw new Error("Resolved OpenCode agent has no name");
-            return {
-                agent: agent.name,
-                available: true,
-                capabilities: capabilities[agent.name] ??
-                    (/^critic-[a-z0-9]+(?:-[a-z0-9]+)*$/.test(agent.name) ? ["read", "review"] : ["read"]),
-                tools: [
-                    "read",
-                    ...(agent.permission?.edit !== "deny" ? ["edit"] : []),
-                    ...Object.entries(agent.tools ?? {})
-                        .filter(([, enabled]) => enabled)
-                        .map(([name]) => name),
-                    ...Object.entries(agent.permission?.bash ?? {})
-                        .filter(([, mode]) => mode !== "deny")
-                        .map(() => "bash"),
-                ].filter((name, index, list) => list.indexOf(name) === index),
-            };
-        });
-        return { agents, revision: digest(raw) };
-    };
-    const route = {
-        description: "Resolve a capability category and dispatch one eligible agent through a one-use Task receipt gate.",
-        args: {
-            action: z.enum(["preview", "dispatch"]),
-            category: z.enum(CATEGORIES),
-            task: z.string(),
-            requirements: z.array(z.string()).default([]),
-            execution_card: z.any().optional(),
-            override: z.string().optional(),
-            trusted_override: z.boolean().optional(),
-            budget: z
-                .object({
-                cost_class: z.string().optional(),
-                latency_class: z.string().optional(),
-            })
-                .optional(),
-            decision: z.any().optional(),
-        },
-        async execute(args, context) {
-            const inventory = await hostInventory();
-            const input = {
-                category: args.category,
-                task: args.task,
-                requirements: args.requirements,
-                agents: inventory.agents,
-                inventory_revision: inventory.revision,
-                execution_card: args.execution_card,
-                override: args.override,
-                trusted_override: args.trusted_override,
-                budget: args.budget,
+export default {
+    id: "agentomatic",
+    async setup(ctx) {
+        const gate = new RoutingGate();
+        const hostInventory = async () => {
+            const { data: raw } = await ctx.agent.list({
+                location: { directory: ctx.location.directory },
+            });
+            const capabilities = {
+                mapper: ["read", "search"],
+                architect: ["read", "architecture"],
+                worker: ["read", "write", "verify"],
+                review: ["read", "review"],
+                critic: ["read", "review"],
             };
-            if (args.action === "preview")
-                return JSON.stringify(gate.preview(input));
-            const decision = gate.dispatch(input, args.decision);
-            if (decision.agent === "worker" && args.execution_card === undefined)
-                throw new Error("implementation dispatch requires a confirmed execution card");
-            const receipt = gate.grant(context.sessionID, decision, {
-                task: args.task,
-                requirements: args.requirements,
-                card: args.execution_card,
+            const agents = raw.map((agent) => ({
+                agent: agent.id,
+                available: true,
+                capabilities: capabilities[agent.id] ??
+                    (/^critic-[a-z0-9]+(?:-[a-z0-9]+)*$/.test(agent.id) ? ["read", "review"] : ["read"]),
+                tools: ["read", "glob", "grep", "edit", "shell"].filter((action) => {
+                    const rules = agent.permissions.filter((rule) => matchesWildcard(rule.action, action));
+                    const broad = rules.reduce((last, rule, index) => (rule.resource === "*" ? index : last), -1);
+                    return rules.slice(Math.max(0, broad)).some((rule) => rule.effect !== "deny");
+                }),
+            }));
+            return { agents, revision: digest(raw) };
+        };
+        await ctx.tool.transform((editor) => {
+            editor.add({
+                name: "route",
+                description: "Resolve a capability category and dispatch one eligible agent through a one-use subagent receipt gate.",
+                input: z.object({
+                    action: z.enum(["preview", "dispatch"]),
+                    category: z.enum(CATEGORIES),
+                    task: z.string(),
+                    requirements: z.array(z.string()).default([]),
+                    execution_card: z.any().optional(),
+                    override: z.string().optional(),
+                    trusted_override: z.boolean().optional(),
+                    budget: z
+                        .object({ cost_class: z.string().optional(), latency_class: z.string().optional() })
+                        .optional(),
+                    decision: z.any().optional(),
+                }),
+                async execute(args, context) {
+                    const inventory = await hostInventory();
+                    const input = {
+                        category: args.category,
+                        task: args.task,
+                        requirements: args.requirements,
+                        agents: inventory.agents,
+                        inventory_revision: inventory.revision,
+                        execution_card: args.execution_card,
+                        override: args.override,
+                        trusted_override: args.trusted_override,
+                        budget: args.budget,
+                    };
+                    if (args.action === "preview")
+                        return { content: JSON.stringify(gate.preview(input)) };
+                    const decision = gate.dispatch(input, args.decision);
+                    if (decision.agent === "worker" && args.execution_card === undefined)
+                        throw new Error("implementation dispatch requires a confirmed execution card");
+                    const receipt = gate.grant(context.sessionID, decision, {
+                        task: args.task,
+                        requirements: args.requirements,
+                        card: args.execution_card,
+                    });
+                    return { content: JSON.stringify({ decision, receipt, status: "routed" }) };
+                },
             });
-            return JSON.stringify({ decision, receipt, status: "routed" });
-        },
-    };
-    return {
-        tool: { route },
-        "tool.execute.before": async (input, output) => {
-            if (input.tool !== "task")
+        });
+        await ctx.tool.hook("execute.before", async (event) => {
+            if (event.tool !== "subagent")
                 return;
-            const args = output.args && typeof output.args === "object"
-                ? output.args
-                : {};
-            const agent = typeof args.agent === "string"
-                ? args.agent
-                : typeof args.subagent_type === "string"
-                    ? args.subagent_type
-                    : undefined;
+            const args = toolInput(event.input);
+            const agent = typeof args.agent === "string" ? args.agent : undefined;
             if (!agent)
-                throw new Error("Native Task requires an explicit agent and an active routing receipt");
+                throw new Error("Native subagent requires an explicit agent and an active routing receipt");
             const hasBinding = "task" in args || "requirements" in args || "execution_card" in args;
             if (!hasBinding)
-                gate.consume(input.sessionID, agent);
-            else {
-                const task = typeof args.task === "string" ? args.task : "";
-                const requirements = Array.isArray(args.requirements)
-                    ? args.requirements
-                    : [];
-                gate.consume(input.sessionID, agent, { task, requirements, card: args.execution_card });
-            }
-        },
-        "tool.execute.after": async (input, output) => {
-            if (input.tool !== "task")
+                gate.consume(event.sessionID, agent);
+            else
+                gate.consume(event.sessionID, agent, {
+                    task: typeof args.task === "string" ? args.task : "",
+                    requirements: Array.isArray(args.requirements) ? args.requirements : [],
+                    card: args.execution_card,
+                });
+        });
+        await ctx.tool.hook("execute.after", async (event) => {
+            if (event.tool !== "subagent" || event.status !== "completed")
                 return;
-            const args = input.args && typeof input.args === "object" ? input.args : {};
-            const agent = typeof args.agent === "string"
-                ? args.agent
-                : typeof args.subagent_type === "string"
-                    ? args.subagent_type
-                    : undefined;
-            if (!agent)
-                throw new Error("Task result requires an explicit agent");
+            const args = toolInput(event.input);
+            if (typeof args.agent !== "string")
+                throw new Error("Subagent result requires an explicit agent");
             let result;
             try {
-                result = JSON.parse(output.output);
+                result = JSON.parse(resultText(event.result) ?? "");
             }
             catch {
-                throw new Error("Task result must be JSON structured report");
+                throw new Error("Subagent result must be JSON structured report");
             }
-            gate.complete(input.sessionID, agent, result);
-        },
-    };
-});
-export const server = plugin;
-export default {
-    id: "agentomatic",
-    server,
-    async setup(ctx) {
-        const hooks = await plugin({
-            directory: ctx.location.directory,
-            client: {
-                app: {
-                    agents: async () => {
-                        const { data: agents } = await ctx.agent.list({
-                            location: { directory: ctx.location.directory },
-                        });
-                        return {
-                            data: agents.map((agent) => ({
-                                name: agent.id,
-                                tools: Object.fromEntries(["read", "glob", "grep", "edit", "bash"].map((tool) => [
-                                    tool,
-                                    [...agent.permissions]
-                                        .reverse()
-                                        .find((rule) => (rule.action === (tool === "bash" ? "shell" : tool) ||
-                                        rule.action === "*") &&
-                                        rule.resource === "*")?.effect !== "deny",
-                                ])),
-                                permission: {
-                                    edit: agent.permissions.some((rule) => rule.action === "edit" && rule.resource === "*" && rule.effect === "deny")
-                                        ? "deny"
-                                        : "allow",
-                                    bash: Object.fromEntries(agent.permissions
-                                        .filter((rule) => rule.action === "shell")
-                                        .map((rule) => [rule.resource, rule.effect])),
-                                },
-                            })),
-                        };
-                    },
-                },
-            },
-        });
-        await ctx.tool.transform((editor) => {
-            const route = hooks.tool.route;
-            editor.add({
-                name: "route",
-                description: route.description,
-                input: z.object(route.args),
-                async execute(args, context) {
-                    return { content: await route.execute(args, context) };
-                },
-            });
+            gate.complete(event.sessionID, args.agent, result);
         });
-        return registerV2Hooks(ctx, hooks);
     },
 };

package/dist/jsonc.d.ts

@@ -30,7 +30,18 @@ export type JsoncPath = Array<string | number>;
 export type JsoncEdit = {
     kind: "append-unique";
     path: JsoncPath;
-    value: string;
+    value: unknown;
+} | {
+    kind: "set-value";
+    path: JsoncPath;
+    value: unknown;
+} | {
+    kind: "rename-key";
+    path: JsoncPath;
+    to: string;
+} | {
+    kind: "remove-key";
+    path: JsoncPath;
 } | {
     kind: "replace-array-value";
     path: JsoncPath;

package/dist/jsonc.js

@@ -143,6 +143,9 @@ function parseObject(parser) {
             parser.cursor += 1;
             trailingComma = true;
         }
+        else if (next && !(next.type === "punct" && next.raw === "}")) {
+            throw new JsoncError("invalid_jsonc", `Expected comma at offset ${next.start}`);
+        }
     }
     if (!closed)
         throw new JsoncError("invalid_jsonc", `Unterminated object at offset ${open.start}`);
@@ -180,6 +183,9 @@ function parseArray(parser) {
             parser.cursor += 1;
             trailingComma = true;
         }
+        else if (next && !(next.type === "punct" && next.raw === "]")) {
+            throw new JsoncError("invalid_jsonc", `Expected comma at offset ${next.start}`);
+        }
     }
     if (!closed)
         throw new JsoncError("invalid_jsonc", `Unterminated array at offset ${open.start}`);
@@ -200,7 +206,12 @@ export function nodeToValue(node) {
         return node.items.map(nodeToValue);
     const value = {};
     for (const key of node.propOrder)
-        value[key] = nodeToValue(node.props.get(key));
+        Object.defineProperty(value, key, {
+            value: nodeToValue(node.props.get(key)),
+            writable: true,
+            configurable: true,
+            enumerable: true,
+        });
     return value;
 }
 function parseDocument(text) {
@@ -278,11 +289,62 @@ function requireObjectPath(text, root, path) {
     return { text: currentText, node };
 }
 function applyEdit(text, root, edit) {
+    if (edit.kind === "rename-key" || edit.kind === "remove-key") {
+        const key = edit.path.at(-1);
+        const parent = resolve(root, edit.path.slice(0, -1));
+        if (typeof key !== "string" || !parent || parent.kind !== "object")
+            throw new JsoncError("conflict", "Key edit requires an object parent");
+        const target = parent.props.get(key);
+        if (!target)
+            return { text, result: "present" };
+        const index = parent.propOrder.indexOf(key);
+        const previous = index ? parent.props.get(parent.propOrder[index - 1]) : undefined;
+        const tokens = tokenize(text).filter((token) => token.start >= (previous?.end ?? parent.start + 1) && token.end <= target.start);
+        const keyToken = tokens.find((token) => token.type === "string");
+        if (!keyToken)
+            throw new JsoncError("conflict", "Object key token is unavailable");
+        if (edit.kind === "rename-key") {
+            if (parent.props.has(edit.to))
+                throw new JsoncError("conflict", `Destination key already exists: ${edit.to}`);
+            return {
+                text: text.slice(0, keyToken.start) + JSON.stringify(edit.to) + text.slice(keyToken.end),
+                result: "replaced",
+            };
+        }
+        const following = tokenize(text).find((token) => token.start >= target.end && token.type !== "ws" && token.type !== "comment");
+        const start = following?.raw === "," || !previous ? keyToken.start : previous.end;
+        const end = following?.raw === "," ? following.end : target.end;
+        const comments = tokenize(text.slice(start, end))
+            .filter((token) => token.type === "comment")
+            .map((token) => `${token.raw}\n`)
+            .join("");
+        return { text: text.slice(0, start) + comments + text.slice(end), result: "replaced" };
+    }
+    if (edit.kind === "set-value") {
+        const target = resolve(root, edit.path);
+        if (!target)
+            return applyEdit(text, root, { ...edit, kind: "set-if-absent" });
+        if (JSON.stringify(nodeToValue(target)) === JSON.stringify(edit.value))
+            return { text, result: "present" };
+        const comments = tokenize(text.slice(target.start, target.end))
+            .filter((token) => token.type === "comment")
+            .map((token) => `${token.raw}\n${lineIndent(text, target.start)}`)
+            .join("");
+        return {
+            text: text.slice(0, target.start) +
+                comments +
+                serialize(edit.value, lineIndent(text, target.start)) +
+                text.slice(target.end),
+            result: "replaced",
+        };
+    }
     if (edit.kind === "append-unique") {
         const target = resolve(root, edit.path);
         if (!target || target.kind !== "array")
             throw new JsoncError("conflict", "append-unique target is missing or not an array");
-        if (target.items.map(nodeToValue).includes(edit.value))
+        if (target.items
+            .map(nodeToValue)
+            .some((value) => JSON.stringify(value) === JSON.stringify(edit.value)))
             return { text, result: "present" };
         const insertion = target.empty ? JSON.stringify(edit.value) : `, ${JSON.stringify(edit.value)}`;
         const at = target.empty ? target.start + 1 : target.items.at(-1).end;
@@ -369,9 +431,24 @@ function at(value, path) {
         : undefined, value);
 }
 function verifyEdit(before, after, edit) {
+    if (edit.kind === "set-value") {
+        if (JSON.stringify(at(after, edit.path)) !== JSON.stringify(edit.value))
+            throw new JsoncError("merge_validation_failed", "set-value postcondition failed");
+        return;
+    }
+    if (edit.kind === "rename-key" || edit.kind === "remove-key") {
+        if (at(after, edit.path) !== undefined)
+            throw new JsoncError("merge_validation_failed", "Old key remains after key edit");
+        if (edit.kind === "rename-key" &&
+            JSON.stringify(at(before, edit.path)) !==
+                JSON.stringify(at(after, [...edit.path.slice(0, -1), edit.to])))
+            throw new JsoncError("merge_validation_failed", "Renamed key lost its value");
+        return;
+    }
     if (edit.kind === "append-unique") {
         const target = at(after, edit.path);
-        if (!Array.isArray(target) || !target.includes(edit.value))
+        if (!Array.isArray(target) ||
+            !target.some((value) => JSON.stringify(value) === JSON.stringify(edit.value)))
             throw new JsoncError("merge_validation_failed", "append-unique postcondition failed");
         return;
     }
@@ -419,12 +496,12 @@ function verifyEdit(before, after, edit) {
         throw new JsoncError("merge_validation_failed", "widened map lost the original scalar value");
 }
 export function applyJsoncEdits(text, edits) {
-    const before = parseJsonc(text);
+    parseJsonc(text);
     let current = text;
     const results = [];
     for (const edit of edits) {
         const applied = applyEdit(current, parseDocument(current), edit);
-        verifyEdit(before, parseJsonc(applied.text), edit);
+        verifyEdit(parseJsonc(current), parseJsonc(applied.text), edit);
         results.push(applied.result);
         current = applied.text;
     }

package/dist/opencode-config.d.ts

@@ -0,0 +1,9 @@
+import { type JsoncEdit } from "./jsonc.js";
+export type PermissionRule = {
+    action: string;
+    resource: string;
+    effect: "allow" | "ask" | "deny";
+};
+export declare function permissionEdits(config: Record<string, unknown>, additions: PermissionRule[]): JsoncEdit[];
+export declare function matchesWildcard(pattern: string, value: string): boolean;
+export declare function corePluginEdits(config: Record<string, unknown>): JsoncEdit[];

package/dist/opencode-config.js

@@ -0,0 +1,136 @@
+import { JsoncError } from "./jsonc.js";
+const effects = new Set(["allow", "ask", "deny"]);
+const aliases = {
+    bash: "shell",
+    task: "subagent",
+    write: "edit",
+    patch: "edit",
+};
+function object(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function legacyPermissions(value) {
+    if (typeof value === "string" && effects.has(value))
+        return [{ action: "*", resource: "*", effect: value }];
+    if (!object(value))
+        throw new JsoncError("conflict", "Legacy permission must be an effect or a tool map");
+    return Object.entries(value).flatMap(([name, entry]) => {
+        if (name === "lsp" || name === "doom_loop")
+            throw new JsoncError("conflict", `Permission action has no V2 equivalent: ${name}`);
+        const action = aliases[name] ?? name;
+        const resources = typeof entry === "string" ? { "*": entry } : entry;
+        if (!object(resources))
+            throw new JsoncError("conflict", `Invalid permission map: ${name}`);
+        return Object.entries(resources).map(([resource, effect]) => {
+            if (typeof effect !== "string" || !effects.has(effect))
+                throw new JsoncError("conflict", `Invalid permission effect: ${name}`);
+            return { action, resource, effect: effect };
+        });
+    });
+}
+export function permissionEdits(config, additions) {
+    const edits = [];
+    let rules = [];
+    if ("permissions" in config) {
+        if (!Array.isArray(config.permissions) ||
+            !config.permissions.every((rule) => object(rule) &&
+                typeof rule.action === "string" &&
+                typeof rule.resource === "string" &&
+                typeof rule.effect === "string" &&
+                effects.has(rule.effect)))
+            throw new JsoncError("conflict", "V2 permissions must be an ordered array of action/resource/effect rules");
+        rules = config.permissions;
+    }
+    let tools = [];
+    if ("tools" in config) {
+        if (!object(config.tools) ||
+            !Object.values(config.tools).every((value) => typeof value === "boolean"))
+            throw new JsoncError("conflict", "Legacy tools must be a boolean map");
+        tools = Object.entries(config.tools).map(([name, enabled]) => ({
+            action: aliases[name] ?? name,
+            resource: "*",
+            effect: enabled ? "allow" : "deny",
+        }));
+    }
+    const legacyKeys = ["tools", "permission"].filter((key) => key in config);
+    if (legacyKeys.length) {
+        // V2 normalizes tools first, legacy permission next, and native rules last.
+        rules = [
+            ...tools,
+            ...("permission" in config ? legacyPermissions(config.permission) : []),
+            ...rules,
+        ];
+        const renamed = "permissions" in config ? undefined : legacyKeys[0];
+        for (const key of legacyKeys)
+            edits.push(key === renamed
+                ? { kind: "rename-key", path: [key], to: "permissions" }
+                : { kind: "remove-key", path: [key] });
+        edits.push({ kind: "set-value", path: ["permissions"], value: rules });
+    }
+    else if (!("permissions" in config))
+        edits.push({ kind: "set-if-absent", path: ["permissions"], value: [] });
+    for (const rule of additions) {
+        const exact = rules.reduce((last, existing, index) => existing.action === rule.action && existing.resource === rule.resource ? index : last, -1);
+        if (exact >= 0) {
+            if (rules[exact].effect !== rule.effect ||
+                rules
+                    .slice(exact + 1)
+                    .some((later) => matchesWildcard(later.action, rule.action) &&
+                    matchesWildcard(later.resource, rule.resource) &&
+                    later.effect !== rule.effect))
+                throw new JsoncError("conflict", `Existing permission conflicts with preset: ${rule.action} ${rule.resource}`);
+            continue;
+        }
+        edits.push({ kind: "append-unique", path: ["permissions"], value: rule });
+        rules = [...rules, rule];
+    }
+    return edits;
+}
+export function matchesWildcard(pattern, value) {
+    return new RegExp(`^${pattern
+        .replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+        .replace(/\\\*/g, ".*")
+        .replace(/\\\?/g, ".")}$`).test(value);
+}
+function plugins(value, legacy) {
+    if (!Array.isArray(value))
+        throw new JsoncError("conflict", "Plugin configuration must be an array");
+    return value.map((entry) => {
+        if (typeof entry === "string")
+            return entry === "@kisev/skills-opencode" ? "@kisev/agentomatic" : entry;
+        if (legacy &&
+            Array.isArray(entry) &&
+            entry.length === 2 &&
+            typeof entry[0] === "string" &&
+            object(entry[1]))
+            return {
+                package: entry[0] === "@kisev/skills-opencode" ? "@kisev/agentomatic" : entry[0],
+                options: entry[1],
+            };
+        if (object(entry) && typeof entry.package === "string")
+            return {
+                ...entry,
+                package: entry.package === "@kisev/skills-opencode" ? "@kisev/agentomatic" : entry.package,
+            };
+        throw new JsoncError("conflict", "Invalid plugin entry; use a package string or V2 package/options object");
+    });
+}
+export function corePluginEdits(config) {
+    const edits = [
+        { kind: "set-if-absent", path: ["$schema"], value: "https://opencode.ai/config.json" },
+    ];
+    const native = "plugins" in config ? plugins(config.plugins, false) : undefined;
+    const legacy = "plugin" in config ? plugins(config.plugin, true) : undefined;
+    if (native && legacy) {
+        if (JSON.stringify(native) !== JSON.stringify(legacy))
+            throw new JsoncError("conflict", "Conflicting plugin and plugins sections; migrate explicitly before config setup");
+        edits.push({ kind: "remove-key", path: ["plugin"] });
+    }
+    else if (legacy)
+        edits.push({ kind: "rename-key", path: ["plugin"], to: "plugins" });
+    const entries = native ?? legacy ?? [];
+    if (!entries.some((entry) => entry === "@kisev/agentomatic" || (object(entry) && entry.package === "@kisev/agentomatic")))
+        entries.push("@kisev/agentomatic");
+    edits.push({ kind: "set-value", path: ["plugins"], value: entries });
+    return edits;
+}

package/dist/plugins/events.d.ts

@@ -0,0 +1,20 @@
+import type { Plugin } from "@opencode/plugin";
+import type { Result } from "@opencode/plugin/promise/tool";
+export type ToolAfter = {
+    tool: string;
+    sessionID: string;
+    input: unknown;
+} & ({
+    status: "completed";
+    result: Result;
+} | {
+    status: "error";
+    error: unknown;
+});
+export declare function toolInput(value: unknown): Record<string, unknown>;
+export declare function resultText(result: Result): string | undefined;
+export declare function replaceResultText(result: Result, text: string): Result;
+export declare function subscribeEvents(ctx: Plugin.Context, receive: (event: {
+    type: string;
+    data?: unknown;
+}) => Promise<void>): () => Promise<void>;

package/dist/plugins/events.js

@@ -0,0 +1,48 @@
+export function toolInput(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+export function resultText(result) {
+    if (typeof result.content === "string")
+        return result.content;
+    if (Array.isArray(result.content))
+        return result.content
+            .filter((part) => part.type === "text")
+            .map((part) => part.text)
+            .join("\n");
+    return undefined;
+}
+export function replaceResultText(result, text) {
+    if (!Array.isArray(result.content))
+        return { ...result, content: text };
+    let replaced = false;
+    return {
+        ...result,
+        content: result.content.flatMap((part) => {
+            if (part.type !== "text")
+                return [part];
+            if (replaced)
+                return [];
+            replaced = true;
+            return [{ type: "text", text }];
+        }),
+    };
+}
+export function subscribeEvents(ctx, receive) {
+    const controller = new AbortController();
+    const subscription = (async () => {
+        try {
+            for await (const event of ctx.event.subscribe({ signal: controller.signal }))
+                await receive(event);
+        }
+        catch (error) {
+            if (!controller.signal.aborted)
+                console.error("agentomatic event subscription failed", error);
+        }
+    })();
+    return async () => {
+        controller.abort();
+        await subscription;
+    };
+}