@agentfield/sdk 0.1.64-rc.5 → 0.1.64-rc.7

package/dist/index.js

@@ -1,5 +1,6 @@
-import fs from 'fs';
-import path from 'path';
+import fs, { promises } from 'fs';
+import * as path2 from 'path';
+import path2__default, { resolve } from 'path';
 import { createRequire } from 'module';
 import { spawn } from 'child_process';
 import express from 'express';
@@ -22,6 +23,7 @@ import https from 'https';
 import WebSocket from 'ws';
 import { Buffer as Buffer$1 } from 'buffer';
 import { zodToJsonSchema } from 'zod-to-json-schema';
+import { readFile } from 'fs/promises';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -54,12 +56,12 @@ function hasJsonSchema(value) {
 function hasParse(value) {
   return isRecord(value) && typeof value.parse === "function";
 }
-function estimateTokens(text) {
-  return Math.floor(text.length / 4);
+function estimateTokens(text2) {
+  return Math.floor(text2.length / 4);
 }
 function writeSchemaFile(schemaJson, cwd) {
   const filePath = getSchemaPath(cwd);
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.mkdirSync(path2__default.dirname(filePath), { recursive: true });
   const fd = fs.openSync(filePath, "w", 384);
   try {
     fs.writeFileSync(fd, schemaJson, "utf8");
@@ -75,10 +77,10 @@ function validateAgainstSchema(data, schema) {
   return data;
 }
 function getOutputPath(cwd) {
-  return path.join(cwd, OUTPUT_FILENAME);
+  return path2__default.join(cwd, OUTPUT_FILENAME);
 }
 function getSchemaPath(cwd) {
-  return path.join(cwd, SCHEMA_FILENAME);
+  return path2__default.join(cwd, SCHEMA_FILENAME);
 }
 function schemaToJsonSchema(schema) {
   if (isRecord(schema)) {
@@ -122,24 +124,24 @@ ${schemaJson}
 Do not include any text outside the JSON in that file. Do not wrap in markdown fences.`;
 }
 function cosmeticRepair(raw) {
-  let text = raw.trim();
-  const fenceMatch = text.match(/^```(?:json)?\s*\n([\s\S]*?)```\s*$/);
+  let text2 = raw.trim();
+  const fenceMatch = text2.match(/^```(?:json)?\s*\n([\s\S]*?)```\s*$/);
   if (fenceMatch) {
-    text = fenceMatch[1].trim();
+    text2 = fenceMatch[1].trim();
   }
-  if (text.length > 0 && text[0] !== "{" && text[0] !== "[") {
-    const firstJsonCharIndex = [...text].findIndex((char) => char === "{" || char === "[");
+  if (text2.length > 0 && text2[0] !== "{" && text2[0] !== "[") {
+    const firstJsonCharIndex = [...text2].findIndex((char) => char === "{" || char === "[");
     if (firstJsonCharIndex >= 0) {
-      text = text.slice(firstJsonCharIndex);
+      text2 = text2.slice(firstJsonCharIndex);
     }
   }
-  text = text.replace(/,\s*([}\]])/g, "$1");
-  const openBraces = (text.match(/{/g)?.length ?? 0) - (text.match(/}/g)?.length ?? 0);
-  const openBrackets = (text.match(/\[/g)?.length ?? 0) - (text.match(/\]/g)?.length ?? 0);
+  text2 = text2.replace(/,\s*([}\]])/g, "$1");
+  const openBraces = (text2.match(/{/g)?.length ?? 0) - (text2.match(/}/g)?.length ?? 0);
+  const openBrackets = (text2.match(/\[/g)?.length ?? 0) - (text2.match(/\]/g)?.length ?? 0);
   if (openBraces > 0 || openBrackets > 0) {
-    text += "]".repeat(openBrackets) + "}".repeat(openBraces);
+    text2 += "]".repeat(openBrackets) + "}".repeat(openBraces);
   }
-  return text;
+  return text2;
 }
 function readAndParse(filePath) {
   try {
@@ -184,7 +186,7 @@ function parseAndValidate(filePath, schema) {
 function cleanupTempFiles(cwd) {
   for (const filename of [OUTPUT_FILENAME, SCHEMA_FILENAME]) {
     try {
-      fs.unlinkSync(path.join(cwd, filename));
+      fs.unlinkSync(path2__default.join(cwd, filename));
     } catch {
     }
   }
@@ -336,7 +338,7 @@ var init_claude = __esm({
   }
 });
 function runCli(cmd, options) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const [bin, ...args] = cmd;
     const proc = spawn(bin, args, {
       env: { ...process.env, ...options?.env },
@@ -359,7 +361,7 @@ function runCli(cmd, options) {
       if (timer) {
         clearTimeout(timer);
       }
-      resolve({ stdout, stderr, exitCode: code ?? 0 });
+      resolve2({ stdout, stderr, exitCode: code ?? 0 });
     });
     proc.on("error", (err) => {
       if (timer) {
@@ -369,9 +371,9 @@ function runCli(cmd, options) {
     });
   });
 }
-function parseJsonl(text) {
+function parseJsonl(text2) {
   const events = [];
-  for (const line of text.split("\n")) {
+  for (const line of text2.split("\n")) {
     const trimmed = line.trim();
     if (!trimmed) {
       continue;
@@ -570,17 +572,30 @@ var init_opencode = __esm({
         this.bin = binPath;
       }
       async execute(prompt, options) {
-        const cmd = [this.bin, "run"];
+        const cmd = [this.bin];
+        if (options.cwd && typeof options.cwd === "string") {
+          cmd.push("-c", options.cwd);
+        } else if (options.project_dir && typeof options.project_dir === "string") {
+          cmd.push("-c", options.project_dir);
+        }
+        const env = { ...options.env };
         if (options.model) {
-          cmd.push("--model", String(options.model));
+          env["MODEL"] = String(options.model);
         }
-        cmd.push(prompt);
+        let effectivePrompt = prompt;
+        if (options.system_prompt && typeof options.system_prompt === "string" && options.system_prompt.trim()) {
+          effectivePrompt = `SYSTEM INSTRUCTIONS:
+${options.system_prompt.trim()}
+
+---
+
+USER REQUEST:
+${prompt}`;
+        }
+        cmd.push("-p", effectivePrompt);
         const startApi = Date.now();
         try {
-          const { stdout, stderr, exitCode } = await runCli(cmd, {
-            env: options.env,
-            cwd: options.cwd
-          });
+          const { stdout, stderr, exitCode } = await runCli(cmd, { env });
           const resultText = stdout.trim() || void 0;
           const isError = exitCode !== 0 && !resultText;
           return createRawResult({
@@ -817,8 +832,8 @@ var init_runner = __esm({
         return base + jitter;
       }
       sleep(delaySeconds) {
-        return new Promise((resolve) => {
-          setTimeout(resolve, Math.max(0, delaySeconds) * 1e3);
+        return new Promise((resolve2) => {
+          setTimeout(resolve2, Math.max(0, delaySeconds) * 1e3);
         });
       }
     };
@@ -876,6 +891,9 @@ var ExecutionContext = class {
     this.res = params.res;
     this.agent = params.agent;
   }
+  get logger() {
+    return this.agent.getExecutionLogger();
+  }
   static run(ctx, fn) {
     return store.run(ctx, fn);
   }
@@ -1185,13 +1203,16 @@ var ReasonerContext = class {
   sessionId;
   actorId;
   workflowId;
+  rootWorkflowId;
   parentExecutionId;
+  reasonerId;
   callerDid;
   targetDid;
   agentNodeDid;
   req;
   res;
   agent;
+  logger;
   aiClient;
   memory;
   workflow;
@@ -1203,13 +1224,16 @@ var ReasonerContext = class {
     this.sessionId = params.sessionId;
     this.actorId = params.actorId;
     this.workflowId = params.workflowId;
+    this.rootWorkflowId = params.rootWorkflowId;
     this.parentExecutionId = params.parentExecutionId;
+    this.reasonerId = params.reasonerId;
     this.callerDid = params.callerDid;
     this.targetDid = params.targetDid;
     this.agentNodeDid = params.agentNodeDid;
     this.req = params.req;
     this.res = params.res;
     this.agent = params.agent;
+    this.logger = params.logger;
     this.aiClient = params.aiClient;
     this.memory = params.memory;
     this.workflow = params.workflow;
@@ -1263,7 +1287,9 @@ var ReasonerContext = class {
       sessionId: this.sessionId,
       actorId: this.actorId,
       workflowId: this.workflowId,
+      rootWorkflowId: this.rootWorkflowId,
       parentExecutionId: this.parentExecutionId,
+      reasonerId: this.reasonerId,
       callerDid: this.callerDid,
       targetDid: this.targetDid,
       agentNodeDid: this.agentNodeDid
@@ -1281,13 +1307,16 @@ function getCurrentContext() {
     sessionId: metadata.sessionId,
     actorId: metadata.actorId,
     workflowId: metadata.workflowId,
+    rootWorkflowId: metadata.rootWorkflowId,
     parentExecutionId: metadata.parentExecutionId,
+    reasonerId: metadata.reasonerId,
     callerDid: metadata.callerDid,
     targetDid: metadata.targetDid,
     agentNodeDid: metadata.agentNodeDid,
     req,
     res,
     agent,
+    logger: agent.getExecutionLogger(),
     aiClient: agent.getAIClient(),
     memory: agent.getMemoryInterface(metadata),
     workflow: agent.getWorkflowReporter(metadata),
@@ -1301,11 +1330,14 @@ var SkillContext = class {
   executionId;
   sessionId;
   workflowId;
+  rootWorkflowId;
+  reasonerId;
   callerDid;
   agentNodeDid;
   req;
   res;
   agent;
+  logger;
   memory;
   workflow;
   did;
@@ -1314,11 +1346,14 @@ var SkillContext = class {
     this.executionId = params.executionId;
     this.sessionId = params.sessionId;
     this.workflowId = params.workflowId;
+    this.rootWorkflowId = params.rootWorkflowId;
+    this.reasonerId = params.reasonerId;
     this.callerDid = params.callerDid;
     this.agentNodeDid = params.agentNodeDid;
     this.req = params.req;
     this.res = params.res;
     this.agent = params.agent;
+    this.logger = params.logger;
     this.memory = params.memory;
     this.workflow = params.workflow;
     this.did = params.did;
@@ -1336,11 +1371,14 @@ function getCurrentSkillContext() {
     executionId: metadata.executionId,
     sessionId: metadata.sessionId,
     workflowId: metadata.workflowId,
+    rootWorkflowId: metadata.rootWorkflowId,
+    reasonerId: metadata.reasonerId,
     callerDid: metadata.callerDid,
     agentNodeDid: metadata.agentNodeDid,
     req,
     res,
     agent,
+    logger: agent.getExecutionLogger(),
     memory: agent.getMemoryInterface(metadata),
     workflow: agent.getWorkflowReporter(metadata),
     did: agent.getDidInterface(metadata, input)
@@ -1478,7 +1516,7 @@ var StatelessRateLimiter = class {
     }
   }
   async _sleep(delaySeconds) {
-    await new Promise((resolve) => setTimeout(resolve, delaySeconds * 1e3));
+    await new Promise((resolve2) => setTimeout(resolve2, delaySeconds * 1e3));
   }
   _now() {
     return Date.now() / 1e3;
@@ -1517,8 +1555,8 @@ var StatelessRateLimiter = class {
 };
 
 // src/ai/AIClient.ts
-function repairJsonText(text) {
-  let cleaned = text.trim();
+function repairJsonText(text2) {
+  let cleaned = text2.trim();
   const codeBlockMatch = cleaned.match(/```(?:json)?\s*([\s\S]*?)```/);
   if (codeBlockMatch) {
     cleaned = codeBlockMatch[1].trim();
@@ -1564,7 +1602,7 @@ var AIClient = class {
         temperature: options.temperature ?? this.config.temperature,
         maxOutputTokens: options.maxTokens ?? this.config.maxTokens,
         schema,
-        experimental_repairText: async ({ text }) => repairJsonText(text)
+        experimental_repairText: async ({ text: text2 }) => repairJsonText(text2)
       });
       const response2 = await this.withRateLimitRetry(call2);
       return response2.object;
@@ -1756,6 +1794,131 @@ var AIClient = class {
     return this.getRateLimiter().executeWithRetry(fn);
   }
 };
+
+// src/observability/ExecutionLogger.ts
+function isExecutionLogBatchPayload(payload) {
+  return "entries" in payload;
+}
+function safeJsonStringify(value) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return JSON.stringify(value, (_key, current) => {
+    if (typeof current === "bigint") {
+      return current.toString();
+    }
+    if (typeof current === "object" && current !== null) {
+      if (seen.has(current)) {
+        return "[Circular]";
+      }
+      seen.add(current);
+    }
+    return current;
+  });
+}
+function mergeAttributes(existing, next) {
+  if (!next) {
+    return void 0;
+  }
+  return {
+    ...{},
+    ...next ?? {}
+  };
+}
+function normalizeExecutionLogEntry(entry) {
+  return {
+    v: entry.v,
+    ts: entry.ts,
+    execution_id: entry.executionId,
+    run_id: entry.runId,
+    workflow_id: entry.workflowId,
+    root_workflow_id: entry.rootWorkflowId,
+    parent_execution_id: entry.parentExecutionId,
+    session_id: entry.sessionId,
+    actor_id: entry.actorId,
+    agent_node_id: entry.agentNodeId,
+    reasoner_id: entry.reasonerId,
+    caller_did: entry.callerDid,
+    target_did: entry.targetDid,
+    agent_node_did: entry.agentNodeDid,
+    level: entry.level,
+    source: entry.source,
+    event_type: entry.eventType,
+    message: entry.message,
+    attributes: entry.attributes,
+    system_generated: entry.systemGenerated
+  };
+}
+function serializeExecutionLogEntry(entry) {
+  return safeJsonStringify(normalizeExecutionLogEntry(entry));
+}
+var ExecutionLogger = class {
+  contextProvider;
+  transport;
+  mirrorToStdout;
+  stdout;
+  defaultSource;
+  constructor(options = {}) {
+    this.contextProvider = options.contextProvider;
+    this.transport = options.transport;
+    this.mirrorToStdout = options.mirrorToStdout ?? true;
+    this.stdout = options.stdout ?? (typeof process !== "undefined" ? process.stdout : void 0);
+    this.defaultSource = options.source ?? "sdk.logger";
+  }
+  log(level, message, attributes, options = {}) {
+    const context = this.contextProvider?.() ?? {};
+    const entry = {
+      v: 1,
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      source: options.source ?? this.defaultSource,
+      message,
+      ...context,
+      ...options.eventType ? { eventType: options.eventType } : {},
+      ...options.systemGenerated ? { systemGenerated: true } : {},
+      ...attributes ? { attributes: mergeAttributes(void 0, attributes) } : {}
+    };
+    this.emit(entry);
+    return entry;
+  }
+  debug(message, attributes, options) {
+    return this.log("debug", message, attributes, options);
+  }
+  info(message, attributes, options) {
+    return this.log("info", message, attributes, options);
+  }
+  warn(message, attributes, options) {
+    return this.log("warn", message, attributes, options);
+  }
+  error(message, attributes, options) {
+    return this.log("error", message, attributes, options);
+  }
+  system(eventType, message, attributes) {
+    return this.log("info", message, attributes, {
+      eventType,
+      source: "sdk.runtime",
+      systemGenerated: true
+    });
+  }
+  emit(entry) {
+    const wire = normalizeExecutionLogEntry(entry);
+    const line = safeJsonStringify(wire) + "\n";
+    if (this.mirrorToStdout && this.stdout?.write) {
+      this.stdout.write(line);
+    }
+    if (this.transport && wire.execution_id) {
+      try {
+        const result = this.transport.emit(wire);
+        if (result && typeof result.catch === "function") {
+          void Promise.resolve(result).catch(() => {
+          });
+        }
+      } catch {
+      }
+    }
+  }
+};
+function createExecutionLogger(options = {}) {
+  return new ExecutionLogger(options);
+}
 var httpAgent = new http.Agent({
   keepAlive: true,
   maxSockets: 10,
@@ -1901,7 +2064,9 @@ var AgentFieldClient = class {
     const headers = {};
     if (metadata?.runId) headers["X-Run-ID"] = metadata.runId;
     if (metadata?.workflowId) headers["X-Workflow-ID"] = metadata.workflowId;
+    if (metadata?.rootWorkflowId) headers["X-Root-Workflow-ID"] = metadata.rootWorkflowId;
     if (metadata?.parentExecutionId) headers["X-Parent-Execution-ID"] = metadata.parentExecutionId;
+    if (metadata?.reasonerId) headers["X-Reasoner-ID"] = metadata.reasonerId;
     if (metadata?.sessionId) headers["X-Session-ID"] = metadata.sessionId;
     if (metadata?.actorId) headers["X-Actor-ID"] = metadata.actorId;
     if (metadata?.callerDid) headers["X-Caller-DID"] = metadata.callerDid;
@@ -1935,6 +2100,7 @@ var AgentFieldClient = class {
       execution_id: event.executionId,
       workflow_id: event.workflowId ?? event.runId,
       run_id: event.runId,
+      root_workflow_id: event.rootWorkflowId ?? event.workflowId ?? event.runId,
       reasoner_id: event.reasonerId,
       type: event.reasonerId,
       agent_node_id: event.agentNodeId,
@@ -1955,6 +2121,19 @@ var AgentFieldClient = class {
     }).catch(() => {
     });
   }
+  publishExecutionLogs(payload) {
+    const executionId = isExecutionLogBatchPayload(payload) ? payload.entries[0]?.execution_id : payload.execution_id;
+    if (!executionId) {
+      return;
+    }
+    const bodyStr = JSON.stringify(payload);
+    const authHeaders = this.didAuthenticator.signRequest(Buffer.from(bodyStr));
+    this.http.post(`/api/v1/executions/${encodeURIComponent(executionId)}/logs`, bodyStr, {
+      headers: this.mergeHeaders({ "Content-Type": "application/json", ...authHeaders }),
+      timeout: this.config.devMode ? 1e3 : 5e3
+    }).catch(() => {
+    });
+  }
   async updateExecutionStatus(executionId, update) {
     if (!executionId) {
       throw new Error("executionId is required to update workflow status");
@@ -2105,7 +2284,9 @@ var AgentFieldClient = class {
     if (metadata.sessionId) headers["x-session-id"] = metadata.sessionId;
     if (metadata.actorId) headers["x-actor-id"] = metadata.actorId;
     if (metadata.workflowId) headers["x-workflow-id"] = metadata.workflowId;
+    if (metadata.rootWorkflowId) headers["x-root-workflow-id"] = metadata.rootWorkflowId;
     if (metadata.parentExecutionId) headers["x-parent-execution-id"] = metadata.parentExecutionId;
+    if (metadata.reasonerId) headers["x-reasoner-id"] = metadata.reasonerId;
     if (metadata.callerDid) headers["x-caller-did"] = metadata.callerDid;
     if (metadata.targetDid) headers["x-target-did"] = metadata.targetDid;
     if (metadata.agentNodeDid) headers["x-agent-node-did"] = metadata.agentNodeDid;
@@ -2495,11 +2676,11 @@ var MemoryInterface = class _MemoryInterface {
       metadata: this.metadata
     });
   }
-  async embedText(text, options) {
+  async embedText(text2, options) {
     if (!this.aiClient) {
       throw new Error("AI client not configured for embeddings");
     }
-    return this.aiClient.embed(text, options);
+    return this.aiClient.embed(text2, options);
   }
   async embedTexts(texts, options) {
     if (!this.aiClient) {
@@ -2507,8 +2688,8 @@ var MemoryInterface = class _MemoryInterface {
     }
     return this.aiClient.embedMany(texts, options);
   }
-  async embedAndSet(key, text, metadata, scope = this.defaultScope, scopeId = this.defaultScopeId, embeddingOptions) {
-    const embedding = await this.embedText(text, embeddingOptions);
+  async embedAndSet(key, text2, metadata, scope = this.defaultScope, scopeId = this.defaultScopeId, embeddingOptions) {
+    const embedding = await this.embedText(text2, embeddingOptions);
     await this.setVector(key, embedding, metadata, scope, scopeId);
     return embedding;
   }
@@ -3402,6 +3583,162 @@ function evaluateConstraints(constraints, inputParams) {
   return true;
 }
 
+// src/agent/processLogs.ts
+function logsEnabled() {
+  const v = (process.env.AGENTFIELD_LOGS_ENABLED ?? "true").trim().toLowerCase();
+  return !["0", "false", "no", "off"].includes(v);
+}
+function maxBufferBytes() {
+  const raw = parseInt(process.env.AGENTFIELD_LOG_BUFFER_BYTES ?? "4194304", 10);
+  return Number.isFinite(raw) && raw >= 1024 ? raw : 4194304;
+}
+function maxLineBytes() {
+  const raw = parseInt(process.env.AGENTFIELD_LOG_MAX_LINE_BYTES ?? "16384", 10);
+  return Number.isFinite(raw) && raw >= 256 ? raw : 16384;
+}
+function maxTailLines() {
+  const raw = parseInt(process.env.AGENTFIELD_LOG_MAX_TAIL_LINES ?? "50000", 10);
+  return Number.isFinite(raw) && raw >= 1 ? raw : 5e4;
+}
+function internalBearerOk(authHeader) {
+  const want = (process.env.AGENTFIELD_AUTHORIZATION_INTERNAL_TOKEN ?? "").trim();
+  if (!want) return true;
+  if (!authHeader?.toLowerCase().startsWith("bearer ")) return false;
+  return authHeader.slice(7).trim() === want;
+}
+var ProcessLogRing = class {
+  seq = 0;
+  entries = [];
+  approxBytes = 0;
+  maxBytes;
+  constructor() {
+    this.maxBytes = maxBufferBytes();
+  }
+  append(stream, line, truncated) {
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    this.seq += 1;
+    const sl = stream.toLowerCase();
+    const level = sl === "stderr" ? "error" : sl === "stdout" ? "info" : "log";
+    const e = {
+      v: 1,
+      seq: this.seq,
+      ts,
+      stream,
+      line,
+      level,
+      source: "process",
+      truncated
+    };
+    this.entries.push(e);
+    this.approxBytes += line.length + 64;
+    while (this.approxBytes > this.maxBytes && this.entries.length > 1) {
+      const old = this.entries.shift();
+      this.approxBytes -= old.line.length + 64;
+    }
+  }
+  tail(n) {
+    if (n <= 0) return [];
+    return this.entries.length <= n ? [...this.entries] : this.entries.slice(-n);
+  }
+  snapshotAfter(sinceSeq, limit) {
+    const buf = this.entries.filter((e) => e.seq > sinceSeq);
+    if (limit != null && limit > 0 && buf.length > limit) {
+      return buf.slice(-limit);
+    }
+    return buf;
+  }
+};
+var captureInstalled = false;
+function installStdioLogCapture(ring) {
+  if (captureInstalled || !logsEnabled()) return;
+  captureInstalled = true;
+  const maxLB = maxLineBytes();
+  const hook = (stream, name) => {
+    const orig = stream.write.bind(stream);
+    let buf = "";
+    stream.write = (chunk, ...args) => {
+      const s = typeof chunk === "string" ? chunk : Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
+      buf += s;
+      let idx;
+      while ((idx = buf.indexOf("\n")) >= 0) {
+        const line = buf.slice(0, idx);
+        buf = buf.slice(idx + 1);
+        let out = line;
+        let trunc = false;
+        if (Buffer.byteLength(out, "utf8") > maxLB) {
+          out = Buffer.from(out, "utf8").subarray(0, maxLB).toString("utf8");
+          trunc = true;
+        }
+        ring.append(name, out, trunc);
+      }
+      return orig(chunk, ...args);
+    };
+  };
+  hook(process.stdout, "stdout");
+  hook(process.stderr, "stderr");
+}
+function registerAgentfieldLogsRoute(app, ring) {
+  app.get("/agentfield/v1/logs", (req, res) => {
+    if (!logsEnabled()) {
+      return res.status(404).json({
+        error: "logs_disabled",
+        message: "Process logs API is disabled"
+      });
+    }
+    const auth = req.headers.authorization;
+    if (!internalBearerOk(auth)) {
+      return res.status(401).json({
+        error: "unauthorized",
+        message: "Valid Authorization Bearer required"
+      });
+    }
+    let tailLines = parseInt(String(req.query.tail_lines ?? "0"), 10);
+    const sinceSeq = parseInt(String(req.query.since_seq ?? "0"), 10);
+    const follow = ["1", "true", "yes"].includes(String(req.query.follow ?? "").toLowerCase());
+    const cap = maxTailLines();
+    if (tailLines > cap) {
+      return res.status(413).json({
+        error: "tail_too_large",
+        message: `tail_lines exceeds max ${cap}`
+      });
+    }
+    if (tailLines <= 0 && sinceSeq <= 0 && !follow) tailLines = 200;
+    let initial;
+    if (sinceSeq > 0) {
+      initial = ring.snapshotAfter(sinceSeq, tailLines > 0 ? tailLines : null);
+    } else {
+      const n = tailLines > 0 ? tailLines : 200;
+      initial = ring.tail(n);
+    }
+    res.setHeader("Content-Type", "application/x-ndjson");
+    res.setHeader("Cache-Control", "no-store");
+    res.status(200);
+    const writeLines = (entries) => {
+      for (const e of entries) {
+        res.write(`${JSON.stringify(e)}
+`);
+      }
+      res.flush?.();
+    };
+    writeLines(initial);
+    let lastSeq = sinceSeq;
+    if (initial.length) lastSeq = initial[initial.length - 1].seq;
+    if (!follow) {
+      return res.end();
+    }
+    const iv = setInterval(() => {
+      const newer = ring.snapshotAfter(lastSeq, null);
+      if (newer.length) {
+        writeLines(newer);
+        lastSeq = newer[newer.length - 1].seq;
+      }
+    }, 400);
+    req.on("close", () => {
+      clearInterval(iv);
+    });
+  });
+}
+
 // src/agent/Agent.ts
 var TargetNotFoundError = class extends Error {
 };
@@ -3424,6 +3761,8 @@ var Agent = class {
   mcpToolRegistrar;
   localVerifier;
   realtimeValidationFunctions = /* @__PURE__ */ new Set();
+  processLogRing = new ProcessLogRing();
+  executionLogger;
   constructor(config) {
     const mcp = config.mcp ? {
       autoRegisterTools: config.mcp.autoRegisterTools ?? true,
@@ -3446,6 +3785,12 @@ var Agent = class {
     this.memoryEventClient = new MemoryEventClient(this.config.agentFieldUrl, this.config.defaultHeaders);
     this.didClient = new DidClient(this.config.agentFieldUrl, this.config.defaultHeaders);
     this.didManager = new DidManager(this.didClient, this.config.nodeId);
+    this.executionLogger = createExecutionLogger({
+      contextProvider: () => this.buildExecutionLogContext(),
+      transport: {
+        emit: (payload) => this.agentFieldClient.publishExecutionLogs(payload)
+      }
+    });
     this.memoryEventClient.onEvent((event) => this.dispatchMemoryEvent(event));
     if (this.config.mcp?.servers?.length) {
       this.mcpClientRegistry = new MCPClientRegistry(this.config.devMode);
@@ -3465,6 +3810,8 @@ var Agent = class {
       );
     }
     this.registerDefaultRoutes();
+    installStdioLogCapture(this.processLogRing);
+    registerAgentfieldLogsRoute(this.app, this.processLogRing);
   }
   reasoner(name, handler, options) {
     this.reasoners.register(name, handler, options);
@@ -3510,6 +3857,9 @@ var Agent = class {
   getAIClient() {
     return this.aiClient;
   }
+  getExecutionLogger() {
+    return this.executionLogger;
+  }
   async getHarnessRunner() {
     const cached = harnessRunners.get(this);
     if (cached) return cached;
@@ -3550,7 +3900,8 @@ var Agent = class {
       executionId: metadata.executionId,
       runId: metadata.runId,
       workflowId: metadata.workflowId,
-      agentNodeId: this.config.nodeId
+      agentNodeId: this.config.nodeId,
+      reasonerId: metadata.reasonerId
     });
   }
   getDidInterface(metadata, defaultInput, targetName) {
@@ -3580,6 +3931,24 @@ var Agent = class {
     }
     this.agentFieldClient.sendNote(message, tags, this.config.nodeId, execMetadata, uiApiUrl, this.config.devMode);
   }
+  buildExecutionLogContext(metadata) {
+    const current = metadata ?? ExecutionContext.getCurrent()?.metadata;
+    if (!current) return void 0;
+    return {
+      executionId: current.executionId,
+      runId: current.runId,
+      workflowId: current.workflowId,
+      rootWorkflowId: current.rootWorkflowId ?? current.workflowId ?? current.runId ?? current.executionId,
+      parentExecutionId: current.parentExecutionId,
+      sessionId: current.sessionId,
+      actorId: current.actorId,
+      agentNodeId: this.config.nodeId,
+      reasonerId: current.reasonerId,
+      callerDid: current.callerDid,
+      targetDid: current.targetDid,
+      agentNodeDid: current.agentNodeDid
+    };
+  }
   async serve() {
     if (this.config.mcp?.autoRegisterTools !== false) {
       try {
@@ -3604,8 +3973,8 @@ var Agent = class {
     const port = this.config.port ?? 8001;
     const host = this.config.host ?? "0.0.0.0";
     await this.agentFieldClient.heartbeat("starting");
-    await new Promise((resolve, reject) => {
-      this.server = this.app.listen(port, host, () => resolve()).on("error", reject);
+    await new Promise((resolve2, reject) => {
+      this.server = this.app.listen(port, host, () => resolve2()).on("error", reject);
     });
     this.memoryEventClient.start();
     this.startHeartbeat();
@@ -3614,46 +3983,59 @@ var Agent = class {
     if (this.heartbeatTimer) {
       clearInterval(this.heartbeatTimer);
     }
-    await new Promise((resolve, reject) => {
+    await new Promise((resolve2, reject) => {
       this.server?.close((err) => {
         if (err) reject(err);
-        else resolve();
+        else resolve2();
       });
     });
     this.memoryEventClient.stop();
   }
   async call(target, input) {
     const { agentId, name } = this.parseTarget(target);
+    const parentMetadata = ExecutionContext.getCurrent()?.metadata;
     if (!agentId || agentId === this.config.nodeId) {
       const local = this.reasoners.get(name);
       if (!local) throw new Error(`Reasoner not found: ${name}`);
-      const parentMetadata = ExecutionContext.getCurrent()?.metadata;
-      const runId = parentMetadata?.runId ?? parentMetadata?.executionId ?? randomUUID();
-      const metadata2 = {
+      const runId2 = parentMetadata?.runId ?? parentMetadata?.executionId ?? randomUUID();
+      const rootWorkflowId2 = parentMetadata?.rootWorkflowId ?? parentMetadata?.workflowId ?? runId2;
+      const metadata = {
         ...parentMetadata,
         executionId: randomUUID(),
         parentExecutionId: parentMetadata?.executionId,
-        runId,
-        workflowId: parentMetadata?.workflowId ?? runId
+        runId: runId2,
+        workflowId: parentMetadata?.workflowId ?? runId2,
+        rootWorkflowId: rootWorkflowId2,
+        reasonerId: name
       };
       const dummyReq = {};
       const dummyRes = {};
       const execCtx = new ExecutionContext({
         input,
         metadata: {
-          ...metadata2,
-          executionId: metadata2.executionId ?? randomUUID()
+          ...metadata,
+          executionId: metadata.executionId ?? randomUUID()
         },
         req: dummyReq,
         res: dummyRes,
         agent: this
       });
       const startTime = Date.now();
+      this.executionLogger.system("agent.call.started", "Local agent call started", {
+        target,
+        reasonerId: name,
+        executionId: metadata.executionId,
+        parentExecutionId: metadata.parentExecutionId,
+        runId: metadata.runId,
+        workflowId: metadata.workflowId,
+        rootWorkflowId: metadata.rootWorkflowId
+      });
       const emitEvent = async (status, payload) => {
         await this.agentFieldClient.publishWorkflowEvent({
           executionId: execCtx.metadata.executionId,
           runId: execCtx.metadata.runId ?? execCtx.metadata.executionId,
           workflowId: execCtx.metadata.workflowId,
+          rootWorkflowId: execCtx.metadata.rootWorkflowId,
           reasonerId: name,
           agentNodeId: this.config.nodeId,
           status,
@@ -3667,6 +4049,22 @@ var Agent = class {
       };
       await emitEvent("running", null);
       return ExecutionContext.run(execCtx, async () => {
+        this.executionLogger.system("execution.started", "Execution started", {
+          target,
+          reasonerId: name,
+          executionId: execCtx.metadata.executionId,
+          parentExecutionId: execCtx.metadata.parentExecutionId,
+          runId: execCtx.metadata.runId,
+          workflowId: execCtx.metadata.workflowId,
+          rootWorkflowId: execCtx.metadata.rootWorkflowId
+        });
+        this.executionLogger.system("reasoner.started", "Reasoner execution started", {
+          target: name,
+          executionId: execCtx.metadata.executionId,
+          runId: execCtx.metadata.runId,
+          workflowId: execCtx.metadata.workflowId,
+          rootWorkflowId: execCtx.metadata.rootWorkflowId
+        });
         try {
           const result = await local.handler(
             new ReasonerContext({
@@ -3676,39 +4074,154 @@ var Agent = class {
               sessionId: execCtx.metadata.sessionId,
               actorId: execCtx.metadata.actorId,
               workflowId: execCtx.metadata.workflowId,
+              rootWorkflowId: execCtx.metadata.rootWorkflowId,
               parentExecutionId: execCtx.metadata.parentExecutionId,
+              reasonerId: name,
               callerDid: execCtx.metadata.callerDid,
               targetDid: execCtx.metadata.targetDid,
               agentNodeDid: execCtx.metadata.agentNodeDid,
               req: dummyReq,
               res: dummyRes,
               agent: this,
+              logger: this.executionLogger,
               aiClient: this.aiClient,
               memory: this.getMemoryInterface(execCtx.metadata),
               workflow: this.getWorkflowReporter(execCtx.metadata),
               did: this.getDidInterface(execCtx.metadata, input, name)
             })
           );
+          this.executionLogger.system("reasoner.completed", "Reasoner execution completed", {
+            target: name,
+            executionId: execCtx.metadata.executionId,
+            runId: execCtx.metadata.runId,
+            workflowId: execCtx.metadata.workflowId,
+            rootWorkflowId: execCtx.metadata.rootWorkflowId,
+            durationMs: Date.now() - startTime
+          });
+          this.executionLogger.system("execution.completed", "Execution completed", {
+            target,
+            reasonerId: name,
+            executionId: execCtx.metadata.executionId,
+            runId: execCtx.metadata.runId,
+            workflowId: execCtx.metadata.workflowId,
+            rootWorkflowId: execCtx.metadata.rootWorkflowId,
+            durationMs: Date.now() - startTime
+          });
+          this.executionLogger.system("agent.call.completed", "Local agent call completed", {
+            target,
+            reasonerId: name,
+            executionId: execCtx.metadata.executionId,
+            runId: execCtx.metadata.runId,
+            workflowId: execCtx.metadata.workflowId,
+            rootWorkflowId: execCtx.metadata.rootWorkflowId,
+            durationMs: Date.now() - startTime
+          });
           await emitEvent("succeeded", result);
           return result;
         } catch (err) {
+          this.executionLogger.error("Reasoner execution failed", {
+            target: name,
+            executionId: execCtx.metadata.executionId,
+            runId: execCtx.metadata.runId,
+            workflowId: execCtx.metadata.workflowId,
+            rootWorkflowId: execCtx.metadata.rootWorkflowId,
+            durationMs: Date.now() - startTime,
+            error: err instanceof Error ? err.message : String(err)
+          }, {
+            eventType: "reasoner.failed",
+            source: "sdk.runtime",
+            systemGenerated: true
+          });
+          this.executionLogger.error("Execution failed", {
+            target,
+            reasonerId: name,
+            executionId: execCtx.metadata.executionId,
+            runId: execCtx.metadata.runId,
+            workflowId: execCtx.metadata.workflowId,
+            rootWorkflowId: execCtx.metadata.rootWorkflowId,
+            durationMs: Date.now() - startTime,
+            error: err instanceof Error ? err.message : String(err)
+          }, {
+            eventType: "execution.failed",
+            source: "sdk.runtime",
+            systemGenerated: true
+          });
+          this.executionLogger.error("Local agent call failed", {
+            target,
+            reasonerId: name,
+            executionId: execCtx.metadata.executionId,
+            runId: execCtx.metadata.runId,
+            workflowId: execCtx.metadata.workflowId,
+            rootWorkflowId: execCtx.metadata.rootWorkflowId,
+            durationMs: Date.now() - startTime,
+            error: err instanceof Error ? err.message : String(err)
+          }, {
+            eventType: "agent.call.failed",
+            source: "sdk.runtime",
+            systemGenerated: true
+          });
           await emitEvent("failed", err);
           throw err;
         }
       });
     }
-    const metadata = ExecutionContext.getCurrent()?.metadata;
-    return this.agentFieldClient.execute(target, input, {
-      runId: metadata?.runId ?? metadata?.executionId,
-      workflowId: metadata?.workflowId ?? metadata?.runId,
-      parentExecutionId: metadata?.executionId,
-      sessionId: metadata?.sessionId,
-      actorId: metadata?.actorId,
-      callerDid: metadata?.callerDid,
-      targetDid: metadata?.targetDid,
-      agentNodeDid: metadata?.agentNodeDid,
-      agentNodeId: this.config.nodeId
+    const executionId = parentMetadata?.executionId ?? randomUUID();
+    const runId = parentMetadata?.runId ?? parentMetadata?.executionId ?? executionId;
+    const workflowId = parentMetadata?.workflowId ?? runId;
+    const rootWorkflowId = parentMetadata?.rootWorkflowId ?? workflowId;
+    this.executionLogger.system("agent.call.started", "Remote agent call started", {
+      target,
+      agentNodeId: agentId,
+      executionId,
+      parentExecutionId: parentMetadata?.executionId,
+      runId,
+      workflowId,
+      rootWorkflowId,
+      reasonerId: name
     });
+    try {
+      const result = await this.agentFieldClient.execute(target, input, {
+        runId,
+        workflowId,
+        rootWorkflowId,
+        parentExecutionId: parentMetadata?.executionId,
+        reasonerId: name,
+        sessionId: parentMetadata?.sessionId,
+        actorId: parentMetadata?.actorId,
+        callerDid: parentMetadata?.callerDid,
+        targetDid: parentMetadata?.targetDid,
+        agentNodeDid: parentMetadata?.agentNodeDid,
+        agentNodeId: this.config.nodeId
+      });
+      this.executionLogger.system("agent.call.completed", "Remote agent call completed", {
+        target,
+        agentNodeId: agentId,
+        executionId,
+        parentExecutionId: parentMetadata?.executionId,
+        runId,
+        workflowId,
+        rootWorkflowId,
+        reasonerId: name
+      });
+      return result;
+    } catch (err) {
+      this.executionLogger.error("Remote agent call failed", {
+        target,
+        agentNodeId: agentId,
+        executionId,
+        parentExecutionId: parentMetadata?.executionId,
+        runId,
+        workflowId,
+        rootWorkflowId,
+        reasonerId: name,
+        error: err instanceof Error ? err.message : String(err)
+      }, {
+        eventType: "agent.call.failed",
+        source: "sdk.runtime",
+        systemGenerated: true
+      });
+      throw err;
+    }
   }
   registerDefaultRoutes() {
     this.app.get("/health", (_req, res) => {
@@ -3762,22 +4275,22 @@ var Agent = class {
         },
         message: { error: "rate_limit_exceeded", message: "Too many authentication attempts. Try again later." },
         skip: (req) => {
-          const path2 = req.path;
-          if (!path2.startsWith("/reasoners/") && !path2.startsWith("/skills/") && !path2.startsWith("/execute") && !path2.startsWith("/api/v1/reasoners/") && !path2.startsWith("/api/v1/skills/")) {
+          const path3 = req.path;
+          if (!path3.startsWith("/reasoners/") && !path3.startsWith("/skills/") && !path3.startsWith("/execute") && !path3.startsWith("/api/v1/reasoners/") && !path3.startsWith("/api/v1/skills/")) {
             return true;
           }
-          const parts = path2.replace(/^\/+/, "").split("/");
+          const parts = path3.replace(/^\/+/, "").split("/");
           const funcName = parts[parts.length - 1] ?? "";
           return realtimeFunctions.has(funcName);
         }
       });
       this.app.use(authRateLimiter);
       this.app.use(async (req, res, next) => {
-        const path2 = req.path;
-        if (!path2.startsWith("/reasoners/") && !path2.startsWith("/skills/") && !path2.startsWith("/execute") && !path2.startsWith("/api/v1/reasoners/") && !path2.startsWith("/api/v1/skills/")) {
+        const path3 = req.path;
+        if (!path3.startsWith("/reasoners/") && !path3.startsWith("/skills/") && !path3.startsWith("/execute") && !path3.startsWith("/api/v1/reasoners/") && !path3.startsWith("/api/v1/skills/")) {
           return next();
         }
-        const parts = path2.replace(/^\/+/, "").split("/");
+        const parts = path3.replace(/^\/+/, "").split("/");
         const funcName = parts[parts.length - 1] ?? "";
         if (realtimeFunctions.has(funcName)) {
           return next();
@@ -3947,13 +4460,16 @@ var Agent = class {
     const executionId = overrides?.executionId ?? normalized["x-execution-id"] ?? randomUUID();
     const runId = overrides?.runId ?? normalized["x-run-id"] ?? executionId;
     const workflowId = overrides?.workflowId ?? normalized["x-workflow-id"] ?? runId;
+    const rootWorkflowId = overrides?.rootWorkflowId ?? normalized["x-root-workflow-id"] ?? workflowId;
     return {
       executionId,
       runId,
       workflowId,
+      rootWorkflowId,
       sessionId: overrides?.sessionId ?? normalized["x-session-id"],
       actorId: overrides?.actorId ?? normalized["x-actor-id"],
       parentExecutionId: overrides?.parentExecutionId ?? normalized["x-parent-execution-id"],
+      reasonerId: overrides?.reasonerId ?? normalized["x-reasoner-id"],
       callerDid: overrides?.callerDid ?? normalized["x-caller-did"],
       targetDid: overrides?.targetDid ?? normalized["x-target-did"],
       agentNodeDid: overrides?.agentNodeDid ?? normalized["x-agent-node-did"] ?? normalized["x-agent-did"]
@@ -3964,9 +4480,9 @@ var Agent = class {
     return handler(req, res);
   }
   async handleServerlessEvent(event) {
-    const path2 = event?.path ?? event?.rawPath ?? "";
+    const path3 = event?.path ?? event?.rawPath ?? "";
     const action = event?.action ?? "";
-    if (path2 === "/discover" || action === "discover") {
+    if (path3 === "/discover" || action === "discover") {
       return {
         statusCode: 200,
         headers: { "content-type": "application/json" },
@@ -3975,7 +4491,7 @@ var Agent = class {
     }
     const body = this.normalizeEventBody(event);
     const invocation = this.extractInvocationDetails({
-      path: path2,
+      path: path3,
       query: event?.queryStringParameters,
       body,
       reasoner: event?.reasoner,
@@ -4031,7 +4547,9 @@ var Agent = class {
       executionId: ctx.executionId ?? ctx.execution_id ?? ctx.executionId,
       runId: ctx.runId ?? ctx.run_id,
       workflowId: ctx.workflowId ?? ctx.workflow_id,
+      rootWorkflowId: ctx.rootWorkflowId ?? ctx.root_workflow_id,
       parentExecutionId: ctx.parentExecutionId ?? ctx.parent_execution_id,
+      reasonerId: ctx.reasonerId ?? ctx.reasoner_id,
       sessionId: ctx.sessionId ?? ctx.session_id,
       actorId: ctx.actorId ?? ctx.actor_id,
       callerDid: ctx.callerDid ?? ctx.caller_did,
@@ -4065,9 +4583,9 @@ var Agent = class {
     const input = this.normalizeInputPayload(params.body);
     return { name: name ?? void 0, targetType: typeValue, input };
   }
-  parsePathTarget(path2) {
-    if (!path2) return {};
-    const normalized = path2.split("?")[0];
+  parsePathTarget(path3) {
+    if (!path3) return {};
+    const normalized = path3.split("?")[0];
     const reasonerMatch = normalized.match(/\/reasoners\/([^/]+)/);
     if (reasonerMatch?.[1]) {
       return { name: reasonerMatch[1], targetType: "reasoner" };
@@ -4178,41 +4696,107 @@ var Agent = class {
   async runReasoner(reasoner, params) {
     const req = params.req ?? {};
     const res = params.res ?? {};
+    const executionMetadata = {
+      ...params.metadata,
+      rootWorkflowId: params.metadata.rootWorkflowId ?? params.metadata.workflowId ?? params.metadata.runId ?? params.metadata.executionId,
+      reasonerId: params.metadata.reasonerId ?? params.targetName
+    };
     const execCtx = new ExecutionContext({
       input: params.input,
-      metadata: params.metadata,
+      metadata: executionMetadata,
       req,
       res,
       agent: this
     });
     return ExecutionContext.run(execCtx, async () => {
+      this.executionLogger.system("execution.started", "Execution started", {
+        target: params.targetName,
+        reasonerId: executionMetadata.reasonerId,
+        executionId: executionMetadata.executionId,
+        parentExecutionId: executionMetadata.parentExecutionId,
+        runId: executionMetadata.runId,
+        workflowId: executionMetadata.workflowId,
+        rootWorkflowId: executionMetadata.rootWorkflowId
+      });
+      this.executionLogger.system("reasoner.started", "Reasoner execution started", {
+        target: params.targetName,
+        executionId: executionMetadata.executionId,
+        runId: executionMetadata.runId,
+        workflowId: executionMetadata.workflowId,
+        rootWorkflowId: executionMetadata.rootWorkflowId
+      });
       try {
         const ctx = new ReasonerContext({
           input: params.input,
-          executionId: params.metadata.executionId,
-          runId: params.metadata.runId,
-          sessionId: params.metadata.sessionId,
-          actorId: params.metadata.actorId,
-          workflowId: params.metadata.workflowId,
-          parentExecutionId: params.metadata.parentExecutionId,
-          callerDid: params.metadata.callerDid,
-          targetDid: params.metadata.targetDid,
-          agentNodeDid: params.metadata.agentNodeDid,
+          executionId: executionMetadata.executionId,
+          runId: executionMetadata.runId,
+          sessionId: executionMetadata.sessionId,
+          actorId: executionMetadata.actorId,
+          workflowId: executionMetadata.workflowId,
+          rootWorkflowId: executionMetadata.rootWorkflowId,
+          parentExecutionId: executionMetadata.parentExecutionId,
+          reasonerId: executionMetadata.reasonerId,
+          callerDid: executionMetadata.callerDid,
+          targetDid: executionMetadata.targetDid,
+          agentNodeDid: executionMetadata.agentNodeDid,
           req,
           res,
           agent: this,
+          logger: this.executionLogger,
           aiClient: this.aiClient,
-          memory: this.getMemoryInterface(params.metadata),
-          workflow: this.getWorkflowReporter(params.metadata),
-          did: this.getDidInterface(params.metadata, params.input, params.targetName)
+          memory: this.getMemoryInterface(executionMetadata),
+          workflow: this.getWorkflowReporter(executionMetadata),
+          did: this.getDidInterface(executionMetadata, params.input, params.targetName)
         });
         const result = await reasoner.handler(ctx);
+        this.executionLogger.system("reasoner.completed", "Reasoner execution completed", {
+          target: params.targetName,
+          executionId: executionMetadata.executionId,
+          runId: executionMetadata.runId,
+          workflowId: executionMetadata.workflowId,
+          rootWorkflowId: executionMetadata.rootWorkflowId
+        });
+        this.executionLogger.system("execution.completed", "Execution completed", {
+          target: params.targetName,
+          reasonerId: executionMetadata.reasonerId,
+          executionId: executionMetadata.executionId,
+          runId: executionMetadata.runId,
+          workflowId: executionMetadata.workflowId,
+          rootWorkflowId: executionMetadata.rootWorkflowId
+        });
         if (params.respond && params.res) {
           params.res.json(result);
           return;
         }
         return result;
       } catch (err) {
+        this.executionLogger.error("Reasoner execution failed", {
+          target: params.targetName,
+          executionId: executionMetadata.executionId,
+          parentExecutionId: executionMetadata.parentExecutionId,
+          runId: executionMetadata.runId,
+          workflowId: executionMetadata.workflowId,
+          rootWorkflowId: executionMetadata.rootWorkflowId,
+          error: err?.message ?? "Execution failed"
+        }, {
+          eventType: "reasoner.failed",
+          source: "sdk.runtime",
+          systemGenerated: true
+        });
+        this.executionLogger.error("Execution failed", {
+          target: params.targetName,
+          reasonerId: executionMetadata.reasonerId,
+          executionId: executionMetadata.executionId,
+          parentExecutionId: executionMetadata.parentExecutionId,
+          runId: executionMetadata.runId,
+          workflowId: executionMetadata.workflowId,
+          rootWorkflowId: executionMetadata.rootWorkflowId,
+          error: err?.message ?? "Execution failed"
+        }, {
+          eventType: "execution.failed",
+          source: "sdk.runtime",
+          systemGenerated: true
+        });
         if (params.respond && params.res) {
           const body = { error: err?.message ?? "Execution failed" };
           if (err?.responseData) body.error_details = err.responseData;
@@ -4227,34 +4811,100 @@ var Agent = class {
   async runSkill(skill, params) {
     const req = params.req ?? {};
     const res = params.res ?? {};
+    const executionMetadata = {
+      ...params.metadata,
+      rootWorkflowId: params.metadata.rootWorkflowId ?? params.metadata.workflowId ?? params.metadata.runId ?? params.metadata.executionId,
+      reasonerId: params.metadata.reasonerId ?? params.targetName
+    };
     const execCtx = new ExecutionContext({
       input: params.input,
-      metadata: params.metadata,
+      metadata: executionMetadata,
       req,
       res,
       agent: this
     });
     return ExecutionContext.run(execCtx, async () => {
+      this.executionLogger.system("execution.started", "Execution started", {
+        target: params.targetName,
+        reasonerId: executionMetadata.reasonerId,
+        executionId: executionMetadata.executionId,
+        parentExecutionId: executionMetadata.parentExecutionId,
+        runId: executionMetadata.runId,
+        workflowId: executionMetadata.workflowId,
+        rootWorkflowId: executionMetadata.rootWorkflowId
+      });
+      this.executionLogger.system("skill.started", "Skill execution started", {
+        target: params.targetName,
+        executionId: executionMetadata.executionId,
+        runId: executionMetadata.runId,
+        workflowId: executionMetadata.workflowId,
+        rootWorkflowId: executionMetadata.rootWorkflowId
+      });
       try {
         const ctx = new SkillContext({
           input: params.input,
-          executionId: params.metadata.executionId,
-          sessionId: params.metadata.sessionId,
-          workflowId: params.metadata.workflowId,
+          executionId: executionMetadata.executionId,
+          sessionId: executionMetadata.sessionId,
+          workflowId: executionMetadata.workflowId,
+          rootWorkflowId: executionMetadata.rootWorkflowId,
+          reasonerId: executionMetadata.reasonerId,
           req,
           res,
           agent: this,
-          memory: this.getMemoryInterface(params.metadata),
-          workflow: this.getWorkflowReporter(params.metadata),
-          did: this.getDidInterface(params.metadata, params.input, params.targetName)
+          logger: this.executionLogger,
+          memory: this.getMemoryInterface(executionMetadata),
+          workflow: this.getWorkflowReporter(executionMetadata),
+          did: this.getDidInterface(executionMetadata, params.input, params.targetName)
         });
         const result = await skill.handler(ctx);
+        this.executionLogger.system("skill.completed", "Skill execution completed", {
+          target: params.targetName,
+          executionId: executionMetadata.executionId,
+          runId: executionMetadata.runId,
+          workflowId: executionMetadata.workflowId,
+          rootWorkflowId: executionMetadata.rootWorkflowId
+        });
+        this.executionLogger.system("execution.completed", "Execution completed", {
+          target: params.targetName,
+          reasonerId: executionMetadata.reasonerId,
+          executionId: executionMetadata.executionId,
+          runId: executionMetadata.runId,
+          workflowId: executionMetadata.workflowId,
+          rootWorkflowId: executionMetadata.rootWorkflowId
+        });
         if (params.respond && params.res) {
           params.res.json(result);
           return;
         }
         return result;
       } catch (err) {
+        this.executionLogger.error("Skill execution failed", {
+          target: params.targetName,
+          executionId: executionMetadata.executionId,
+          parentExecutionId: executionMetadata.parentExecutionId,
+          runId: executionMetadata.runId,
+          workflowId: executionMetadata.workflowId,
+          rootWorkflowId: executionMetadata.rootWorkflowId,
+          error: err?.message ?? "Execution failed"
+        }, {
+          eventType: "skill.failed",
+          source: "sdk.runtime",
+          systemGenerated: true
+        });
+        this.executionLogger.error("Execution failed", {
+          target: params.targetName,
+          reasonerId: executionMetadata.reasonerId,
+          executionId: executionMetadata.executionId,
+          parentExecutionId: executionMetadata.parentExecutionId,
+          runId: executionMetadata.runId,
+          workflowId: executionMetadata.workflowId,
+          rootWorkflowId: executionMetadata.rootWorkflowId,
+          error: err?.message ?? "Execution failed"
+        }, {
+          eventType: "execution.failed",
+          source: "sdk.runtime",
+          systemGenerated: true
+        });
         if (params.respond && params.res) {
           const body = { error: err?.message ?? "Execution failed" };
           if (err?.responseData) body.error_details = err.responseData;
@@ -4321,7 +4971,7 @@ var Agent = class {
     const timeoutMs = 5 * 60 * 1e3;
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
-      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+      await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
       try {
         const node = await this.agentFieldClient.getNode(this.config.nodeId);
         const status = node?.lifecycle_status;
@@ -4412,6 +5062,589 @@ var AgentRouter = class {
 function sanitize(value) {
   return value.replace(/[^0-9a-zA-Z]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
 }
+var IMAGE_MIME_TYPES = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".bmp": "image/bmp"
+};
+var AUDIO_MIME_TYPES = {
+  ".wav": "audio/wav",
+  ".mp3": "audio/mpeg",
+  ".flac": "audio/flac",
+  ".ogg": "audio/ogg"
+};
+var Text = class {
+  type = "text";
+  text;
+  constructor(text2) {
+    this.text = text2;
+  }
+};
+var Image = class _Image {
+  type = "image_url";
+  imageUrl;
+  constructor(imageUrl) {
+    this.imageUrl = imageUrl;
+  }
+  /**
+   * Create Image from a local file by converting to base64 data URL.
+   */
+  static async fromFile(filePath, detail = "high") {
+    const absolutePath = resolve(filePath);
+    const buffer = await readFile(absolutePath);
+    const base64Data = buffer.toString("base64");
+    const ext = getExtension(absolutePath).toLowerCase();
+    const mimeType = IMAGE_MIME_TYPES[ext] || "image/jpeg";
+    const dataUrl = `data:${mimeType};base64,${base64Data}`;
+    return new _Image({ url: dataUrl, detail });
+  }
+  /**
+   * Create Image from a URL.
+   */
+  static fromUrl(url, detail = "high") {
+    return new _Image({ url, detail });
+  }
+  /**
+   * Create Image from a buffer.
+   */
+  static async fromBuffer(buffer, mimeType = "image/jpeg", detail = "high") {
+    const base64Data = Buffer.from(buffer).toString("base64");
+    const dataUrl = `data:${mimeType};base64,${base64Data}`;
+    return new _Image({ url: dataUrl, detail });
+  }
+  /**
+   * Create Image from a base64 string.
+   */
+  static async fromBase64(base64Data, mimeType = "image/jpeg", detail = "high") {
+    const dataUrl = `data:${mimeType};base64,${base64Data}`;
+    return new _Image({ url: dataUrl, detail });
+  }
+};
+var Audio = class _Audio {
+  type = "input_audio";
+  audio;
+  constructor(audio) {
+    this.audio = audio;
+  }
+  /**
+   * Create Audio from a local file by converting to base64.
+   */
+  static async fromFile(filePath, format) {
+    const absolutePath = resolve(filePath);
+    const ext = getExtension(absolutePath).toLowerCase().replace(".", "");
+    const audioFormat = format || (["wav", "mp3", "flac", "ogg"].includes(ext) ? ext : "wav");
+    const buffer = await readFile(absolutePath);
+    const base64Data = buffer.toString("base64");
+    return new _Audio({ data: base64Data, format: audioFormat });
+  }
+  /**
+   * Create Audio from a URL (downloads and converts to base64).
+   */
+  static async fromUrl(url, format = "wav") {
+    try {
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(`Failed to fetch audio from URL: ${response.status} ${response.statusText}`);
+      }
+      const arrayBuffer = await response.arrayBuffer();
+      const base64Data = Buffer.from(arrayBuffer).toString("base64");
+      return new _Audio({ data: base64Data, format });
+    } catch (error) {
+      if (error instanceof TypeError && error.message.includes("fetch")) {
+        throw new Error("URL download requires a fetch-compatible environment");
+      }
+      throw error;
+    }
+  }
+  /**
+   * Create Audio from a buffer.
+   */
+  static async fromBuffer(buffer, format = "wav") {
+    const base64Data = Buffer.from(buffer).toString("base64");
+    return new _Audio({ data: base64Data, format });
+  }
+  /**
+   * Create Audio from a base64 string.
+   */
+  static async fromBase64(base64Data, format = "wav") {
+    return new _Audio({ data: base64Data, format });
+  }
+};
+var File = class _File {
+  type = "file";
+  file;
+  constructor(file) {
+    this.file = file;
+  }
+  /**
+   * Create File from a local file path.
+   */
+  static async fromFile(filePath, mimeType) {
+    const absolutePath = resolve(filePath);
+    const detectedMimeType = mimeType || guessMimeType(absolutePath) || "application/octet-stream";
+    const buffer = await readFile(absolutePath);
+    const base64Data = buffer.toString("base64");
+    const dataUrl = `data:${detectedMimeType};base64,${base64Data}`;
+    return new _File({ url: dataUrl, mimeType: detectedMimeType });
+  }
+  /**
+   * Create File from a URL.
+   */
+  static fromUrl(url, mimeType) {
+    return new _File({ url, mimeType });
+  }
+  /**
+   * Create File from a buffer.
+   */
+  static async fromBuffer(buffer, mimeType) {
+    const base64Data = Buffer.from(buffer).toString("base64");
+    const dataUrl = `data:${mimeType};base64,${base64Data}`;
+    return new _File({ url: dataUrl, mimeType });
+  }
+  /**
+   * Create File from a base64 string.
+   */
+  static async fromBase64(base64Data, mimeType) {
+    const dataUrl = `data:${mimeType};base64,${base64Data}`;
+    return new _File({ url: dataUrl, mimeType });
+  }
+};
+function getExtension(filePath) {
+  const lastDot = filePath.lastIndexOf(".");
+  if (lastDot === -1) {
+    return "";
+  }
+  return filePath.slice(lastDot);
+}
+function guessMimeType(filePath) {
+  const ext = getExtension(filePath).toLowerCase();
+  if (ext in IMAGE_MIME_TYPES) {
+    return IMAGE_MIME_TYPES[ext];
+  }
+  if (ext in AUDIO_MIME_TYPES) {
+    return AUDIO_MIME_TYPES[ext];
+  }
+  const documentMimeTypes = {
+    ".pdf": "application/pdf",
+    ".doc": "application/msword",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".xls": "application/vnd.ms-excel",
+    ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ".txt": "text/plain",
+    ".csv": "text/csv",
+    ".html": "text/html",
+    ".json": "application/json",
+    ".xml": "application/xml",
+    ".zip": "application/zip"
+  };
+  return documentMimeTypes[ext] || null;
+}
+function text(content) {
+  return new Text(content);
+}
+async function imageFromFile(filePath, detail = "high") {
+  return Image.fromFile(filePath, detail);
+}
+function imageFromUrl(url, detail = "high") {
+  return Image.fromUrl(url, detail);
+}
+async function imageFromBuffer(buffer, mimeType = "image/jpeg", detail = "high") {
+  return Image.fromBuffer(buffer, mimeType, detail);
+}
+async function imageFromBase64(base64Data, mimeType, detail = "high") {
+  return Image.fromBase64(base64Data, mimeType, detail);
+}
+async function audioFromFile(filePath, format) {
+  return Audio.fromFile(filePath, format);
+}
+async function audioFromUrl(url, format = "wav") {
+  return Audio.fromUrl(url, format);
+}
+async function audioFromBuffer(buffer, format = "wav") {
+  return Audio.fromBuffer(buffer, format);
+}
+async function audioFromBase64(base64Data, format = "wav") {
+  return Audio.fromBase64(base64Data, format);
+}
+async function fileFromPath(filePath, mimeType) {
+  return File.fromFile(filePath, mimeType);
+}
+function fileFromUrl(url, mimeType) {
+  return File.fromUrl(url, mimeType);
+}
+async function fileFromBuffer(buffer, mimeType) {
+  return File.fromBuffer(buffer, mimeType);
+}
+async function fileFromBase64(base64Data, mimeType) {
+  return File.fromBase64(base64Data, mimeType);
+}
+var MultimodalResponse = class {
+  _text;
+  _audio;
+  _images;
+  _files;
+  _rawResponse;
+  _costUsd;
+  _usage;
+  constructor(text2 = "", audio = null, images = [], files = [], rawResponse = null, costUsd = null, usage = {}) {
+    this._text = text2;
+    this._audio = audio;
+    this._images = images;
+    this._files = files;
+    this._rawResponse = rawResponse;
+    this._costUsd = costUsd;
+    this._usage = usage;
+  }
+  /**
+   * Get text content.
+   */
+  get text() {
+    return this._text;
+  }
+  /**
+   * Get audio output if available.
+   */
+  get audio() {
+    return this._audio;
+  }
+  /**
+   * Get list of image outputs.
+   */
+  get images() {
+    return this._images;
+  }
+  /**
+   * Get list of file outputs.
+   */
+  get files() {
+    return this._files;
+  }
+  /**
+   * Check if response contains audio.
+   */
+  hasAudio() {
+    return this._audio !== null;
+  }
+  /**
+   * Check if response contains images.
+   */
+  hasImage() {
+    return this._images.length > 0;
+  }
+  /**
+   * Check if response contains files.
+   */
+  hasFile() {
+    return this._files.length > 0;
+  }
+  /**
+   * Check if response contains any multimodal content.
+   */
+  isMultimodal() {
+    return this.hasAudio() || this.hasImage() || this.hasFile();
+  }
+  /**
+   * Get the raw LLM response object.
+   */
+  get rawResponse() {
+    return this._rawResponse;
+  }
+  /**
+   * Estimated cost of this LLM call in USD, if available.
+   */
+  get costUsd() {
+    return this._costUsd;
+  }
+  /**
+   * Token usage breakdown.
+   */
+  get usage() {
+    return this._usage;
+  }
+  /**
+   * Get all images.
+   * Alias for images property for API consistency.
+   */
+  getImages() {
+    return this._images;
+  }
+  /**
+   * Get audio.
+   * Alias for audio property for API consistency.
+   */
+  getAudio() {
+    return this._audio;
+  }
+  /**
+   * Get all files.
+   * Alias for files property for API consistency.
+   */
+  getFiles() {
+    return this._files;
+  }
+  /**
+   * Get raw image bytes from an ImageOutput.
+   */
+  decodeBase64(data) {
+    return new Uint8Array(Buffer.from(data, "base64"));
+  }
+  async getUrlBytes(sourceUrl) {
+    if (sourceUrl.startsWith("data:")) {
+      const base64Data = sourceUrl.split(",", 2)[1];
+      if (!base64Data) {
+        throw new Error("Invalid data URL");
+      }
+      return this.decodeBase64(base64Data);
+    }
+    const response = await fetch(sourceUrl);
+    if (!response.ok) {
+      throw new Error(`Failed to download multimodal asset: ${response.status} ${response.statusText}`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    return new Uint8Array(arrayBuffer);
+  }
+  async getImageBytes(image) {
+    if (image.b64Json) {
+      return this.decodeBase64(image.b64Json);
+    } else if (image.url) {
+      return this.getUrlBytes(image.url);
+    }
+    throw new Error("No image data available");
+  }
+  /**
+   * Get raw audio bytes from an AudioOutput.
+   */
+  async getAudioBytes(audio) {
+    if (audio.data) {
+      return this.decodeBase64(audio.data);
+    }
+    if (audio.url) {
+      return this.getUrlBytes(audio.url);
+    }
+    throw new Error("No audio data available");
+  }
+  /**
+   * Get raw file bytes from a FileOutput.
+   */
+  async getFileBytes(file) {
+    if (file.data) {
+      return this.decodeBase64(file.data);
+    }
+    if (file.url) {
+      return this.getUrlBytes(file.url);
+    }
+    throw new Error("No file data available");
+  }
+  /**
+   * Save a single image to file.
+   */
+  async saveImage(image, imagePath) {
+    const bytes = await this.getImageBytes(image);
+    await promises.mkdir(path2.dirname(imagePath), { recursive: true });
+    await promises.writeFile(imagePath, bytes);
+  }
+  /**
+   * Save a single audio to file.
+   */
+  async saveAudio(audio, audioPath) {
+    const bytes = await this.getAudioBytes(audio);
+    await promises.mkdir(path2.dirname(audioPath), { recursive: true });
+    await promises.writeFile(audioPath, bytes);
+  }
+  /**
+   * Save a single file to disk.
+   */
+  async saveFile(file, filePath) {
+    const bytes = await this.getFileBytes(file);
+    await promises.mkdir(path2.dirname(filePath), { recursive: true });
+    await promises.writeFile(filePath, bytes);
+  }
+  /**
+   * Save all multimodal content to a directory.
+   * Returns a dict mapping content type to saved file paths.
+   */
+  async save(outputDir, prefix = "output") {
+    const savedFiles = {};
+    await promises.mkdir(outputDir, { recursive: true });
+    if (this._audio) {
+      const audioPath = path2.join(outputDir, `${prefix}_audio.${this._audio.format}`);
+      await this.saveAudio(this._audio, audioPath);
+      savedFiles["audio"] = audioPath;
+    }
+    for (let i = 0; i < this._images.length; i++) {
+      const image = this._images[i];
+      let ext = "png";
+      if (image.url) {
+        const urlExt = path2.extname(image.url).slice(1);
+        if (urlExt) ext = urlExt;
+      }
+      const imagePath = path2.join(outputDir, `${prefix}_image_${i}.${ext}`);
+      await this.saveImage(image, imagePath);
+      savedFiles[`image_${i}`] = imagePath;
+    }
+    for (let i = 0; i < this._files.length; i++) {
+      const file = this._files[i];
+      const filename = file.filename || `${prefix}_file_${i}`;
+      const filePath = path2.join(outputDir, filename);
+      await this.saveFile(file, filePath);
+      savedFiles[`file_${i}`] = filePath;
+    }
+    if (this._text) {
+      const textPath = path2.join(outputDir, `${prefix}_text.txt`);
+      await promises.writeFile(textPath, this._text, "utf-8");
+      savedFiles["text"] = textPath;
+    }
+    return savedFiles;
+  }
+  /**
+   * String representation for backward compatibility.
+   */
+  toString() {
+    return this._text;
+  }
+  /**
+   * Developer-friendly representation.
+   */
+  toJSON() {
+    const parts = [];
+    if (this._audio) parts.push(`audio=${this._audio.format}`);
+    if (this._images.length > 0) parts.push(`images=${this._images.length}`);
+    if (this._files.length > 0) parts.push(`files=${this._files.length}`);
+    return {
+      text: this._text,
+      audio: this._audio,
+      images: this._images,
+      files: this._files,
+      _debug: `MultimodalResponse(${parts.join(", ")})`
+    };
+  }
+};
+function createMultimodalResponse(rawResponse, text2 = "") {
+  let audio = null;
+  let images = [];
+  let files = [];
+  const extractedImages = extractImages(rawResponse);
+  if (extractedImages.length > 0) {
+    images = extractedImages;
+  }
+  const extractedAudio = extractAudio(rawResponse);
+  if (extractedAudio) {
+    audio = extractedAudio;
+  }
+  const extractedFiles = extractFiles(rawResponse);
+  if (extractedFiles.length > 0) {
+    files = extractedFiles;
+  }
+  return new MultimodalResponse(text2, audio, images, files, rawResponse);
+}
+function extractImages(data) {
+  const images = [];
+  if (!data) return images;
+  if (Array.isArray(data)) {
+    for (const item of data) {
+      const extracted = extractSingleImage(item);
+      if (extracted) images.push(extracted);
+    }
+    return images;
+  }
+  if (typeof data === "object") {
+    const obj = data;
+    if (Array.isArray(obj.images)) {
+      for (const img of obj.images) {
+        const extracted = extractSingleImage(img);
+        if (extracted) images.push(extracted);
+      }
+    }
+    if (obj.image_url) {
+      const extracted = extractSingleImage(obj.image_url);
+      if (extracted) images.push(extracted);
+    }
+    if (obj.url || obj.b64_json || obj.b64Json) {
+      const extracted = extractSingleImage(obj);
+      if (extracted) images.push(extracted);
+    }
+  }
+  return images;
+}
+function extractSingleImage(data) {
+  if (!data) return null;
+  if (typeof data === "string") {
+    if (data.startsWith("http") || data.startsWith("data:")) {
+      return { url: data };
+    }
+    return null;
+  }
+  if (typeof data === "object") {
+    const obj = data;
+    if (obj.image_url) {
+      const imageUrl = obj.image_url;
+      const url2 = imageUrl.url;
+      if (url2) {
+        if (url2.startsWith("data:image")) {
+          const base64Data = url2.split(",", 2)[1];
+          return { url: url2, b64Json: base64Data || void 0 };
+        }
+        return { url: url2 };
+      }
+    }
+    const url = obj.url || obj.image_url;
+    const b64Json = obj.b64_json || obj.b64Json;
+    const revisedPrompt = obj.revised_prompt || obj.revisedPrompt;
+    if (url || b64Json) {
+      return { url, b64Json, revisedPrompt };
+    }
+  }
+  return null;
+}
+function extractAudio(data) {
+  if (!data || typeof data !== "object") return null;
+  const obj = data;
+  if (obj.audio && typeof obj.audio === "object") {
+    const audio = obj.audio;
+    return {
+      data: audio.data,
+      format: audio.format || "wav",
+      url: audio.url
+    };
+  }
+  if (obj.input_audio && typeof obj.input_audio === "object") {
+    const inputAudio = obj.input_audio;
+    return {
+      data: inputAudio.data,
+      format: inputAudio.format || "wav"
+    };
+  }
+  return null;
+}
+function extractFiles(data) {
+  const files = [];
+  if (!data) return files;
+  if (typeof data === "object") {
+    const obj = data;
+    if (Array.isArray(obj.files)) {
+      for (const file of obj.files) {
+        const extracted = extractSingleFile(file);
+        if (extracted) files.push(extracted);
+      }
+    }
+  }
+  return files;
+}
+function extractSingleFile(data) {
+  if (!data || typeof data !== "object") return null;
+  const obj = data;
+  const url = obj.url;
+  const data_b64 = obj.data;
+  const mimeType = obj.mime_type || obj.mimeType;
+  const filename = obj.filename;
+  if (url || data_b64) {
+    return { url, data: data_b64, mimeType, filename };
+  }
+  return null;
+}
 
 // src/harness/index.ts
 init_types();
@@ -4574,9 +5807,9 @@ var ApprovalClient = class {
   }
 };
 function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 
-export { ACTIVE_STATUSES, AIClient, Agent, AgentRouter, ApprovalClient, CANONICAL_STATUSES, DIDAuthenticator, DidClient, DidInterface, DidManager, ExecutionContext, ExecutionStatus, HEADER_CALLER_DID, HEADER_DID_NONCE, HEADER_DID_SIGNATURE, HEADER_DID_TIMESTAMP, HarnessRunner, MCPClient, MCPClientRegistry, MCPToolRegistrar, MemoryClient, MemoryClientBase, MemoryEventClient, MemoryInterface, RateLimitError, ReasonerContext, SUPPORTED_PROVIDERS, SkillContext, StatelessRateLimiter, TERMINAL_STATUSES, WorkflowReporter, buildProvider, buildToolConfig, capabilitiesToTools, capabilityToMetadataTool, capabilityToTool, createHarnessResult, createMetrics, createRawResult, executeToolCallLoop, getCurrentContext, getCurrentSkillContext, isActive, isTerminal, normalizeStatus };
+export { ACTIVE_STATUSES, AIClient, Agent, AgentRouter, ApprovalClient, Audio, CANONICAL_STATUSES, DIDAuthenticator, DidClient, DidInterface, DidManager, ExecutionContext, ExecutionLogger, ExecutionStatus, File, HEADER_CALLER_DID, HEADER_DID_NONCE, HEADER_DID_SIGNATURE, HEADER_DID_TIMESTAMP, HarnessRunner, Image, MCPClient, MCPClientRegistry, MCPToolRegistrar, MemoryClient, MemoryClientBase, MemoryEventClient, MemoryInterface, MultimodalResponse, RateLimitError, ReasonerContext, SUPPORTED_PROVIDERS, SkillContext, StatelessRateLimiter, TERMINAL_STATUSES, Text, WorkflowReporter, audioFromBase64, audioFromBuffer, audioFromFile, audioFromUrl, buildProvider, buildToolConfig, capabilitiesToTools, capabilityToMetadataTool, capabilityToTool, createExecutionLogger, createHarnessResult, createMetrics, createMultimodalResponse, createRawResult, executeToolCallLoop, fileFromBase64, fileFromBuffer, fileFromPath, fileFromUrl, getCurrentContext, getCurrentSkillContext, imageFromBase64, imageFromBuffer, imageFromFile, imageFromUrl, isActive, isExecutionLogBatchPayload, isTerminal, normalizeExecutionLogEntry, normalizeStatus, serializeExecutionLogEntry, text };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map