@perkos/perkos-a2a 0.8.8 → 0.8.10

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,cAAc,YAAY,CAAC;AAuB3B,MAAM,CAAC,OAAO,UAAU,QAAQ,CAAC,GAAG,EAAE,GAAG,QAofxC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,cAAc,YAAY,CAAC;AAuB3B,MAAM,CAAC,OAAO,UAAU,QAAQ,CAAC,GAAG,EAAE,GAAG,QAsiBxC"}

package/dist/index.js

@@ -26665,6 +26665,13 @@ var RelayHub = class {
 };
 
 // src/server.ts
+function appendArtifact(task, text) {
+  task.artifacts.push({
+    kind: "artifact",
+    artifactId: randomUUID3(),
+    parts: [{ kind: "text", text }]
+  });
+}
 async function detectNetworking() {
   const localIps = [];
   const ifaces = networkInterfaces();
@@ -26829,11 +26836,12 @@ var A2AServer = class {
     this.logger.info(
       `[perkos-a2a] Task ${taskId} received from ${task.metadata?.fromAgent}`
     );
-    this.processTask(task);
+    void this.processTask(task);
     return this.success(rpcId, task);
   }
   async processTask(task) {
     task.status = { state: "working", timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+    this.tasks.set(task.id, structuredClone(task));
     const textParts = task.messages.flatMap((m) => m.parts || []).filter((p) => p.kind === "text").map((p) => p.text).join("\n");
     try {
       if (this.messageInjector) {
@@ -26842,11 +26850,8 @@ var A2AServer = class {
           fromAgent: task.metadata?.fromAgent,
           taskId: task.id
         });
-        task.artifacts.push({
-          kind: "artifact",
-          artifactId: randomUUID3(),
-          parts: [{ kind: "text", text: "Task accepted and dispatched for execution" }]
-        });
+        appendArtifact(task, "Task accepted and dispatched for execution");
+        this.tasks.set(task.id, structuredClone(task));
       } else {
         const fs = await import("fs");
         const taskDir = this.config.workspacePath || `${homedir()}/.openclaw/workspace/memory`;
@@ -26867,11 +26872,8 @@ var A2AServer = class {
           ""
         ].join("\n");
         fs.writeFileSync(taskFile, content);
-        task.artifacts.push({
-          kind: "artifact",
-          artifactId: randomUUID3(),
-          parts: [{ kind: "text", text: `Task queued: ${taskFile}` }]
-        });
+        appendArtifact(task, `Task queued: ${taskFile}`);
+        this.tasks.set(task.id, structuredClone(task));
       }
       if (this.taskResultHandler) {
         await this.taskResultHandler(task, textParts);
@@ -26881,6 +26883,7 @@ var A2AServer = class {
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         };
       }
+      this.tasks.set(task.id, structuredClone(task));
       this.logger.info(`[perkos-a2a] Task ${task.id} completed`);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -26896,16 +26899,17 @@ var A2AServer = class {
           }
         };
       }
+      this.tasks.set(task.id, structuredClone(task));
       this.logger.error(`[perkos-a2a] Task ${task.id} failed: ${msg}`);
     }
   }
   handleGetTask(params, rpcId) {
     const task = this.tasks.get(params?.id);
     if (!task) return this.error(rpcId, 404, "Task not found");
-    return this.success(rpcId, task);
+    return this.success(rpcId, structuredClone(task));
   }
   handleListTasks(rpcId) {
-    const allTasks = Array.from(this.tasks.values()).sort(
+    const allTasks = Array.from(this.tasks.values()).map((task) => structuredClone(task)).sort(
       (a, b) => new Date(b.status.timestamp).getTime() - new Date(a.status.timestamp).getTime()
     );
     return this.success(rpcId, { tasks: allTasks, nextPageToken: "" });
@@ -27187,79 +27191,126 @@ function register(api) {
     logger.info("[perkos-a2a] runtime.system.requestHeartbeatNow unavailable \u2014 wake will rely on next agent turn");
   }
   server.setTaskResultHandler(async (task, text) => {
-    const cfg = await api.runtime?.config?.loadConfig?.();
-    if (!api.runtime?.agent?.runEmbeddedAgent || !cfg) {
-      task.status = {
-        state: "completed",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      return;
-    }
-    const agentDir = api.runtime.agent.resolveAgentDir(cfg);
-    const workspaceDir = api.runtime.agent.resolveAgentWorkspaceDir(cfg);
-    await api.runtime.agent.ensureAgentWorkspace(cfg);
-    const sessionId = `perkos-a2a:task:${task.id}`;
-    const prompt = [
-      `You are handling an incoming A2A task from agent ${task.metadata?.fromAgent || "unknown"}.`,
-      `Task ID: ${task.id}`,
-      `Context ID: ${task.contextId}`,
-      "",
-      "Execute the request below and return the actual final answer for the peer agent.",
-      "Do not describe internal steps unless the task explicitly asks for them.",
-      "Return only the useful final response.",
-      "",
-      text
-    ].join("\n");
-    const result = await api.runtime.agent.runEmbeddedAgent({
-      sessionId,
-      runId: randomUUID4(),
-      sessionFile: path.join(agentDir, "sessions", `perkos-a2a-task-${task.id}.jsonl`),
-      workspaceDir,
-      prompt,
-      timeoutMs: api.runtime.agent.resolveAgentTimeoutMs(cfg)
-    });
-    const payloadText = result?.payloads?.map((p) => p?.text).filter(Boolean).join("\n\n") || "";
-    const finalText = (result?.meta?.finalAssistantVisibleText || payloadText || "").trim();
     task.artifacts.push({
       kind: "artifact",
       artifactId: randomUUID4(),
-      parts: [{
-        kind: "text",
-        text: JSON.stringify({
-          debug: "embedded-run-result",
-          stopReason: result?.meta?.stopReason || null,
-          finalAssistantVisibleText: result?.meta?.finalAssistantVisibleText || null,
-          payloadText: payloadText || null,
-          didSendViaMessagingTool: result?.didSendViaMessagingTool || false,
-          payloadCount: Array.isArray(result?.payloads) ? result.payloads.length : 0
-        }, null, 2)
-      }]
+      parts: [{ kind: "text", text: "debug: entered task result handler" }]
     });
-    if (finalText) {
+    try {
+      const cfg = await api.runtime?.config?.loadConfig?.();
       task.artifacts.push({
         kind: "artifact",
         artifactId: randomUUID4(),
-        parts: [{ kind: "text", text: finalText }]
+        parts: [{ kind: "text", text: `debug: config loaded=${!!cfg}` }]
       });
-      task.status = {
-        state: "completed",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        message: {
-          role: "agent",
+      if (!api.runtime?.agent?.runEmbeddedAgent || !cfg) {
+        task.artifacts.push({
+          kind: "artifact",
+          artifactId: randomUUID4(),
+          parts: [{ kind: "text", text: "debug: embedded agent runtime unavailable" }]
+        });
+        task.status = {
+          state: "completed",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          message: {
+            role: "agent",
+            parts: [{ kind: "text", text: "Embedded agent runtime unavailable." }]
+          }
+        };
+        return;
+      }
+      const agentDir = api.runtime.agent.resolveAgentDir(cfg);
+      const workspaceDir = api.runtime.agent.resolveAgentWorkspaceDir(cfg);
+      await api.runtime.agent.ensureAgentWorkspace(cfg);
+      task.artifacts.push({
+        kind: "artifact",
+        artifactId: randomUUID4(),
+        parts: [{ kind: "text", text: "debug: agent workspace ensured" }]
+      });
+      const sessionId = `perkos-a2a:task:${task.id}`;
+      const prompt = [
+        `You are handling an incoming A2A task from agent ${task.metadata?.fromAgent || "unknown"}.`,
+        `Task ID: ${task.id}`,
+        `Context ID: ${task.contextId}`,
+        "",
+        "Execute the request below and return the actual final answer for the peer agent.",
+        "Do not describe internal steps unless the task explicitly asks for them.",
+        "Return only the useful final response.",
+        "",
+        text
+      ].join("\n");
+      task.artifacts.push({
+        kind: "artifact",
+        artifactId: randomUUID4(),
+        parts: [{ kind: "text", text: "debug: starting embedded run" }]
+      });
+      const result = await api.runtime.agent.runEmbeddedAgent({
+        sessionId,
+        runId: randomUUID4(),
+        sessionFile: path.join(agentDir, "sessions", `perkos-a2a-task-${task.id}.jsonl`),
+        workspaceDir,
+        prompt,
+        timeoutMs: api.runtime.agent.resolveAgentTimeoutMs(cfg)
+      });
+      const payloadText = result?.payloads?.map((p) => p?.text).filter(Boolean).join("\n\n") || "";
+      const finalText = (result?.meta?.finalAssistantVisibleText || payloadText || "").trim();
+      task.artifacts.push({
+        kind: "artifact",
+        artifactId: randomUUID4(),
+        parts: [{
+          kind: "text",
+          text: JSON.stringify({
+            debug: "embedded-run-result",
+            stopReason: result?.meta?.stopReason || null,
+            finalAssistantVisibleText: result?.meta?.finalAssistantVisibleText || null,
+            payloadText: payloadText || null,
+            didSendViaMessagingTool: result?.didSendViaMessagingTool || false,
+            payloadCount: Array.isArray(result?.payloads) ? result.payloads.length : 0
+          }, null, 2)
+        }]
+      });
+      if (finalText) {
+        task.artifacts.push({
+          kind: "artifact",
+          artifactId: randomUUID4(),
           parts: [{ kind: "text", text: finalText }]
-        }
-      };
-      logger.info(`[perkos-a2a] Task ${task.id} final result captured from embedded agent`);
-    } else {
+        });
+        task.status = {
+          state: "completed",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          message: {
+            role: "agent",
+            parts: [{ kind: "text", text: finalText }]
+          }
+        };
+        logger.info(`[perkos-a2a] Task ${task.id} final result captured from embedded agent`);
+      } else {
+        task.status = {
+          state: "completed",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          message: {
+            role: "agent",
+            parts: [{ kind: "text", text: "Task executed but no final visible text was captured." }]
+          }
+        };
+        logger.info(`[perkos-a2a] Task ${task.id} executed, but no final visible text was captured`);
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.stack || err.message : String(err);
+      task.artifacts.push({
+        kind: "artifact",
+        artifactId: randomUUID4(),
+        parts: [{ kind: "text", text: `debug: result handler threw: ${msg}` }]
+      });
       task.status = {
-        state: "completed",
+        state: "failed",
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         message: {
           role: "agent",
-          parts: [{ kind: "text", text: "Task executed but no final visible text was captured." }]
+          parts: [{ kind: "text", text: msg }]
         }
       };
-      logger.info(`[perkos-a2a] Task ${task.id} executed, but no final visible text was captured`);
+      throw err;
     }
   });
   server.setTaskFailureHandler(async (task, errorText) => {