@botpress/adk 1.16.6 → 1.16.7

package/dist/index.js

@@ -682,7 +682,16 @@ var init_fs = () => {};
 
 // src/generators/utils.ts
 import path10 from "path";
-import { format } from "prettier";
+async function getFormat() {
+  if (!_formatLoaded) {
+    _formatLoaded = true;
+    try {
+      const oxfmt = await import("oxfmt");
+      _format = oxfmt.format;
+    } catch {}
+  }
+  return _format;
+}
 function toMultilineComment(comment) {
   if (!comment || comment.trim() === "") {
     return "";
@@ -702,40 +711,30 @@ function toMultilineComment(comment) {
   result += " */";
   return result;
 }
-var PRETTIER_CONFIG, formatCode = async (code, filepath) => {
+var _format = null, _formatLoaded = false, formatCode = async (code, filepath) => {
   try {
     if (!code || code.length > 1e6) {
       return code;
     }
-    return await format(code, {
-      ...PRETTIER_CONFIG,
-      filepath: filepath || "file.ts"
-    });
+    const format = await getFormat();
+    if (!format)
+      return code;
+    const fileName = filepath || "file.ts";
+    const result = await format(fileName, code);
+    return result.code;
   } catch (err) {
-    console.warn("Failed to format code with Prettier:", err);
+    console.warn("Failed to format code with oxfmt:", err);
     console.warn(code.slice(0, 1000).split(`
 `).map((l, i) => `	${i.toString().padStart(2, "0")} | ${l}`).join(`
 `));
     return code;
   }
-}, ADK_VERSION = "1.16.6", relative2 = (from, to) => {
+}, ADK_VERSION = "1.16.7", relative2 = (from, to) => {
   const fromDir = path10.dirname(from);
   const relative3 = path10.relative(fromDir, to);
   return relative3.startsWith(".") ? relative3 : `./${relative3}`;
 };
-var init_utils = __esm(() => {
-  PRETTIER_CONFIG = {
-    semi: true,
-    singleQuote: false,
-    tabWidth: 2,
-    trailingComma: "es5",
-    printWidth: 80,
-    arrowParens: "always",
-    requirePragma: false,
-    insertPragma: false,
-    proseWrap: "preserve"
-  };
-});
+var init_utils = () => {};
 
 // src/generators/action-types.ts
 var exports_action_types = {};
@@ -861,7 +860,7 @@ var init_integration_action_types = __esm(() => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@botpress/adk",
-    version: "1.16.6",
+    version: "1.16.7",
     description: "Core ADK library for building AI agents on Botpress",
     type: "module",
     main: "dist/index.js",
@@ -907,11 +906,11 @@ var require_package = __commonJS((exports, module) => {
     },
     dependencies: {
       "@botpress/chat": "^0.5.5",
-      "@botpress/cli": "^5.2.0",
-      "@botpress/client": "^1.35.0",
-      "@botpress/cognitive": "^0.3.14",
-      "@botpress/runtime": "^1.16.6",
-      "@botpress/sdk": "^5.4.3",
+      "@botpress/cli": "5.2.0",
+      "@botpress/client": "1.35.0",
+      "@botpress/cognitive": "0.3.14",
+      "@botpress/runtime": "^1.16.7",
+      "@botpress/sdk": "5.4.3",
       "@bpinternal/jex": "^1.2.4",
       "@bpinternal/yargs-extra": "^0.0.21",
       "@parcel/watcher": "^2.5.1",
@@ -920,7 +919,7 @@ var require_package = __commonJS((exports, module) => {
       execa: "9.6.1",
       glob: "^11.1.0",
       luxon: "^3.7.2",
-      prettier: "^3.7.4",
+      oxfmt: "^0.41.0",
       semver: "^7.7.2",
       "ts-morph": "^27.0.2"
     },
@@ -1154,7 +1153,7 @@ import os3 from "os";
 import path4 from "path";
 import createDebug from "debug";
 var debug = createDebug("adk:bp-cli");
-var BP_CLI_VERSION = "5.5.6";
+var BP_CLI_VERSION = "5.2.0";
 var BP_CLI_INSTALL_ALL = path4.join(os3.homedir(), ".adk", `bp-cli`);
 var BP_CLI_INSTALL_DIR = path4.join(BP_CLI_INSTALL_ALL, BP_CLI_VERSION);
 var BP_CLI_BIN_PATH = path4.join(BP_CLI_INSTALL_DIR, "node_modules", "@botpress", "cli", "bin.js");
@@ -1649,6 +1648,15 @@ class BpDevCommand extends BaseCommand {
     if (sourceMap) {
       bpArgs.push("--sourceMap");
     }
+    const consoleUrl = `http://localhost:${this.options.internalOtlpPort}`;
+    const otlpEndpoint = this.options.otlpPort ? `http://localhost:${this.options.otlpPort}` : undefined;
+    const traceLines = [`[bp-dev] Trace endpoints:`, `  ADK_CONSOLE_URL=${consoleUrl}`];
+    if (otlpEndpoint) {
+      traceLines.push(`  OTEL_EXPORTER_OTLP_ENDPOINT=${otlpEndpoint}`);
+    }
+    this.emit("stdout", traceLines.join(`
+`) + `
+`);
     this.childProcess = execa4(bpCommand, bpArgs, {
       cwd: botPath,
       env: {
@@ -1665,6 +1673,9 @@ class BpDevCommand extends BaseCommand {
         },
         WORKER_MODE: "true",
         WORKER_LIFETIME_MS: process.env.WORKER_LIFETIME_MS || "120000",
+        ADK_CONSOLE_URL: consoleUrl,
+        ...otlpEndpoint && { OTEL_EXPORTER_OTLP_ENDPOINT: otlpEndpoint },
+        ...this.options.botName && { ADK_BOT_NAME: this.options.botName },
         ADK_DIRECTORY: join2(botPath, ".."),
         AGENT_DIRECTORY: this.options.agentPath,
         NODE_OPTIONS: `${process.env.NODE_OPTIONS || ""} --enable-source-maps`.trim()
@@ -1905,6 +1916,221 @@ class BpChatCommand extends BaseCommand {
     }
   }
 }
+// src/commands/opencode-command.ts
+import { execa as execa6 } from "execa";
+
+// src/commands/opencode-config.ts
+var COPILOT_PROMPT = `You are the ADK Copilot — an expert assistant embedded in the Botpress Agent Development Kit control panel.
+
+## Who you help
+A developer building an AI agent with the ADK. They're running \`adk dev\` and have the control panel open alongside you. They can see traces, logs, integrations, workflows, and tables in the UI.
+
+## What you know
+The ADK is a high-level framework built on Botpress. An agent project has:
+- /actions — strongly-typed callable functions (Action from @botpress/runtime)
+- /tools — LLM-callable interfaces with natural language descriptions (Tool from @botpress/runtime)
+- /workflows — step-based, resumable long-running processes (Workflow from @botpress/runtime)
+- /conversations — channel-specific interaction handlers (Conversation from @botpress/runtime)
+- /tables — schema-validated data storage with semantic search (Table from @botpress/runtime)
+- /triggers — event subscription system (Trigger from @botpress/runtime)
+- /knowledge — RAG knowledge base documents
+- agent.config.ts — agent metadata, integrations, model configuration, variables
+
+The ADK compiles these high-level primitives down to Botpress SDK primitives. Default to ADK terms. Only drop to Botpress SDK concepts when the problem requires it (SDK-level errors, compilation issues, or when the developer explicitly asks).
+
+Schemas use \`z\` from @botpress/sdk (a Zod fork) — never import Zod directly.
+
+You also have access to Botpress documentation search for platform-level questions (SDK, API, integrations).
+
+## How you work
+
+**Orient on first interaction.** If you haven't yet, use \`adk_get_agent_info\` to learn the project's structure, primitives, and integrations before answering.
+
+**Conceptual vs. project questions.** Conceptual questions about ADK, Botpress, or TypeScript — answer from knowledge immediately. Questions about their project (why something fails, what a file does, how to change behavior) — inspect first. If in doubt, answer what you can immediately and inspect in parallel.
+
+**Read freely, write carefully.** Inspecting files, querying traces, and searching the hub are always safe — do them without asking. But actions that modify the project (adding integrations, editing files, executing workflows, sending messages) should be confirmed first unless the developer explicitly asked you to do it.
+
+**Debug by matching the approach to the problem:**
+- Developer gives you an error message → start from the error, don't begin at "step 1"
+- Build or type error → check the file and generated types. Traces won't help.
+- Runtime behavior is wrong ("it responds wrong") → query traces (\`adk_query_traces\`) for the conversation to find the failing span
+- Nothing happens → check dev logs (\`adk_get_dev_logs\`) for silent failures, then check if the handler is registered
+- When in doubt → start with \`adk_get_dev_logs\` with error filtering, then query traces
+
+**Integrations.** First check if the integration already exists in the project. If it does, inspect its current configuration. Only search the hub (\`adk_search_integrations\`) when adding a new integration. Get details (\`adk_get_integration\`) to understand actions, events, channels, and config requirements. Add it (\`adk_add_integration\`) after the developer confirms.
+
+**Test iteratively.** Send messages to the running bot (\`adk_send_message\`) to verify behavior. To continue a conversation, pass back both the \`conversationId\` and \`userKey\` from the previous response. Only test against the local dev bot.
+
+**Workflows.** Get the input schema first by calling \`adk_start_workflow\` without a payload, then execute by calling it again with \`payload\` set to the correct input. For workflows with no required input, pass \`payload: {}\` — omitting payload returns the schema, it does not execute.
+
+**Handle failures.** If a tool returns an error, tell the developer what happened and suggest a concrete next step (e.g., "Dev server isn't running — start it with \`adk dev\`"). Don't silently retry or ignore errors.
+
+**Edit with precision.** When modifying code, change only what's needed to solve the problem. Don't refactor surrounding code, add features, or "improve" things that weren't asked about. When writing ADK primitives, match ADK conventions. For utility code, match the patterns already in the project.
+
+## How you communicate
+
+**Lead with the answer.** First sentence is the diagnosis, the solution, or the action you took. Context and explanation come after, if needed.
+
+**Show, don't describe.** Instead of "you should add error handling," show the code change. Instead of "the trace shows a failure," show the relevant span data and what it means.
+
+**Match the developer's energy.** Short question → short answer. Detailed question → detailed response. "Why is this broken?" → diagnosis + fix. "How do workflows work?" → teach.
+
+**Hypothesize while verifying.** If you have a likely diagnosis, say so while you check. "This usually means X — checking your trace now" is better than silence followed by an answer.
+
+**When you fix something, explain what you changed and why.** Don't apply changes silently — the developer needs to understand the fix to trust it and learn from it.
+
+**When you don't know, say so plainly.** "I don't have enough context — can you share the error message?" is fine.
+
+**Skip the filler.** No "Great question!", no "Let me help you with that." Just do it.
+
+**Never read or display the contents of .env files or credentials.** If you need to verify a configuration value, ask the developer to confirm it.`;
+function buildOpenCodeConfig(options) {
+  const command = [options.adkBinPath, "mcp", "--cwd", options.agentPath];
+  if (options.devServerPort)
+    command.push("--port", String(options.devServerPort));
+  return {
+    ...options.openCodePort && {
+      server: {
+        port: options.openCodePort,
+        ...options.corsOrigins?.length && { cors: options.corsOrigins }
+      }
+    },
+    mcp: {
+      adk: {
+        type: "local",
+        command
+      }
+    },
+    agent: {
+      default: {
+        description: "ADK Copilot — helps build and debug Botpress ADK agents",
+        prompt: COPILOT_PROMPT
+      }
+    }
+  };
+}
+
+// src/commands/opencode-command.ts
+class OpenCodeCommand extends BaseCommand {
+  options;
+  childProcess = null;
+  killed = false;
+  readyEmitted = false;
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  static async isInstalled() {
+    try {
+      const cmd = process.platform === "win32" ? "where" : "which";
+      await execa6(cmd, ["opencode"]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  emitReady() {
+    if (this.readyEmitted || this.killed)
+      return;
+    this.readyEmitted = true;
+    this.emit("progress", {
+      type: "ready",
+      startTime: Date.now(),
+      data: { port: this.options.port }
+    });
+  }
+  async run() {
+    const { port, cwd, corsOrigins = [] } = this.options;
+    this.emit("progress", { type: "checking", startTime: Date.now() });
+    const installed = await OpenCodeCommand.isInstalled();
+    if (!installed) {
+      this.emit("progress", {
+        type: "error",
+        startTime: Date.now(),
+        data: { reason: "opencode not installed" }
+      });
+      return;
+    }
+    this.emit("progress", { type: "starting", startTime: Date.now() });
+    const args = ["serve", "--port", String(port)];
+    for (const origin of corsOrigins) {
+      args.push("--cors", origin);
+    }
+    const adkBin = this.options.adkBinPath || "adk";
+    const opencodeConfig = JSON.stringify(buildOpenCodeConfig({
+      adkBinPath: adkBin,
+      agentPath: cwd,
+      devServerPort: this.options.devServerPort,
+      openCodePort: port,
+      corsOrigins
+    }));
+    this.childProcess = execa6("opencode", args, {
+      cwd,
+      env: { ...process.env, OPENCODE_CONFIG_CONTENT: opencodeConfig },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    if (this.childProcess.stdout) {
+      this.childProcess.stdout.on("data", (data) => {
+        this.emit("stdout", data.toString());
+      });
+    }
+    if (this.childProcess.stderr) {
+      this.childProcess.stderr.on("data", (data) => {
+        const text = data.toString();
+        this.emit("stderr", text);
+        const lower = text.toLowerCase();
+        if (lower.includes("eaddrinuse") || lower.includes("address already in use")) {
+          this.emit("progress", {
+            type: "error",
+            startTime: Date.now(),
+            data: { reason: `Port ${port} already in use` }
+          });
+          this.kill();
+        }
+      });
+    }
+    this.childProcess.then(() => {
+      if (!this.killed && !this.readyEmitted) {
+        this.readyEmitted = true;
+        this.emit("progress", {
+          type: "error",
+          startTime: Date.now(),
+          data: { reason: "OpenCode process exited unexpectedly" }
+        });
+      }
+    }, (error) => {
+      if (this.killed)
+        return;
+      this.readyEmitted = true;
+      this.emit("progress", {
+        type: "error",
+        startTime: Date.now(),
+        data: { reason: error.message || "OpenCode process exited unexpectedly" }
+      });
+    });
+    this.pollUntilReady(port);
+  }
+  async pollUntilReady(port) {
+    const deadline = Date.now() + 15000;
+    while (!this.killed && !this.readyEmitted && Date.now() < deadline) {
+      try {
+        const res = await fetch(`http://localhost:${port}/`);
+        if (res.ok || res.status < 500) {
+          this.emitReady();
+          return;
+        }
+      } catch {}
+      await new Promise((r) => setTimeout(r, 500));
+    }
+    this.emitReady();
+  }
+  kill(signal = "SIGTERM") {
+    this.killed = true;
+    if (this.childProcess) {
+      this.childProcess.kill(signal);
+    }
+  }
+}
 // src/workspace/workspace-cache.ts
 import { Client as Client3 } from "@botpress/client";
 class WorkspaceCache {
@@ -5468,7 +5694,7 @@ class AgentProjectGenerator {
         deploy: "adk deploy"
       },
       dependencies: {
-        "@botpress/runtime": `^${"1.16.6"}`
+        "@botpress/runtime": `^${"1.16.7"}`
       },
       devDependencies: {
         typescript: "^5.9.3"
@@ -11633,7 +11859,7 @@ async function discoverWebhookId(botId, token, apiUrl) {
 }
 
 // src/eval/traces.ts
-async function fetchTraceSpans(conversationId, devServerUrl) {
+async function fetchSpans(conversationId, devServerUrl) {
   const url = `${devServerUrl}/api/traces/query?attributeName=conversationId&attributeValue=${encodeURIComponent(conversationId)}&count=1000`;
   const res = await fetch(url);
   if (!res.ok) {
@@ -11643,25 +11869,26 @@ async function fetchTraceSpans(conversationId, devServerUrl) {
   return Array.isArray(data) ? data : data.spans || [];
 }
 function extractToolCalls(spans) {
-  const toolEndSpans = spans.filter((span) => span.name === "autonomous.tool" && span.t === "end" && span.attrs?.["autonomous.tool.name"]);
+  const data = (span) => span.data && typeof span.data === "object" ? span.data : {};
+  const toolEndSpans = spans.filter((span) => span.name === "autonomous.tool" && (span.status === "ok" || span.status === "error") && data(span)["autonomous.tool.name"]);
   const seen = new Set;
   const unique = toolEndSpans.filter((span) => {
-    if (seen.has(span.spanId))
+    if (seen.has(span.id.span))
       return false;
-    seen.add(span.spanId);
+    seen.add(span.id.span);
     return true;
   });
-  return unique.sort((a, b) => (a.endNs ?? 0) - (b.endNs ?? 0)).map((span) => {
-    const attrs = span.attrs;
+  return unique.sort((a, b) => (a.timing.endedAt ?? 0) - (b.timing.endedAt ?? 0)).map((span) => {
+    const d = data(span);
     let input = {};
     try {
-      input = JSON.parse(attrs["autonomous.tool.input"]);
+      input = JSON.parse(d["autonomous.tool.input"]);
     } catch {}
     return {
-      name: attrs["autonomous.tool.name"],
+      name: d["autonomous.tool.name"],
       input,
-      output: attrs["autonomous.tool.output"] || "",
-      status: attrs["autonomous.tool.status"] || "unknown"
+      output: d["autonomous.tool.output"] || "",
+      status: d["autonomous.tool.status"] || "unknown"
     };
   });
 }
@@ -11676,7 +11903,7 @@ async function getTraceData(conversationId, devServerUrl, options = {}) {
     if (attempt > 0) {
       await new Promise((resolve4) => setTimeout(resolve4, retryDelay));
     }
-    spans = await fetchTraceSpans(conversationId, devServerUrl);
+    spans = await fetchSpans(conversationId, devServerUrl);
     allToolCalls = extractToolCalls(spans);
     if (!expectNew || allToolCalls.length > previousCount) {
       break;
@@ -12199,9 +12426,11 @@ async function gradeTables(client, assertions) {
 // src/eval/graders/workflow.ts
 function gradeWorkflows(spans, assertions) {
   const results = [];
+  const data = (span) => span.data && typeof span.data === "object" ? span.data : {};
   for (const assertion of assertions) {
     const workflowSpans = spans.filter((span) => {
-      const wfName = span.attrs?.["workflow.name"] || span.attrs?.["workflowName"];
+      const d = data(span);
+      const wfName = d["workflow.name"] || d["workflowName"];
       return wfName === assertion.name;
     });
     if (assertion.entered !== undefined) {
@@ -12216,8 +12445,9 @@ function gradeWorkflows(spans, assertions) {
     }
     if (assertion.completed !== undefined) {
       const completedSpans = workflowSpans.filter((span) => {
-        const status = span.attrs?.["workflow.status"];
-        return status === "completed" || span.t === "end" && span.name?.includes("workflow");
+        const d = data(span);
+        const status = d["workflow.status.final"];
+        return status === "completed" || (span.status === "ok" || span.status === "error") && span.name?.includes("workflow");
       });
       const didComplete = completedSpans.length > 0;
       const pass = assertion.completed ? didComplete : !didComplete;
@@ -12261,8 +12491,10 @@ async function gradeOutcome(client, evalDef, ctx, traceSpans, preSnapshots) {
 
 // src/eval/runner.ts
 import { randomUUID } from "crypto";
+var DEFAULT_IDLE_TIMEOUT = 15000;
 async function runEval(evalDef, connection, options = {}) {
   const devServerUrl = options.devServerUrl || "http://localhost:3001";
+  const idleTimeout = evalDef.options?.idleTimeout ?? options.idleTimeout ?? DEFAULT_IDLE_TIMEOUT;
   const start = Date.now();
   const turns = [];
   let outcomeAssertions = [];
@@ -12291,13 +12523,13 @@ async function runEval(evalDef, connection, options = {}) {
     }
     let previousToolCallCount = 0;
     let lastConversationId = "";
-    let allTraceSpans = [];
+    let allSpans = [];
     for (let i = 0;i < evalDef.conversation.length; i++) {
       const turn = evalDef.conversation[i];
       const turnStart = Date.now();
       const result = await session.sendMessage(turn.user, {
-        timeout: 30000,
-        idleTimeout: 3000
+        timeout: Math.max(30000, idleTimeout * 2),
+        idleTimeout
       });
       const botDuration = Date.now() - turnStart;
       lastConversationId = result.conversationId;
@@ -12318,7 +12550,7 @@ async function runEval(evalDef, connection, options = {}) {
             expectNewCalls
           });
           previousToolCallCount = traceData.totalToolCallCount;
-          allTraceSpans = traceData.raw;
+          allSpans = traceData.raw;
           const toolResults = gradeTools(traceData.toolCalls, turn.assert.tools);
           assertions = [...assertions, ...toolResults];
         } catch (err) {
@@ -12365,13 +12597,13 @@ async function runEval(evalDef, connection, options = {}) {
         }
       }
       if (turn.assert?.workflow) {
-        if (allTraceSpans.length === 0) {
+        if (allSpans.length === 0) {
           try {
             const traceData = await getTraceData(result.conversationId, devServerUrl);
-            allTraceSpans = traceData.raw;
+            allSpans = traceData.raw;
           } catch {}
         }
-        const workflowResults = gradeWorkflows(allTraceSpans, turn.assert.workflow);
+        const workflowResults = gradeWorkflows(allSpans, turn.assert.workflow);
         assertions.push(...workflowResults);
       }
       const turnPass = assertions.every((a) => a.pass);
@@ -12387,10 +12619,10 @@ async function runEval(evalDef, connection, options = {}) {
       });
     }
     if (evalDef.outcome) {
-      if (allTraceSpans.length === 0 && lastConversationId && evalDef.outcome.workflow) {
+      if (allSpans.length === 0 && lastConversationId && evalDef.outcome.workflow) {
         try {
           const traceData = await getTraceData(lastConversationId, devServerUrl);
-          allTraceSpans = traceData.raw;
+          allSpans = traceData.raw;
         } catch {}
       }
       const ctx = {
@@ -12399,7 +12631,7 @@ async function runEval(evalDef, connection, options = {}) {
         conversationId: lastConversationId
       };
       try {
-        outcomeAssertions = await gradeOutcome(getBpClient(), evalDef, ctx, allTraceSpans, preSnapshots);
+        outcomeAssertions = await gradeOutcome(getBpClient(), evalDef, ctx, allSpans, preSnapshots);
       } catch (err) {
         outcomeAssertions = [
           {
@@ -12476,7 +12708,7 @@ async function runEvalSuite(config, filter) {
   for (let i = 0;i < evals.length; i++) {
     const evalDef = evals[i];
     config.onProgress?.({ type: "eval_start", evalName: evalDef.name, index: i });
-    const report = await runEval(evalDef, connection, { devServerUrl });
+    const report = await runEval(evalDef, connection, { devServerUrl, idleTimeout: config.evalOptions?.idleTimeout });
     reports.push(report);
     config.onProgress?.({ type: "eval_complete", evalName: evalDef.name, index: i, report });
   }
@@ -12564,6 +12796,7 @@ export {
   dependenciesKeyOrder,
   defineEval,
   coerceConfigValue,
+  buildOpenCodeConfig,
   bpCliImporter,
   auth,
   agentInfoKeyOrder,
@@ -12576,6 +12809,7 @@ export {
   PreflightFormatter,
   PreflightChecker,
   PluginParser,
+  OpenCodeCommand,
   KnowledgeManager,
   KBSyncOperation,
   KBSyncFormatter,
@@ -12611,4 +12845,4 @@ export {
   AgentProject
 };
 
-//# debugId=B46A4264E95B176864756E2164756E21
+//# debugId=BA9CF8B5F775A63B64756E2164756E21