@arcanemachine/inter-agent-opencode 0.1.0

package/dist/protocol.d.ts

@@ -0,0 +1,132 @@
+import { type ProtocolErrorCode } from "./errors.js";
+export declare const AUTH_METHOD = "hmac-sha256";
+export declare const SERVER_PROOF_DOMAIN = "inter-agent/server-proof/v1";
+export declare const CLIENT_PROOF_DOMAIN = "inter-agent/client-proof/v1";
+export declare const DEFAULT_DIRECT_TEXT_MAX: number;
+export declare const DEFAULT_BROADCAST_TEXT_MAX: number;
+export type JsonObject = Record<string, unknown>;
+export type ProtocolFrame = JsonObject & {
+    op: string;
+};
+export type Hello = ProtocolFrame & {
+    op: "hello";
+    auth: {
+        method: typeof AUTH_METHOD;
+        client_nonce: string;
+    };
+    role: "agent" | "control";
+    session_id: string;
+    name?: string;
+    label: string | null;
+    capabilities: JsonObject;
+};
+export type AuthChallenge = ProtocolFrame & {
+    op: "auth_challenge";
+    method: typeof AUTH_METHOD;
+    server_nonce: string;
+    server_proof: string;
+};
+export type AuthResponse = ProtocolFrame & {
+    op: "auth_response";
+    client_proof: string;
+};
+export type Welcome = ProtocolFrame & {
+    op: "welcome";
+    session_id: string;
+    assigned_name: string;
+    capabilities: JsonObject;
+};
+export type Message = ProtocolFrame & {
+    op: "msg";
+    msg_id: string;
+    from: string;
+    from_name: string;
+    ts: string;
+    to?: string | null;
+    channel?: string;
+    text?: string;
+    custom_type?: string;
+    payload?: unknown;
+};
+export type ProtocolErrorFrame = ProtocolFrame & {
+    op: "error";
+    code: ProtocolErrorCode;
+    message: string;
+};
+export type SendFrame = ProtocolFrame & {
+    op: "send";
+    to: string;
+    text: string;
+    from_name?: string;
+};
+export type BroadcastFrame = ProtocolFrame & {
+    op: "broadcast";
+    text: string;
+    from_name?: string;
+};
+export type ListFrame = ProtocolFrame & {
+    op: "list";
+};
+export type SessionInfo = {
+    session_id: string;
+    name: string;
+    label: string | null;
+};
+export type ListOkFrame = ProtocolFrame & {
+    op: "list_ok";
+    sessions: SessionInfo[];
+};
+export declare function generateNonce(): string;
+export declare function buildHello(input: {
+    role: "agent" | "control";
+    sessionId: string;
+    name?: string;
+    label?: string | null;
+    capabilities?: JsonObject;
+    clientNonce?: string;
+}): Hello;
+export declare function canonicalHelloTranscript(hello: JsonObject): string;
+export declare function canonicalJson(value: unknown): string;
+export declare function hmacProof(secret: string, domain: string, input: {
+    clientNonce: string;
+    serverNonce: string;
+    hello: JsonObject;
+}): string;
+export declare function serverProof(secret: string, input: {
+    clientNonce: string;
+    serverNonce: string;
+    hello: JsonObject;
+}): string;
+export declare function clientProof(secret: string, input: {
+    clientNonce: string;
+    serverNonce: string;
+    hello: JsonObject;
+}): string;
+export declare function verifyProof(actual: string, expected: string): boolean;
+export declare function verifyServerProof(proof: string, secret: string, input: {
+    clientNonce: string;
+    serverNonce: string;
+    hello: JsonObject;
+}): boolean;
+export declare function verifyClientProof(proof: string, secret: string, input: {
+    clientNonce: string;
+    serverNonce: string;
+    hello: JsonObject;
+}): boolean;
+export declare function buildAuthResponse(secret: string, input: {
+    clientNonce: string;
+    serverNonce: string;
+    hello: JsonObject;
+}): AuthResponse;
+export declare function validateName(value: unknown): value is string;
+export declare function utf8ByteLength(value: string): number;
+export declare function validateText(value: unknown, maxBytes: number): value is string;
+export declare function decodeFrame(data: unknown): string;
+export declare function parseFrame(data: unknown): ProtocolFrame;
+export declare function parseHello(frame: ProtocolFrame): Hello;
+export declare function parseAuthChallenge(frame: ProtocolFrame): AuthChallenge;
+export declare function parseWelcome(frame: ProtocolFrame): Welcome;
+export declare function parseError(frame: ProtocolFrame): ProtocolErrorFrame;
+export declare function parseListOk(frame: ProtocolFrame): ListOkFrame;
+export declare function parseMessage(frame: ProtocolFrame): Message;
+export declare function isRecord(value: unknown): value is JsonObject;

