315 lines
10 KiB
TypeScript
315 lines
10 KiB
TypeScript
import type {
|
|
AnyAgentTool,
|
|
GatewayRequestHandlerOptions,
|
|
OpenClawPluginApi,
|
|
} from "openclaw/plugin-sdk/core";
|
|
import {
|
|
exportXWorkmateArtifacts,
|
|
prepareXWorkmateArtifacts,
|
|
readXWorkmateArtifact,
|
|
} from "./src/exportArtifacts.js";
|
|
import { runXWorkmateBridgeAgents } from "./src/bridgeAgents.js";
|
|
|
|
type XWorkmateToolContext = {
|
|
config?: unknown;
|
|
workspaceDir?: string;
|
|
sessionKey?: string;
|
|
runId?: string;
|
|
sessionScope?: {
|
|
sessionKey?: string;
|
|
runId?: string;
|
|
workspaceDir?: string;
|
|
};
|
|
};
|
|
|
|
const plugin = {
|
|
id: "openclaw-multi-session-plugins",
|
|
name: "openclaw-multi-session-plugins",
|
|
description: "OpenClaw logical isolation support for multi-session plugin runtimes and scoped XWorkmate artifacts.",
|
|
register,
|
|
};
|
|
|
|
export default plugin;
|
|
|
|
function register(api: OpenClawPluginApi) {
|
|
api.registerGatewayMethod("xworkmate.artifacts.prepare", async (opts: GatewayRequestHandlerOptions) => {
|
|
try {
|
|
const payload = await prepareXWorkmateArtifacts({
|
|
params: opts.params,
|
|
config: api.config,
|
|
pluginConfig: api.pluginConfig,
|
|
});
|
|
opts.respond(true, payload, undefined);
|
|
} catch (error) {
|
|
opts.respond(false, undefined, {
|
|
code: "INVALID_REQUEST",
|
|
message: error instanceof Error ? error.message : String(error),
|
|
});
|
|
}
|
|
});
|
|
api.registerGatewayMethod("xworkmate.artifacts.export", async (opts: GatewayRequestHandlerOptions) => {
|
|
try {
|
|
const payload = await exportXWorkmateArtifacts({
|
|
params: opts.params,
|
|
config: api.config,
|
|
pluginConfig: api.pluginConfig,
|
|
});
|
|
opts.respond(true, payload, undefined);
|
|
} catch (error) {
|
|
opts.respond(false, undefined, {
|
|
code: "INVALID_REQUEST",
|
|
message: error instanceof Error ? error.message : String(error),
|
|
});
|
|
}
|
|
});
|
|
api.registerGatewayMethod("xworkmate.artifacts.list", async (opts: GatewayRequestHandlerOptions) => {
|
|
try {
|
|
const payload = await exportXWorkmateArtifacts({
|
|
params: { ...opts.params, includeContent: false },
|
|
config: api.config,
|
|
pluginConfig: api.pluginConfig,
|
|
});
|
|
opts.respond(true, payload, undefined);
|
|
} catch (error) {
|
|
opts.respond(false, undefined, {
|
|
code: "INVALID_REQUEST",
|
|
message: error instanceof Error ? error.message : String(error),
|
|
});
|
|
}
|
|
});
|
|
api.registerGatewayMethod("xworkmate.artifacts.read", async (opts: GatewayRequestHandlerOptions) => {
|
|
try {
|
|
const payload = await readXWorkmateArtifact({
|
|
params: opts.params,
|
|
config: api.config,
|
|
pluginConfig: api.pluginConfig,
|
|
});
|
|
opts.respond(true, payload, undefined);
|
|
} catch (error) {
|
|
opts.respond(false, undefined, {
|
|
code: "INVALID_REQUEST",
|
|
message: error instanceof Error ? error.message : String(error),
|
|
});
|
|
}
|
|
});
|
|
api.registerGatewayMethod("xworkmate.agents.run", async (opts: GatewayRequestHandlerOptions) => {
|
|
try {
|
|
const payload = await runXWorkmateBridgeAgents({
|
|
params: opts.params,
|
|
config: api.config,
|
|
pluginConfig: api.pluginConfig,
|
|
});
|
|
opts.respond(true, payload, undefined);
|
|
} catch (error) {
|
|
opts.respond(false, undefined, {
|
|
code: "INVALID_REQUEST",
|
|
message: error instanceof Error ? error.message : String(error),
|
|
});
|
|
}
|
|
});
|
|
api.registerTool((ctx) => createXWorkmateArtifactsTool(api, ctx), {
|
|
names: ["openclaw_multi_session_artifacts"],
|
|
optional: true,
|
|
});
|
|
api.registerTool((ctx) => createXWorkmateAgentsTool(api, ctx), {
|
|
names: ["openclaw_multi_session_agents"],
|
|
optional: true,
|
|
});
|
|
}
|
|
|
|
function createXWorkmateArtifactsTool(
|
|
api: OpenClawPluginApi,
|
|
ctx: XWorkmateToolContext,
|
|
): AnyAgentTool {
|
|
return {
|
|
name: "openclaw_multi_session_artifacts",
|
|
label: "openclaw-multi-session-plugins",
|
|
description:
|
|
"List generated artifacts in the current OpenClaw workspace or read one small artifact as base64 for XWorkmate.",
|
|
parameters: {
|
|
type: "object",
|
|
additionalProperties: false,
|
|
properties: {
|
|
action: {
|
|
type: "string",
|
|
enum: ["list", "read"],
|
|
description: "Use list to show workspace artifacts, or read to return one small file.",
|
|
},
|
|
relativePath: {
|
|
type: "string",
|
|
description: "Artifact path relative to artifactScope. Required for action=read without artifactRef.",
|
|
},
|
|
artifactScope: {
|
|
type: "string",
|
|
description: "Task artifact scope returned by prepare/export, for example tasks/<session>/<run>.",
|
|
},
|
|
artifactRef: {
|
|
type: "string",
|
|
description: "Plugin-signed artifact reference returned by export/list. Bound to the issuing task scope.",
|
|
},
|
|
sinceUnixMs: {
|
|
type: "number",
|
|
description: "Only list files changed at or after this Unix timestamp in milliseconds.",
|
|
},
|
|
maxFiles: {
|
|
type: "number",
|
|
description: "Maximum number of files to list.",
|
|
},
|
|
maxInlineBytes: {
|
|
type: "number",
|
|
description: "Maximum bytes to inline when reading an artifact.",
|
|
},
|
|
},
|
|
required: ["action"],
|
|
},
|
|
async execute(_id: string, params: Record<string, unknown>) {
|
|
const action = typeof params.action === "string" ? params.action : "";
|
|
const sessionKey = ctx.sessionScope?.sessionKey || ctx.sessionKey;
|
|
const runId = ctx.sessionScope?.runId || ctx.runId || "";
|
|
const workspaceDir = ctx.sessionScope?.workspaceDir || ctx.workspaceDir;
|
|
if (!sessionKey) {
|
|
throw new Error("sessionKey required");
|
|
}
|
|
if (!runId) {
|
|
throw new Error("runId required");
|
|
}
|
|
const {
|
|
sessionKey: _ignoredSessionKey,
|
|
runId: _ignoredRunId,
|
|
workspaceDir: _ignoredWorkspaceDir,
|
|
...operationParams
|
|
} = params;
|
|
const baseParams = {
|
|
...operationParams,
|
|
sessionKey,
|
|
runId,
|
|
...(workspaceDir ? { workspaceDir } : {}),
|
|
};
|
|
if (action === "list") {
|
|
const payload = await exportXWorkmateArtifacts({
|
|
params: { ...baseParams, includeContent: false },
|
|
config: ctx.config ?? api.config,
|
|
pluginConfig: api.pluginConfig,
|
|
});
|
|
return { content: [{ type: "text", text: payload.manifestMarkdown }], details: {} };
|
|
}
|
|
if (action === "read") {
|
|
const payload = await readXWorkmateArtifact({
|
|
params: baseParams,
|
|
config: ctx.config ?? api.config,
|
|
pluginConfig: api.pluginConfig,
|
|
});
|
|
const artifact = payload.artifacts[0];
|
|
const text = artifact
|
|
? [
|
|
payload.manifestMarkdown,
|
|
"",
|
|
artifact.content
|
|
? `Base64 content for \`${artifact.relativePath}\`:\n\n\`\`\`base64\n${artifact.content}\n\`\`\``
|
|
: `\`${artifact.relativePath}\` is larger than maxInlineBytes; use the workspace path to download it directly.`,
|
|
].join("\n")
|
|
: payload.manifestMarkdown;
|
|
return { content: [{ type: "text", text }], details: {} };
|
|
}
|
|
throw new Error("action must be list or read");
|
|
},
|
|
} as unknown as AnyAgentTool;
|
|
}
|
|
|
|
function createXWorkmateAgentsTool(
|
|
api: OpenClawPluginApi,
|
|
ctx: XWorkmateToolContext,
|
|
): AnyAgentTool {
|
|
return {
|
|
name: "openclaw_multi_session_agents",
|
|
label: "XWorkmate multi-agent bridge",
|
|
description:
|
|
"Ask XWorkmate Bridge to coordinate multiple configured agents, then save the result into the current task artifact scope.",
|
|
parameters: {
|
|
type: "object",
|
|
additionalProperties: false,
|
|
properties: {
|
|
taskPrompt: {
|
|
type: "string",
|
|
description: "Overall multi-agent task prompt.",
|
|
},
|
|
mode: {
|
|
type: "string",
|
|
enum: ["sequence", "parallel", "race", "conversation"],
|
|
description: "Multi-agent orchestration mode.",
|
|
},
|
|
steps: {
|
|
type: "array",
|
|
description: "Agent steps. Each item needs providerId and prompt.",
|
|
items: {
|
|
type: "object",
|
|
additionalProperties: false,
|
|
properties: {
|
|
providerId: { type: "string" },
|
|
prompt: { type: "string" },
|
|
outputAs: { type: "string" },
|
|
timeoutMs: { type: "number" },
|
|
},
|
|
required: ["providerId", "prompt"],
|
|
},
|
|
},
|
|
participants: {
|
|
type: "array",
|
|
description: "Conversation participants by providerId.",
|
|
items: { type: "string" },
|
|
},
|
|
maxTurns: {
|
|
type: "number",
|
|
description: "Maximum turns for conversation mode.",
|
|
},
|
|
stopConditions: {
|
|
type: "array",
|
|
description: "Text markers that stop conversation mode.",
|
|
items: { type: "string" },
|
|
},
|
|
timeoutMs: {
|
|
type: "number",
|
|
description: "Overall bridge request timeout.",
|
|
},
|
|
},
|
|
required: ["taskPrompt"],
|
|
},
|
|
async execute(_id: string, params: Record<string, unknown>) {
|
|
const sessionKey = ctx.sessionScope?.sessionKey || ctx.sessionKey;
|
|
const runId = ctx.sessionScope?.runId || ctx.runId || "";
|
|
const workspaceDir = ctx.sessionScope?.workspaceDir || ctx.workspaceDir;
|
|
if (!sessionKey) {
|
|
throw new Error("sessionKey required");
|
|
}
|
|
if (!runId) {
|
|
throw new Error("runId required");
|
|
}
|
|
const {
|
|
sessionKey: _ignoredSessionKey,
|
|
runId: _ignoredRunId,
|
|
workspaceDir: _ignoredWorkspaceDir,
|
|
...operationParams
|
|
} = params;
|
|
const payload = await runXWorkmateBridgeAgents({
|
|
params: {
|
|
...operationParams,
|
|
sessionKey,
|
|
runId,
|
|
...(workspaceDir ? { workspaceDir } : {}),
|
|
},
|
|
config: ctx.config ?? api.config,
|
|
pluginConfig: api.pluginConfig,
|
|
});
|
|
const summary = typeof payload.bridgeResult.summary === "string"
|
|
? payload.bridgeResult.summary
|
|
: typeof payload.bridgeResult.output === "string"
|
|
? payload.bridgeResult.output
|
|
: "Multi-agent run completed.";
|
|
return {
|
|
content: [{ type: "text", text: [summary, "", payload.manifestMarkdown].join("\n") }],
|
|
details: { artifacts: payload.artifacts, bridgeResult: payload.bridgeResult },
|
|
};
|
|
},
|
|
} as unknown as AnyAgentTool;
|
|
}
|