package/dist/protocol.js

@@ -0,0 +1,255 @@
+import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
+import { TextDecoder } from "node:util";
+import { ProtocolError, isProtocolErrorCode, } from "./errors.js";
+export const AUTH_METHOD = "hmac-sha256";
+export const SERVER_PROOF_DOMAIN = "inter-agent/server-proof/v1";
+export const CLIENT_PROOF_DOMAIN = "inter-agent/client-proof/v1";
+export const DEFAULT_DIRECT_TEXT_MAX = 2 * 1024 * 1024;
+export const DEFAULT_BROADCAST_TEXT_MAX = 512 * 1024;
+const decoder = new TextDecoder("utf-8", { fatal: true });
+export function generateNonce() {
+    return randomBytes(32).toString("base64url");
+}
+export function buildHello(input) {
+    const hello = {
+        op: "hello",
+        auth: {
+            method: AUTH_METHOD,
+            client_nonce: input.clientNonce ?? generateNonce(),
+        },
+        role: input.role,
+        session_id: input.sessionId,
+        label: input.label ?? null,
+        capabilities: input.capabilities ?? {},
+    };
+    if (input.name !== undefined)
+        hello.name = input.name;
+    return hello;
+}
+export function canonicalHelloTranscript(hello) {
+    return canonicalJson({
+        capabilities: isRecord(hello.capabilities) ? hello.capabilities : {},
+        label: hello.label ?? null,
+        name: hello.name ?? null,
+        role: hello.role ?? null,
+        session_id: hello.session_id ?? null,
+    });
+}
+function compareUnicodeKeys(left, right) {
+    const leftCodePoints = Array.from(left, (character) => character.codePointAt(0) ?? 0);
+    const rightCodePoints = Array.from(right, (character) => character.codePointAt(0) ?? 0);
+    const length = Math.min(leftCodePoints.length, rightCodePoints.length);
+    for (let index = 0; index < length; index += 1) {
+        const leftCodePoint = leftCodePoints[index] ?? 0;
+        const rightCodePoint = rightCodePoints[index] ?? 0;
+        if (leftCodePoint !== rightCodePoint)
+            return leftCodePoint - rightCodePoint;
+    }
+    return leftCodePoints.length - rightCodePoints.length;
+}
+export function canonicalJson(value) {
+    if (value === undefined)
+        return "null";
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "boolean" ||
+        typeof value === "number") {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value))
+        return `[${value.map((item) => canonicalJson(item)).join(",")}]`;
+    if (isRecord(value)) {
+        return `{${Object.keys(value)
+            .sort(compareUnicodeKeys)
+            .map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`)
+            .join(",")}}`;
+    }
+    return "null";
+}
+function proofMessage(domain, clientNonce, serverNonce, hello) {
+    return `${domain}\n${clientNonce}\n${serverNonce}\n${canonicalHelloTranscript(hello)}`;
+}
+export function hmacProof(secret, domain, input) {
+    return createHmac("sha256", secret)
+        .update(proofMessage(domain, input.clientNonce, input.serverNonce, input.hello), "utf8")
+        .digest("hex");
+}
+export function serverProof(secret, input) {
+    return hmacProof(secret, SERVER_PROOF_DOMAIN, input);
+}
+export function clientProof(secret, input) {
+    return hmacProof(secret, CLIENT_PROOF_DOMAIN, input);
+}
+export function verifyProof(actual, expected) {
+    const left = Buffer.from(actual, "utf8");
+    const right = Buffer.from(expected, "utf8");
+    return left.length === right.length && timingSafeEqual(left, right);
+}
+export function verifyServerProof(proof, secret, input) {
+    return verifyProof(proof, serverProof(secret, input));
+}
+export function verifyClientProof(proof, secret, input) {
+    return verifyProof(proof, clientProof(secret, input));
+}
+export function buildAuthResponse(secret, input) {
+    return { op: "auth_response", client_proof: clientProof(secret, input) };
+}
+export function validateName(value) {
+    return typeof value === "string" && /^[a-z0-9][a-z0-9-]{0,39}$/.test(value);
+}
+export function utf8ByteLength(value) {
+    return Buffer.byteLength(value, "utf8");
+}
+export function validateText(value, maxBytes) {
+    return typeof value === "string" && utf8ByteLength(value) <= maxBytes;
+}
+export function decodeFrame(data) {
+    try {
+        if (typeof data === "string")
+            return data;
+        if (data instanceof ArrayBuffer)
+            return decoder.decode(new Uint8Array(data));
+        if (ArrayBuffer.isView(data))
+            return decoder.decode(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+    }
+    catch {
+        throw new ProtocolError("websocket frame is not valid UTF-8");
+    }
+    throw new ProtocolError("websocket frame must be UTF-8 text or binary data");
+}
+export function parseFrame(data) {
+    let parsed;
+    try {
+        parsed = JSON.parse(decodeFrame(data));
+    }
+    catch {
+        throw new ProtocolError("websocket frame is not valid UTF-8 JSON");
+    }
+    if (!isRecord(parsed) || typeof parsed.op !== "string")
+        throw new ProtocolError("protocol frame must be a JSON object with op");
+    return parsed;
+}
+export function parseHello(frame) {
+    if (frame.op !== "hello" ||
+        !isRecord(frame.auth) ||
+        frame.auth.method !== AUTH_METHOD ||
+        typeof frame.auth.client_nonce !== "string" ||
+        !frame.auth.client_nonce) {
+        throw new ProtocolError("invalid hello frame");
+    }
+    if (frame.role !== "agent" && frame.role !== "control")
+        throw new ProtocolError("invalid hello role");
+    if (typeof frame.session_id !== "string" || !frame.session_id)
+        throw new ProtocolError("invalid hello session_id");
+    if (frame.role === "agent" && !validateName(frame.name))
+        throw new ProtocolError("invalid hello name");
+    if (frame.name !== undefined && typeof frame.name !== "string")
+        throw new ProtocolError("invalid hello name");
+    if (frame.label !== undefined &&
+        frame.label !== null &&
+        typeof frame.label !== "string")
+        throw new ProtocolError("invalid hello label");
+    if (!isRecord(frame.capabilities))
+        throw new ProtocolError("invalid hello capabilities");
+    return {
+        ...frame,
+        label: frame.label === undefined ? null : frame.label,
+        capabilities: frame.capabilities,
+    };
+}
+export function parseAuthChallenge(frame) {
+    if (frame.op !== "auth_challenge" ||
+        frame.method !== AUTH_METHOD ||
+        typeof frame.server_nonce !== "string" ||
+        !frame.server_nonce ||
+        typeof frame.server_proof !== "string" ||
+        !frame.server_proof) {
+        throw new ProtocolError("invalid auth challenge");
+    }
+    return frame;
+}
+export function parseWelcome(frame) {
+    if (frame.op !== "welcome" ||
+        typeof frame.session_id !== "string" ||
+        typeof frame.assigned_name !== "string" ||
+        !isRecord(frame.capabilities)) {
+        throw new ProtocolError("invalid welcome frame");
+    }
+    const core = frame.capabilities.core;
+    if (!isRecord(core) ||
+        core.version !== "0.1" ||
+        frame.capabilities.channels !== true ||
+        frame.capabilities.rate_limit !== false) {
+        throw new ProtocolError("invalid welcome capabilities");
+    }
+    return frame;
+}
+export function parseError(frame) {
+    if (frame.op !== "error" ||
+        !isProtocolErrorCode(frame.code) ||
+        typeof frame.message !== "string")
+        throw new ProtocolError("invalid protocol error frame");
+    return frame;
+}
+export function parseListOk(frame) {
+    if (frame.op !== "list_ok" || !Array.isArray(frame.sessions))
+        throw new ProtocolError("invalid list response");
+    const sessions = frame.sessions.map((value) => {
+        if (!isRecord(value) ||
+            typeof value.session_id !== "string" ||
+            typeof value.name !== "string" ||
+            (value.label !== null && typeof value.label !== "string")) {
+            throw new ProtocolError("invalid list session");
+        }
+        return {
+            session_id: value.session_id,
+            name: value.name,
+            label: value.label,
+        };
+    });
+    return { ...frame, sessions };
+}
+export function parseMessage(frame) {
+    if (frame.op !== "msg" ||
+        typeof frame.msg_id !== "string" ||
+        typeof frame.from !== "string" ||
+        typeof frame.from_name !== "string" ||
+        typeof frame.ts !== "string") {
+        throw new ProtocolError("invalid message frame");
+    }
+    if ("to" in frame && frame.to !== null && typeof frame.to !== "string")
+        throw new ProtocolError("invalid message target");
+    if ("channel" in frame &&
+        (typeof frame.channel !== "string" || !validateName(frame.channel)))
+        throw new ProtocolError("invalid message channel");
+    const hasText = "text" in frame;
+    const hasCustom = "custom_type" in frame || "payload" in frame;
+    if (hasText === hasCustom)
+        throw new ProtocolError("message must contain exactly one payload form");
+    if (hasText && typeof frame.text !== "string")
+        throw new ProtocolError("invalid message text");
+    if (hasCustom) {
+        if (typeof frame.custom_type !== "string" || frame.custom_type.length === 0)
+            throw new ProtocolError("invalid custom message type");
+        if (!("payload" in frame))
+            throw new ProtocolError("custom message payload is missing");
+        if (!isJsonValue(frame.payload))
+            throw new ProtocolError("invalid custom message payload");
+    }
+    return frame;
+}
+function isJsonValue(value) {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return true;
+    if (typeof value === "number")
+        return Number.isFinite(value);
+    if (Array.isArray(value))
+        return value.every((item) => isJsonValue(item));
+    if (isRecord(value))
+        return Object.values(value).every((item) => isJsonValue(item));
+    return false;
+}
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=protocol.js.map

package/dist/server.d.ts

@@ -0,0 +1,49 @@
+import type { PluginModule } from "@opencode-ai/plugin";
+import { type ToolContext, type ToolResult } from "@opencode-ai/plugin";
+import { type WebSocketFactory } from "./client.js";
+type ServerToolOptions = {
+    websocketFactory?: WebSocketFactory;
+};
+export declare function createServerTools(options?: ServerToolOptions): {
+    inter_agent_send: {
+        description: string;
+        args: {
+            to: import("zod").ZodString;
+            text: import("zod").ZodString;
+        };
+        execute(args: {
+            to: string;
+            text: string;
+        }, context: ToolContext): Promise<ToolResult>;
+    };
+    inter_agent_broadcast: {
+        description: string;
+        args: {
+            text: import("zod").ZodString;
+        };
+        execute(args: {
+            text: string;
+        }, context: ToolContext): Promise<ToolResult>;
+    };
+    inter_agent_list: {
+        description: string;
+        args: {};
+        execute(args: Record<string, never>, context: ToolContext): Promise<ToolResult>;
+    };
+    inter_agent_status: {
+        description: string;
+        args: {};
+        execute(args: Record<string, never>, context: ToolContext): Promise<ToolResult>;
+    };
+    inter_agent_read_messages: {
+        description: string;
+        args: {
+            count: import("zod").ZodOptional<import("zod").ZodNumber>;
+        };
+        execute(args: {
+            count?: number | undefined;
+        }, context: ToolContext): Promise<ToolResult>;
+    };
+};
+declare const server: PluginModule;
+export default server;

package/dist/server.js

@@ -0,0 +1,231 @@
+import { tool } from "@opencode-ai/plugin";
+import { assertSupportedEndpoint, resolveEndpoint, resolveSecret, } from "./config.js";
+import { broadcast, listSessions, sendDirect, } from "./client.js";
+import { DEFAULT_BROADCAST_TEXT_MAX, DEFAULT_DIRECT_TEXT_MAX, validateName, validateText, } from "./protocol.js";
+import { canonicalWorkspacePath, hashScope, readPreferences, resolveLease, workspaceKey, } from "./state.js";
+import { readInboxFile } from "./inbox.js";
+const DEFAULT_INBOX_COUNT = 20;
+const MAX_INBOX_COUNT = 100;
+function result(title, value, metadata = {}) {
+    return {
+        title,
+        output: JSON.stringify(value),
+        metadata,
+    };
+}
+function contextWorkspacePath(context) {
+    const path = context.worktree || context.directory;
+    if (!path)
+        throw new Error("OpenCode project scope is unavailable");
+    return canonicalWorkspacePath(path);
+}
+function scopeFor(context, endpoint) {
+    const workspacePath = contextWorkspacePath(context);
+    return {
+        endpoint,
+        workspacePath,
+        workspaceHash: workspaceKey(workspacePath),
+        sessionHash: hashScope(context.sessionID),
+        sessionID: context.sessionID,
+    };
+}
+function exactLease(lease, scope) {
+    return (lease.workspacePath === scope.workspacePath &&
+        lease.workspaceHash === scope.workspaceHash &&
+        lease.openCodeSessionID === scope.sessionID &&
+        lease.sessionHash === scope.sessionHash &&
+        lease.host === scope.endpoint.host &&
+        lease.port === scope.endpoint.port &&
+        lease.tls === scope.endpoint.tls &&
+        validateName(lease.name));
+}
+function unavailableSession() {
+    return new Error("this OpenCode session is disconnected or unavailable; connect it before using inter-agent messaging");
+}
+function preferenceMatchesLease(preferences, lease) {
+    return (!preferences ||
+        (preferences.name === lease.name && preferences.label === lease.label));
+}
+async function sessionScope(context) {
+    return scopeFor(context, await resolveEndpoint());
+}
+async function callerScope(context) {
+    const scope = await sessionScope(context);
+    assertSupportedEndpoint(scope.endpoint);
+    const resolution = resolveLease(scope.endpoint.dataDir, {
+        workspacePath: scope.workspacePath,
+        openCodeSessionID: scope.sessionID,
+    });
+    if (resolution.check !== "fresh" ||
+        !resolution.lease ||
+        !exactLease(resolution.lease, scope))
+        throw unavailableSession();
+    const preferences = readPreferences(scope.endpoint.dataDir, scope.workspaceHash, scope.sessionHash, {
+        workspacePath: scope.workspacePath,
+        openCodeSessionID: scope.sessionID,
+    });
+    if (!preferenceMatchesLease(preferences, resolution.lease))
+        throw unavailableSession();
+    return { ...scope, lease: resolution.lease };
+}
+function operationOptions(context, endpoint, options) {
+    return {
+        endpoint,
+        secret: resolveSecret().secret,
+        signal: context.abort,
+        websocketFactory: options.websocketFactory,
+    };
+}
+function validateCount(count) {
+    const value = count === undefined ? DEFAULT_INBOX_COUNT : count;
+    if (typeof value !== "number" ||
+        !Number.isInteger(value) ||
+        value < 1 ||
+        value > MAX_INBOX_COUNT)
+        throw new Error("count must be an integer between 1 and 100");
+    return value;
+}
+function sessionsValue(sessions) {
+    return {
+        sessions: sessions.map((session) => ({
+            session_id: session.session_id,
+            name: session.name,
+            label: session.label,
+        })),
+    };
+}
+function statusValue(scope, lease, leaseState, server, inboxCount, name, label) {
+    return {
+        endpoint: `${scope.endpoint.host}:${scope.endpoint.port}`,
+        supported: scope.endpoint.supported,
+        server,
+        session: lease ? "connected" : "disconnected",
+        name,
+        label,
+        lease: leaseState,
+        inbox: inboxCount,
+    };
+}
+async function executeSend(args, context, options) {
+    if (!validateName(args.to))
+        throw new Error("to must be a valid inter-agent name");
+    if (typeof args.text !== "string" ||
+        args.text.length === 0 ||
+        !validateText(args.text, DEFAULT_DIRECT_TEXT_MAX))
+        throw new Error("text is empty or exceeds the direct message limit");
+    const caller = await callerScope(context);
+    await sendDirect(args.to, args.text, caller.lease.name, operationOptions(context, caller.endpoint, options));
+    return result("Inter-agent message sent", {
+        sent: true,
+        to: args.to,
+        from_name: caller.lease.name,
+    });
+}
+async function executeBroadcast(args, context, options) {
+    if (typeof args.text !== "string" ||
+        args.text.length === 0 ||
+        !validateText(args.text, DEFAULT_BROADCAST_TEXT_MAX))
+        throw new Error("text is empty or exceeds the broadcast message limit");
+    const caller = await callerScope(context);
+    await broadcast(args.text, caller.lease.name, operationOptions(context, caller.endpoint, options));
+    return result("Inter-agent broadcast sent", {
+        sent: true,
+        from_name: caller.lease.name,
+    });
+}
+async function executeList(context, options) {
+    const scope = await sessionScope(context);
+    assertSupportedEndpoint(scope.endpoint);
+    const listed = await listSessions(operationOptions(context, scope.endpoint, options));
+    return result("Inter-agent sessions", sessionsValue(listed.sessions), {
+        count: listed.sessions.length,
+    });
+}
+async function executeStatus(context, options) {
+    const scope = await sessionScope(context);
+    const resolution = resolveLease(scope.endpoint.dataDir, {
+        workspacePath: scope.workspacePath,
+        openCodeSessionID: scope.sessionID,
+    });
+    const preferences = readPreferences(scope.endpoint.dataDir, scope.workspaceHash, scope.sessionHash, {
+        workspacePath: scope.workspacePath,
+        openCodeSessionID: scope.sessionID,
+    });
+    const lease = resolution.check === "fresh" &&
+        resolution.lease &&
+        exactLease(resolution.lease, scope) &&
+        preferenceMatchesLease(preferences, resolution.lease)
+        ? resolution.lease
+        : undefined;
+    let server = "unreachable";
+    if (scope.endpoint.supported) {
+        try {
+            await listSessions(operationOptions(context, scope.endpoint, options));
+            server = "reachable";
+        }
+        catch {
+            server = "unreachable";
+        }
+    }
+    const inboxCount = readInboxFile(scope.endpoint.dataDir, scope.workspaceHash, scope.sessionHash).messages.length;
+    const value = statusValue(scope, lease, lease ? "fresh" : resolution.check, server, inboxCount, lease?.name ?? preferences?.name ?? null, lease?.label ?? preferences?.label ?? null);
+    return result("Inter-agent status", value, {
+        session: value.session,
+    });
+}
+async function executeInbox(args, context) {
+    const count = validateCount(args.count);
+    const scope = await sessionScope(context);
+    const messages = readInboxFile(scope.endpoint.dataDir, scope.workspaceHash, scope.sessionHash).messages.slice(-count);
+    return result("Inter-agent inbox", { messages }, { count: messages.length });
+}
+export function createServerTools(options = {}) {
+    return {
+        inter_agent_send: tool({
+            description: "Send a direct inter-agent message from this OpenCode session.",
+            args: {
+                to: tool.schema.string().describe("Recipient agent name"),
+                text: tool.schema.string().describe("Message text"),
+            },
+            execute: (args, context) => executeSend(args, context, options),
+        }),
+        inter_agent_broadcast: tool({
+            description: "Broadcast an inter-agent message to everyone only when explicitly requested.",
+            args: {
+                text: tool.schema.string().describe("Message text"),
+            },
+            execute: (args, context) => executeBroadcast(args, context, options),
+        }),
+        inter_agent_list: tool({
+            description: "List currently connected inter-agent sessions.",
+            args: {},
+            execute: (_args, context) => executeList(context, options),
+        }),
+        inter_agent_status: tool({
+            description: "Show inter-agent status for this exact OpenCode session.",
+            args: {},
+            execute: (_args, context) => executeStatus(context, options),
+        }),
+        inter_agent_read_messages: tool({
+            description: "Read this exact OpenCode session's durable inter-agent inbox.",
+            args: {
+                count: tool.schema
+                    .number()
+                    .int()
+                    .min(1)
+                    .max(MAX_INBOX_COUNT)
+                    .optional()
+                    .describe("Maximum messages to return (1-100)"),
+            },
+            execute: (args, context) => executeInbox(args, context),
+        }),
+    };
+}
+const server = {
+    id: "inter-agent",
+    async server(_input) {
+        return { tool: createServerTools() };
+    },
+};
+export default server;
+//# sourceMappingURL=server.js.map