@botpress/adk 1.16.6 → 1.17.0

package/dist/index.js

@@ -15,7 +15,7 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/agent-project/types.ts
 import { z } from "@botpress/sdk";
-var pluginDependencyMappingSchema, dependenciesSchema, agentInfoSchema, ValidationErrorCode, ValidationSeverity, ProjectState;
+var pluginDependencyMappingSchema, dependenciesSchema, agentInfoSchema, agentLocalInfoSchema, ValidationErrorCode, ValidationSeverity, ProjectState;
 var init_types = __esm(() => {
   pluginDependencyMappingSchema = z.object({
     integrationAlias: z.string(),
@@ -40,6 +40,9 @@ var init_types = __esm(() => {
     apiUrl: z.string().optional().describe("The Botpress API URL (e.g., https://api.botpress.cloud)"),
     devId: z.string().optional().describe("The development ID used during local development")
   });
+  agentLocalInfoSchema = z.object({
+    devId: z.string().optional().describe("The development bot ID used during local development")
+  });
   ((ValidationErrorCode2) => {
     ValidationErrorCode2["DIRECTORY_NOT_FOUND"] = "DIRECTORY_NOT_FOUND";
     ValidationErrorCode2["DIRECTORY_ACCESS_ERROR"] = "DIRECTORY_ACCESS_ERROR";
@@ -487,6 +490,15 @@ async function resolveAgent(agentPath, options = {}) {
     if (!agentInfo.apiUrl) {
       agentInfo.apiUrl = DEFAULT_API_URL;
     }
+    const localPath = path.join(agentPath, "agent.local.json");
+    try {
+      const localContent = await fs.readFile(localPath, "utf-8");
+      const localData = JSON.parse(localContent);
+      const localResult = agentLocalInfoSchema.safeParse(localData);
+      if (localResult.success && localResult.data.devId) {
+        agentInfo.devId = localResult.data.devId;
+      }
+    } catch {}
     if (requireWorkspace && !agentInfo.workspaceId) {
       throw ValidationErrors.workspaceIdMissing();
     }
@@ -525,10 +537,14 @@ import os from "os";
 class CredentialsManager {
   credentialsPath;
   configDir;
+  profileOverride;
   constructor() {
     this.configDir = path2.join(os.homedir(), ".adk");
     this.credentialsPath = path2.join(this.configDir, "credentials");
   }
+  setProfileOverride(profile) {
+    this.profileOverride = profile;
+  }
   async ensureConfigDir() {
     try {
       await fs2.mkdir(this.configDir, { recursive: true });
@@ -644,23 +660,54 @@ class CredentialsManager {
     await this.writeCredentials(store);
   }
   async getActiveCredentials() {
-    const envProfile = process.env.ADK_PROFILE;
-    const credentials = await this.getCredentials(envProfile);
+    const profileName = this.profileOverride || process.env.ADK_PROFILE;
+    const credentials = await this.getCredentials(profileName);
     if (!credentials) {
-      const profileName = envProfile || "default";
-      throw new Error(`No credentials found for profile '${profileName}'. ` + `Please run 'adk login' to authenticate.`);
+      const displayName = profileName || "default";
+      throw new Error(`No credentials found for profile '${displayName}'. ` + `Please run 'adk login' to authenticate.`);
     }
     return credentials;
   }
+  findProfileByApiUrl(store, apiUrl) {
+    const normalizedUrl = apiUrl.replace(/\/+$/, "");
+    for (const [, credentials] of Object.entries(store.profiles)) {
+      if (!credentials.apiUrl)
+        continue;
+      const profileUrl = credentials.apiUrl.replace(/\/+$/, "");
+      if (profileUrl === normalizedUrl) {
+        return credentials;
+      }
+    }
+    return null;
+  }
   async getAgentCredentials(agentPath) {
-    const baseCredentials = await this.getActiveCredentials();
     const agentInfo = await resolveAgent(agentPath, {
       required: true,
       requireWorkspace: true
     });
+    const agentApiUrl = agentInfo.apiUrl;
+    let baseCredentials;
+    const hasExplicitProfile = !!(this.profileOverride || process.env.ADK_PROFILE);
+    if (hasExplicitProfile) {
+      baseCredentials = await this.getActiveCredentials();
+    } else {
+      const store = await this.readCredentials();
+      const matchingCredentials = this.findProfileByApiUrl(store, agentApiUrl);
+      if (matchingCredentials) {
+        console.info(`Using profile matching agent.json API URL (${agentApiUrl})`);
+        baseCredentials = matchingCredentials;
+      } else {
+        const profileName = store.currentProfile || "default";
+        const activeCredentials = store.profiles[profileName];
+        if (!activeCredentials) {
+          throw new Error(`No credentials found for profile '${profileName}'. ` + `Please run 'adk login' to authenticate.`);
+        }
+        baseCredentials = activeCredentials;
+      }
+    }
     return {
       ...baseCredentials,
-      apiUrl: agentInfo.apiUrl || baseCredentials.apiUrl,
+      apiUrl: agentApiUrl,
       workspaceId: agentInfo.workspaceId,
       botId: agentInfo.botId
     };
@@ -682,7 +729,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 +758,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.17.0", 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,16 +907,31 @@ var init_integration_action_types = __esm(() => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@botpress/adk",
-    version: "1.16.6",
+    version: "1.17.0",
     description: "Core ADK library for building AI agents on Botpress",
-    type: "module",
-    main: "dist/index.js",
-    types: "dist/index.d.ts",
+    keywords: [
+      "adk",
+      "agent",
+      "ai",
+      "botpress",
+      "chatbot",
+      "conversational-ai",
+      "development-kit"
+    ],
+    license: "MIT",
+    author: "Botpress",
+    repository: {
+      type: "git",
+      url: "https://github.com/botpress/adk"
+    },
     files: [
       "dist/**/*",
       "package.json",
       "README.md"
     ],
+    type: "module",
+    main: "dist/index.js",
+    types: "dist/index.d.ts",
     exports: {
       ".": {
         types: "./dist/index.d.ts",
@@ -885,33 +946,18 @@ var require_package = __commonJS((exports, module) => {
       watch: "bun run build:types && bun build ./src/index.ts --outdir ./dist --target node --format esm --sourcemap --watch",
       clean: "rm -rf dist",
       prepublishOnly: "bun run clean && bun run build",
-      test: "vitest run",
-      "test:watch": "vitest",
-      "test:ui": "vitest --ui",
-      "test:coverage": "vitest run --coverage"
-    },
-    keywords: [
-      "botpress",
-      "adk",
-      "agent",
-      "ai",
-      "chatbot",
-      "conversational-ai",
-      "development-kit"
-    ],
-    author: "Botpress",
-    license: "MIT",
-    repository: {
-      type: "git",
-      url: "https://github.com/botpress/adk"
+      test: "bun test",
+      "test:watch": "bun test --watch",
+      "test:coverage": "bun test",
+      "check:type": "tsc --noEmit"
     },
     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/chat": "0.5.5",
+      "@botpress/cli": "6.2.2",
+      "@botpress/client": "1.38.1",
+      "@botpress/cognitive": "0.4.2",
+      "@botpress/runtime": "^1.17.0",
+      "@botpress/sdk": "6.3.1",
       "@bpinternal/jex": "^1.2.4",
       "@bpinternal/yargs-extra": "^0.0.21",
       "@parcel/watcher": "^2.5.1",
@@ -920,11 +966,12 @@ 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"
     },
     devDependencies: {
+      "@bpinternal/zui": "2.1.0",
       "@types/debug": "^4.1.12",
       "@types/glob": "^9.0.0",
       "@types/luxon": "^3.7.1",
@@ -935,8 +982,8 @@ var require_package = __commonJS((exports, module) => {
       typescript: ">=4.5.0"
     },
     engines: {
-      node: ">=22.0.0",
-      bun: ">=1.3.9"
+      bun: ">=1.3.9",
+      node: ">=22.0.0"
     },
     packageManager: "bun@1.3.9"
   };
@@ -1105,6 +1152,9 @@ class Auth {
   async setCurrentProfile(profileName) {
     return this.credentialsManager.setCurrentProfile(profileName);
   }
+  setProfileOverride(profile) {
+    this.credentialsManager.setProfileOverride(profile);
+  }
   async getActiveCredentials() {
     return this.credentialsManager.getActiveCredentials();
   }
@@ -1154,7 +1204,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 = "6.2.2";
 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 +1699,15 @@ class BpDevCommand extends BaseCommand {
     if (sourceMap) {
       bpArgs.push("--sourceMap");
     }
+    const spanIngestUrl = `http://localhost:${this.options.spanIngestPort}`;
+    const otlpEndpoint = this.options.otlpPort ? `http://localhost:${this.options.otlpPort}` : undefined;
+    const traceLines = [`[bp-dev] Trace endpoints:`, `  ADK_SPAN_INGEST_URL=${spanIngestUrl}`];
+    if (otlpEndpoint) {
+      traceLines.push(`  OTEL_EXPORTER_OTLP_ENDPOINT=${otlpEndpoint}`);
+    }
+    this.emit("stdout", traceLines.join(`
+`) + `
+`);
     this.childProcess = execa4(bpCommand, bpArgs, {
       cwd: botPath,
       env: {
@@ -1665,6 +1724,9 @@ class BpDevCommand extends BaseCommand {
         },
         WORKER_MODE: "true",
         WORKER_LIFETIME_MS: process.env.WORKER_LIFETIME_MS || "120000",
+        ADK_SPAN_INGEST_URL: spanIngestUrl,
+        ...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()
@@ -1891,10 +1953,11 @@ class BpChatCommand extends BaseCommand {
     try {
       await this.childProcess;
     } catch (error) {
+      const errObj = error != null && typeof error === "object" ? error : {};
       this.emit("error", {
-        exitCode: error.exitCode || 1,
-        stderr: error.stderr || "",
-        message: error.message || "Chat command failed"
+        exitCode: "exitCode" in errObj ? errObj.exitCode || 1 : 1,
+        stderr: "stderr" in errObj ? errObj.stderr || "" : "",
+        message: error instanceof Error ? error.message || "Chat command failed" : "Chat command failed"
       });
       throw error;
     }
@@ -1905,6 +1968,227 @@ 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.uiServerPort)
+    command.push("--port", String(options.uiServerPort));
+  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,
+      uiServerPort: this.options.uiServerPort,
+      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));
+    }
+    if (!this.readyEmitted && !this.killed) {
+      this.emit("progress", {
+        type: "error",
+        startTime: Date.now(),
+        data: { reason: "OpenCode server did not respond in time" }
+      });
+    }
+  }
+  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 {
@@ -1981,7 +2265,8 @@ function getChatClient(cwd = process.cwd()) {
   return Client4;
 }
 // src/utils/json-ordering.ts
-var agentInfoKeyOrder = ["botId", "workspaceId", "apiUrl", "devId"];
+var agentInfoKeyOrder = ["botId", "workspaceId", "apiUrl"];
+var agentLocalInfoKeyOrder = ["devId"];
 var dependenciesKeyOrder = ["integrations"];
 var integrationKeyOrder = ["version", "enabled", "configurationType", "config"];
 function orderKeys(obj, keyOrder) {
@@ -2066,7 +2351,7 @@ class AssetsCacheManager {
       const content = await fs4.readFile(this.cachePath, "utf-8");
       this.cache = JSON.parse(content);
       return this.cache;
-    } catch (error) {
+    } catch {
       this.cache = {
         version: "1.0",
         entries: {}
@@ -2599,7 +2884,7 @@ class EnhancedIntegrationCache {
 
 // src/agent-project/dependencies-parser.ts
 init_validation_errors();
-import { z as z2, ZodIssueCode } from "@botpress/sdk";
+import { z as z2 } from "@botpress/sdk";
 var INTEGRATION_ALIAS_MIN_LENGTH = 2;
 var INTEGRATION_ALIAS_MAX_LENGTH = 100;
 var INTEGRATION_ALIAS_REGEX = /^(?:[a-z][a-z0-9_-]*\/)?[a-z][a-z0-9_-]*$/;
@@ -2610,10 +2895,10 @@ var integrationRefSchema = z2.string().transform((val, ctx) => {
   const match = val.match(/^(?:([^/]+)\/)?([^@]+)@(.+)$/);
   if (!match) {
     ctx.addIssue({
-      code: ZodIssueCode.custom,
+      code: "custom",
       message: `Invalid integration version format: ${val}. Expected format: 'name@version' or 'workspace/name@version'`
     });
-    return z2.NEVER;
+    return;
   }
   const [, workspace, name, version] = match;
   return {
@@ -2712,10 +2997,10 @@ var pluginRefSchema = z2.string().transform((val, ctx) => {
   const match = val.match(/^([^/@]+)@(.+)$/);
   if (!match) {
     ctx.addIssue({
-      code: ZodIssueCode.custom,
+      code: "custom",
       message: `Invalid plugin version format: ${val}. Expected format: 'name@version' (no workspace prefix)`
     });
-    return z2.NEVER;
+    return;
   }
   const [, name, version] = match;
   return {
@@ -2772,7 +3057,7 @@ class PluginParser {
       if (!pluginConfig.dependencies) {
         continue;
       }
-      for (const [depAlias, depMapping] of Object.entries(pluginConfig.dependencies)) {
+      for (const [_depAlias, depMapping] of Object.entries(pluginConfig.dependencies)) {
         if (!integrationAliases.includes(depMapping.integrationAlias)) {
           errors.push(ValidationErrors.invalidPluginDependency(alias, depMapping.integrationAlias, integrationAliases));
         }
@@ -3043,7 +3328,7 @@ class IntegrationCache {
         }
       }
       return cached.definition;
-    } catch (error) {
+    } catch {
       return null;
     }
   }
@@ -4432,7 +4717,7 @@ async function expandExports(options) {
         });
         return {};
       }
-      currentError = currentError.cause;
+      currentError = currentError instanceof Error ? currentError.cause : undefined;
     }
     throw importError;
   }
@@ -4698,20 +4983,62 @@ class AgentProject {
     return this._assetsManager;
   }
   async createAgentInfo(info) {
+    const { devId, ...agentJsonInfo } = info;
     const agentPath = path13.join(this._path, "agent.json");
-    const agentContent = stringifyWithOrder(info, agentInfoKeyOrder);
+    const agentContent = stringifyWithOrder(agentJsonInfo, agentInfoKeyOrder);
     await fs10.writeFile(agentPath, agentContent);
     this._agentInfo = info;
+    if (devId) {
+      await this.createAgentLocalInfo({ devId });
+    }
   }
   async updateAgentInfo(updates) {
     if (!this._agentInfo) {
       throw new Error("No agent.json found. Use createAgentInfo() first.");
     }
-    const updatedInfo = { ...this._agentInfo, ...updates };
+    const { devId, ...agentJsonUpdates } = updates;
+    const updatedInfo = { ...this._agentInfo, ...agentJsonUpdates };
+    const { devId: _devId, ...agentJsonData } = updatedInfo;
     const agentPath = path13.join(this._path, "agent.json");
-    const agentContent = stringifyWithOrder(updatedInfo, agentInfoKeyOrder);
+    const agentContent = stringifyWithOrder(agentJsonData, agentInfoKeyOrder);
     await fs10.writeFile(agentPath, agentContent);
     this._agentInfo = updatedInfo;
+    if (devId !== undefined) {
+      await this.updateAgentLocalInfo({ devId });
+    }
+  }
+  async createAgentLocalInfo(info) {
+    const localPath = path13.join(this._path, "agent.local.json");
+    let existing = {};
+    try {
+      const content2 = await fs10.readFile(localPath, "utf-8");
+      existing = JSON.parse(content2);
+    } catch {}
+    const merged = { ...existing, ...info };
+    const content = stringifyWithOrder(merged, agentLocalInfoKeyOrder);
+    await fs10.writeFile(localPath, content);
+    if (this._agentInfo) {
+      this._agentInfo.devId = merged.devId;
+    }
+  }
+  async updateAgentLocalInfo(updates) {
+    const localPath = path13.join(this._path, "agent.local.json");
+    let existing = {};
+    try {
+      const content2 = await fs10.readFile(localPath, "utf-8");
+      existing = JSON.parse(content2);
+    } catch {}
+    const updated = { ...existing, ...updates };
+    for (const key of Object.keys(updated)) {
+      if (updated[key] === undefined) {
+        delete updated[key];
+      }
+    }
+    const content = stringifyWithOrder(updated, agentLocalInfoKeyOrder);
+    await fs10.writeFile(localPath, content);
+    if (this._agentInfo) {
+      this._agentInfo.devId = updated.devId;
+    }
   }
   requiresAgentInfo(operation) {
     if (!this._agentInfo?.botId) {
@@ -4902,6 +5229,19 @@ ${err.stack?.split(`
       console.warn(`Failed to register data source workflows for ${kbPath}:`, error);
     }
   }
+  isBarrelReexport(existing, newPath, newExport, newDefinition) {
+    const isNewBarrel = /^index\.[tj]s$/i.test(path13.basename(newPath));
+    const isExistingBarrel = /^index\.[tj]s$/i.test(path13.basename(existing.path));
+    if (!isNewBarrel && !isExistingBarrel) {
+      return false;
+    }
+    if (isExistingBarrel && !isNewBarrel) {
+      existing.path = newPath;
+      existing.export = newExport;
+      existing.definition = newDefinition;
+    }
+    return true;
+  }
   getChannelsList(channelSpec) {
     if (channelSpec === "*") {
       return ["*"];
@@ -4984,6 +5324,9 @@ ${err.stack?.split(`
               return existingChannels.some((ch) => newChannels.includes(ch));
             });
             if (overlapping) {
+              if (this.isBarrelReexport(overlapping, relPath, key, definition)) {
+                continue;
+              }
               this._warnings.push({
                 $type: "ValidationError",
                 code: "DUPLICATE_PRIMITIVE" /* DUPLICATE_PRIMITIVE */,
@@ -5001,6 +5344,9 @@ ${err.stack?.split(`
           } else if (Primitives2.Definitions.isKnowledgeDefinition(definition)) {
             const existing = this._knowledge.find((p) => p.definition.name === definition.name);
             if (existing) {
+              if (this.isBarrelReexport(existing, relPath, key, definition)) {
+                continue;
+              }
               this._warnings.push({
                 $type: "ValidationError",
                 code: "DUPLICATE_PRIMITIVE" /* DUPLICATE_PRIMITIVE */,
@@ -5019,6 +5365,9 @@ ${err.stack?.split(`
           } else if (Primitives2.Definitions.isTriggerDefinition(definition)) {
             const existing = this._triggers.find((p) => p.definition.name === definition.name);
             if (existing) {
+              if (this.isBarrelReexport(existing, relPath, key, definition)) {
+                continue;
+              }
               this._warnings.push({
                 $type: "ValidationError",
                 code: "DUPLICATE_PRIMITIVE" /* DUPLICATE_PRIMITIVE */,
@@ -5036,6 +5385,9 @@ ${err.stack?.split(`
           } else if (Primitives2.Definitions.isWorkflowDefinition(definition)) {
             const existing = this._workflows.find((p) => p.definition.name === definition.name);
             if (existing) {
+              if (this.isBarrelReexport(existing, relPath, key, definition)) {
+                continue;
+              }
               this._warnings.push({
                 $type: "ValidationError",
                 code: "DUPLICATE_PRIMITIVE" /* DUPLICATE_PRIMITIVE */,
@@ -5053,6 +5405,9 @@ ${err.stack?.split(`
           } else if (Primitives2.Definitions.isActionDefinition(definition)) {
             const existing = this._actions.find((p) => p.definition.name === definition.name);
             if (existing) {
+              if (this.isBarrelReexport(existing, relPath, key, definition)) {
+                continue;
+              }
               this._warnings.push({
                 $type: "ValidationError",
                 code: "DUPLICATE_PRIMITIVE" /* DUPLICATE_PRIMITIVE */,
@@ -5070,6 +5425,9 @@ ${err.stack?.split(`
           } else if (Primitives2.Definitions.isTableDefinition(definition)) {
             const existing = this._tables.find((p) => p.definition.name === definition.name);
             if (existing) {
+              if (this.isBarrelReexport(existing, relPath, key, definition)) {
+                continue;
+              }
               this._warnings.push({
                 $type: "ValidationError",
                 code: "DUPLICATE_PRIMITIVE" /* DUPLICATE_PRIMITIVE */,
@@ -5393,22 +5751,36 @@ adk deploy   # Deploy to Botpress Cloud
 adk chat     # Chat with your agent in the terminal
 \`\`\`
 
-## AI Coding Assistant Skills
+## MCP Tools (ADK Dev Server)
 
-This project uses the Botpress ADK. Before making changes, use the relevant skill:
+This project includes an MCP server that provides AI coding assistants with deep ADK integration.
+Run \`adk mcp:init --all\` to generate configuration for your editor, or use the tools below directly.
 
-| Skill              | Use for                                          |
-| ------------------ | ------------------------------------------------ |
-| \`/adk\`             | ADK concepts, patterns, and API reference        |
-| \`/adk-integration\` | Finding and using Botpress integrations           |
-| \`/adk-debugger\`    | Debugging with traces and test conversations      |
-| \`/adk-frontend\`    | Building frontends that connect to ADK bots       |
+### Debugging & Testing
 
-If these skills are not installed, install them:
+| Tool               | Use for                                                      |
+| ------------------ | ------------------------------------------------------------ |
+| \`adk_send_message\` | Send a test message to the running bot and receive responses |
+| \`adk_query_traces\` | Query trace spans for debugging conversations and workflows  |
+| \`adk_get_dev_logs\` | Get dev server logs, build output, errors, and warnings      |
 
-\`\`\`
-npx skills add botpress/skills --skill adk
-\`\`\`
+### Project & Integration Management
+
+| Tool                      | Use for                                                     |
+| ------------------------- | ----------------------------------------------------------- |
+| \`adk_get_agent_info\`      | Get project info: name, version, and all primitives         |
+| \`adk_search_integrations\` | Search available integrations on the Botpress Hub           |
+| \`adk_get_integration\`     | Get detailed info about an integration before adding it     |
+| \`adk_add_integration\`     | Add an integration to the project (updates agent.config.ts) |
+
+### Workflows
+
+| Tool                 | Use for                                    |
+| -------------------- | ------------------------------------------ |
+| \`adk_list_workflows\` | List available workflows with descriptions |
+| \`adk_start_workflow\` | Start a workflow or get its input schema   |
+
+> **Tip:** The dev server must be running (\`adk dev\`) for debugging and testing tools to work.
 
 ## Project Overview
 
@@ -5468,7 +5840,7 @@ class AgentProjectGenerator {
         deploy: "adk deploy"
       },
       dependencies: {
-        "@botpress/runtime": `^${"1.16.6"}`
+        "@botpress/runtime": `^${"1.17.0"}`
       },
       devDependencies: {
         typescript: "^5.9.3"
@@ -5571,6 +5943,12 @@ dist/
 .env.local
 .env.production
 
+# Local development
+agent.local.json
+
+# MCP configuration (auto-generated by adk mcp:init)
+.mcp.json
+
 # IDE files
 .vscode/
 .idea/
@@ -6001,7 +6379,7 @@ if (typeof globalThis !== 'undefined') {
   }
 }
 // src/generators/integration-types.ts
-import { transforms } from "@botpress/sdk";
+import { z as z3 } from "@botpress/sdk";
 import crypto2 from "crypto";
 import path18 from "path";
 
@@ -6029,6 +6407,7 @@ function getPluginAlias(pluginName) {
 }
 
 // src/generators/integration-types.ts
+var { transforms } = z3;
 var getIntegrationHash = (integration) => {
   return crypto2.createHash("sha256").update(`${integration.alias}|${integration.definition?.id}|${integration.definition?.version}|${integration.definition?.updatedAt}`).digest("hex");
 };
@@ -6261,9 +6640,10 @@ Description: ${tag?.description}`);
   }
   if (integration.definition?.configurations) {
     for (const [key, config] of Object.entries(integration.definition.configurations)) {
-      const title = config.title || key;
-      const description = config.description || "";
-      const schema = config.schema;
+      const configRecord = config;
+      const title = configRecord.title || key;
+      const description = configRecord.description || "";
+      const schema = configRecord.schema;
       let tsType = "{}";
       if (schema) {
         tsType = transforms.fromJSONSchema(schema).toTypescriptType();
@@ -6380,12 +6760,14 @@ async function generateClientWrapper(project) {
           let schema;
           let computed = false;
           if (typeof colDef === "object" && colDef !== null && "schema" in colDef) {
-            schema = colDef.schema;
-            computed = colDef.computed || false;
+            const colDefRecord = colDef;
+            schema = colDefRecord.schema;
+            computed = colDefRecord.computed || false;
           } else {
             schema = colDef;
           }
-          const tsType = schema.toTypescriptType ? schema.toTypescriptType({ treatDefaultAsOptional: true }) : "any";
+          const schemaObj = schema;
+          const tsType = typeof schemaObj.toTypescriptType === "function" ? schemaObj.toTypescriptType({ treatDefaultAsOptional: true }) : "any";
           if (!computed) {
             inputColumns.push(`${colName}: ${tsType}`);
           }
@@ -6700,10 +7082,11 @@ import fs18 from "fs/promises";
 import path38 from "path";
 
 // src/generators/plugin-types.ts
-import { transforms as transforms2 } from "@botpress/sdk";
+import { z as z4 } from "@botpress/sdk";
 import crypto4 from "crypto";
 import path20 from "path";
 init_utils();
+var { transforms: transforms2 } = z4;
 function stripRefs(schema) {
   if (typeof schema !== "object" || schema === null) {
     return schema;
@@ -6849,10 +7232,11 @@ export type PluginActions = PluginsMap<Plugins>;
 }
 
 // src/generators/interface-types.ts
-import { transforms as transforms3 } from "@botpress/sdk";
+import { z as z5 } from "@botpress/sdk";
 import crypto5 from "crypto";
 import path22 from "path";
 init_utils();
+var { transforms: transforms3 } = z5;
 var sameMajorVersion = (a, b) => {
   const majorA = a.split(".")[0];
   const majorB = b.split(".")[0];
@@ -7638,7 +8022,7 @@ class DevIdManager {
       if (!project.agentInfo) {
         throw ValidationErrors.agentNotLinked();
       }
-      await project.updateAgentInfo({
+      await project.updateAgentLocalInfo({
         devId: projectCache.devId
       });
     }
@@ -7665,7 +8049,7 @@ class DevIdManager {
         const client = await this.getClient();
         await client.getBot({ id: agentInfo.devId });
         return true;
-      } catch (error) {
+      } catch {
         return false;
       }
     }
@@ -8038,10 +8422,11 @@ class PluginSync {
 
 // src/bot-generator/generator.ts
 init_utils();
-import { transforms as transforms4 } from "@botpress/sdk";
+import { z as z6 } from "@botpress/sdk";
 init_constants();
 import { BuiltInActions as BuiltInActions2, BuiltInWorkflows as BuiltInWorkflows4, Primitives as Primitives3 } from "@botpress/runtime/internal";
 import { BUILT_IN_TAGS as BUILT_IN_TAGS2 } from "@botpress/runtime/definition";
+var { transforms: transforms4 } = z6;
 var plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
 function isBuiltinWorkflow3(name) {
   return !!Object.values(BuiltInWorkflows4).find((x) => x.name === name);
@@ -9055,7 +9440,9 @@ export default bot;`;
     }
     {
       const dest = path38.join(srcDir, "triggers.ts");
-      const { transforms: transforms5 } = await import("@botpress/sdk");
+      const {
+        z: { transforms: transforms5 }
+      } = await import("@botpress/sdk");
       const imports = new Map;
       const exports = new Set;
       const payloadTypes = {};
@@ -9343,7 +9730,9 @@ async function generateBotProject(options) {
 }
 // src/tables/table-manager.ts
 import { Client as Client15 } from "@botpress/client";
-import { transforms as transforms5 } from "@botpress/sdk";
+import { z as z7 } from "@botpress/sdk";
+var { transforms: transforms5 } = z7;
+
 class TableManager {
   client;
   botId;
@@ -9374,13 +9763,14 @@ class TableManager {
   }
   getSchemaType(schema) {
     if (schema.type) {
-      if (schema.type === "array" && schema.items?.type) {
-        return `array<${schema.items.type}>`;
+      const items = schema.items;
+      if (schema.type === "array" && items?.type) {
+        return `array<${items.type}>`;
       }
-      return schema.type;
+      return String(schema.type);
     }
     if (schema.$ref) {
-      return schema.$ref.split("/").pop() || "unknown";
+      return String(schema.$ref).split("/").pop() || "unknown";
     }
     return "unknown";
   }
@@ -9391,8 +9781,8 @@ class TableManager {
     } else if (Math.abs(oldPosition - newPosition) <= 1) {
       score += 1;
     }
-    const oldDesc = (oldSchema?.description || "").toLowerCase();
-    const newDesc = (newSchema?.description || "").toLowerCase();
+    const oldDesc = String(oldSchema?.description || "").toLowerCase();
+    const newDesc = String(newSchema?.description || "").toLowerCase();
     if (oldDesc && newDesc && oldDesc === newDesc) {
       score += 5;
     } else if (oldDesc && newDesc && oldDesc.length > 5 && newDesc.length > 5) {
@@ -9407,8 +9797,10 @@ class TableManager {
         }
       }
     }
-    const oldOptional = oldSchema?.type?.includes("null") || oldSchema?.nullable === true;
-    const newOptional = newSchema?.type?.includes("null") || newSchema?.nullable === true;
+    const oldType = oldSchema?.type;
+    const newType = newSchema?.type;
+    const oldOptional = typeof oldType === "string" && oldType.includes("null") || oldSchema?.nullable === true;
+    const newOptional = typeof newType === "string" && newType.includes("null") || newSchema?.nullable === true;
     if (oldOptional === newOptional) {
       score += 1;
     }
@@ -10636,7 +11028,7 @@ class KBSyncFormatter {
   }
 }
 // src/file-watcher/watcher.ts
-import { watch as watch2, readdirSync as readdirSync2 } from "fs";
+import { watch as watch2, readdirSync as readdirSync2, statSync } from "fs";
 import { EventEmitter as EventEmitter3 } from "events";
 import { join as join9, relative as relative3 } from "path";
 import { existsSync as existsSync9 } from "fs";
@@ -10678,7 +11070,7 @@ class FileWatcher2 extends EventEmitter3 {
           this.updateFileState(fullPath);
         }
       }
-    } catch (error) {}
+    } catch {}
   }
   watchFile(filePath) {
     if (this.watchers.has(filePath)) {
@@ -10711,6 +11103,12 @@ class FileWatcher2 extends EventEmitter3 {
     }
   }
   handleFileChange(filePath) {
+    try {
+      if (existsSync9(filePath) && statSync(filePath).isDirectory()) {
+        this.scanDirectoryForChanges(filePath);
+        return;
+      }
+    } catch {}
     const fileExists = existsSync9(filePath);
     const previousState = this.fileStates.get(filePath);
     let changeType;
@@ -10731,12 +11129,7 @@ class FileWatcher2 extends EventEmitter3 {
       path: relativePath,
       type: changeType
     });
-    if (this.debounceTimer) {
-      clearTimeout(this.debounceTimer);
-    }
-    this.debounceTimer = setTimeout(() => {
-      this.emitPendingChanges();
-    }, this.debounceMs);
+    this.scheduleDebouncedEmit();
   }
   emitPendingChanges() {
     if (this.pendingChanges.size === 0) {
@@ -10750,6 +11143,44 @@ class FileWatcher2 extends EventEmitter3 {
     };
     this.emit("change", event);
   }
+  scanDirectoryForChanges(dirPath) {
+    try {
+      const entries = readdirSync2(dirPath, { withFileTypes: true });
+      const currentFiles = new Set;
+      for (const entry of entries) {
+        const fullPath = join9(dirPath, entry.name);
+        if (entry.isFile()) {
+          currentFiles.add(fullPath);
+          if (!this.fileStates.has(fullPath)) {
+            this.updateFileState(fullPath);
+            const relativePath = relative3(this.projectPath, fullPath);
+            this.pendingChanges.set(relativePath, { path: relativePath, type: "added" });
+            this.scheduleDebouncedEmit();
+          }
+        } else if (entry.isDirectory()) {
+          this.scanDirectoryForChanges(fullPath);
+        }
+      }
+      for (const [trackedPath] of this.fileStates) {
+        if (trackedPath.startsWith(dirPath) && !trackedPath.includes("/", dirPath.length + 1)) {
+          if (!currentFiles.has(trackedPath)) {
+            this.fileStates.delete(trackedPath);
+            const relativePath = relative3(this.projectPath, trackedPath);
+            this.pendingChanges.set(relativePath, { path: relativePath, type: "deleted" });
+            this.scheduleDebouncedEmit();
+          }
+        }
+      }
+    } catch {}
+  }
+  scheduleDebouncedEmit() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+    this.debounceTimer = setTimeout(() => {
+      this.emitPendingChanges();
+    }, this.debounceMs);
+  }
   updateFileState(filePath) {
     if (existsSync9(filePath)) {
       this.fileStates.set(filePath, Date.now());
@@ -11529,6 +11960,7 @@ function filterEvals(evals, filter) {
 }
 // src/eval/runner.ts
 import { Client as BpClient2 } from "@botpress/client";
+import { BUILT_IN_STATES as BUILT_IN_STATES2 } from "@botpress/runtime/internal";
 
 // src/eval/client.ts
 import { Client as BpClient } from "@botpress/client";
@@ -11549,20 +11981,21 @@ class ChatSession {
     }
     return this.client.user.id;
   }
-  async sendMessage(message, options = {}) {
+  async ensureConversation() {
     if (!this.client) {
       throw new Error("ChatSession not connected. Call connect() first.");
     }
-    const { timeout = 30000, idleTimeout = 3000 } = options;
     if (!this.conversationId) {
       const conv = await this.client.createConversation({});
       this.conversationId = conv.conversation.id;
+      return conv.conversation.id;
     }
-    const conversationId = this.conversationId;
+    return this.conversationId;
+  }
+  async _awaitResponses(conversationId, trigger, options = {}) {
+    const { timeout = 30000, idleTimeout = 3000 } = options;
     const responses = [];
-    const listener = await this.client.listenConversation({
-      id: conversationId
-    });
+    const listener = await this.client.listenConversation({ id: conversationId });
     return new Promise((resolve4, reject) => {
       let idleTimer = null;
       let resolved = false;
@@ -11582,7 +12015,7 @@ class ChatSession {
       };
       const overallTimer = setTimeout(() => {
         if (!resolved) {
-          if (responses.length > 0) {
+          if (responses.length > 0 || options.expectSilence) {
             done();
           } else {
             resolved = true;
@@ -11605,10 +12038,7 @@ class ChatSession {
           done();
         }
       });
-      this.client.createMessage({
-        conversationId,
-        payload: { type: "text", text: message }
-      }).then(() => {
+      trigger().then(() => {
         resetIdle();
       }).catch((err) => {
         clearTimeout(overallTimer);
@@ -11619,6 +12049,20 @@ class ChatSession {
       });
     });
   }
+  async sendMessage(message, options = {}) {
+    if (!this.client) {
+      throw new Error("ChatSession not connected. Call connect() first.");
+    }
+    const conversationId = await this.ensureConversation();
+    return this._awaitResponses(conversationId, () => this.client.createMessage({ conversationId, payload: { type: "text", text: message } }), options);
+  }
+  async sendEvent(type, payload, options = {}) {
+    if (!this.client) {
+      throw new Error("ChatSession not connected. Call connect() first.");
+    }
+    const conversationId = await this.ensureConversation();
+    return this._awaitResponses(conversationId, () => this.client.createEvent({ type, payload, conversationId }), options);
+  }
 }
 async function discoverWebhookId(botId, token, apiUrl) {
   const client = new BpClient({ token, botId, apiUrl });
@@ -11626,14 +12070,14 @@ async function discoverWebhookId(botId, token, apiUrl) {
   const integrations = bot.integrations || {};
   const chat = Object.values(integrations).find((int) => int.name === "chat");
   const webhookId = chat?.webhookId;
-  if (!webhookId) {
+  if (!webhookId || typeof webhookId !== "string") {
     throw new Error("No chat integration found on bot. Make sure the bot has the chat integration enabled.");
   }
   return webhookId;
 }
 
 // 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 +12087,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 +12121,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;
@@ -11687,9 +12132,11 @@ async function getTraceData(conversationId, devServerUrl, options = {}) {
 }
 
 // src/eval/graders/llm.ts
-import { Cognitive } from "@botpress/cognitive";
+import { Cognitive } from "@botpress/runtime";
 import { Client as Client18 } from "@botpress/client";
-var JUDGE_SYSTEM_PROMPT = `You are an evaluation judge for a chatbot. You will be given:
+var DEFAULT_PASS_THRESHOLD = 3;
+function buildJudgeSystemPrompt(passThreshold) {
+  return `You are an evaluation judge for a chatbot. You will be given:
 - The user's message
 - The bot's response
 - Grading criteria
@@ -11710,32 +12157,44 @@ Scoring guide:
 - 2: Barely meets criteria, significant issues
 - 1: Does not meet criteria
 
-A score of 3 or above is a pass.`;
+A score of ${passThreshold} or above is a pass.`;
+}
+var MODEL_ALIASES = ["fast", "best"];
 var _cognitive = null;
-function getCognitive() {
-  if (_cognitive)
-    return _cognitive;
-  const token = process.env.BP_TOKEN || process.env.ADK_TOKEN;
-  const botId = process.env.ADK_BOT_ID;
-  const apiUrl = process.env.ADK_API_URL || "https://api.botpress.cloud";
-  if (!token || !botId)
-    return null;
-  const client = new Client18({ token, apiUrl, botId });
-  _cognitive = new Cognitive({ client, __experimental_beta: true });
-  return _cognitive;
+var _availableModels = [];
+var _judgeModel = "fast";
+function _isModelValid(model) {
+  if (MODEL_ALIASES.includes(model))
+    return true;
+  if (_availableModels.length === 0)
+    return false;
+  return _availableModels.includes(model);
 }
-function initLLMJudge(credentials) {
+async function initLLMJudge(credentials, options) {
+  const log = options?.logger ?? console;
   const client = new Client18({
     token: credentials.token,
     apiUrl: credentials.apiUrl,
     botId: credentials.botId
   });
   _cognitive = new Cognitive({ client, __experimental_beta: true });
+  try {
+    _availableModels = Array.from((await _cognitive.fetchRemoteModels()).keys());
+  } catch (err) {
+    log.warn(`Failed to fetch available models: ${err.message}. LLM judge will be unavailable.`);
+    _availableModels = [];
+  }
+  _judgeModel = options?.model ?? "fast";
+  if (_availableModels.length === 0) {
+    log.warn("No available Cognitive models: cannot validate judge model.");
+  } else if (!_isModelValid(_judgeModel)) {
+    log.warn(`Configured LLM judge model "${_judgeModel}" is invalid. Run "adk models" to list available models.`);
+  }
 }
 async function gradeLLMJudge(botResponse, criteria, context) {
+  const threshold = Math.max(1, Math.min(5, context.passThreshold ?? DEFAULT_PASS_THRESHOLD));
   try {
-    const cognitive = getCognitive();
-    if (!cognitive) {
+    if (!_cognitive) {
       return {
         assertion: `llm_judge: "${criteria}"`,
         pass: true,
@@ -11743,11 +12202,19 @@ async function gradeLLMJudge(botResponse, criteria, context) {
         actual: "SKIPPED — LLM judge unavailable: no credentials configured"
       };
     }
-    const { output } = await cognitive.generateContent({
-      model: "fast",
+    if (!_isModelValid(_judgeModel)) {
+      return {
+        assertion: `llm_judge: "${criteria}"`,
+        pass: false,
+        expected: criteria,
+        actual: "FAILED — invalid LLM judge model"
+      };
+    }
+    const { output } = await _cognitive.generateContent({
+      model: _judgeModel,
       temperature: 0,
       responseFormat: "json_object",
-      systemPrompt: JUDGE_SYSTEM_PROMPT,
+      systemPrompt: buildJudgeSystemPrompt(threshold),
       messages: [
         {
           role: "user",
@@ -11772,9 +12239,9 @@ Criteria: ${criteria}`
     const verdict = JSON.parse(content);
     return {
       assertion: `llm_judge: "${criteria}"`,
-      pass: verdict.score >= 3,
+      pass: verdict.score >= threshold,
       expected: criteria,
-      actual: `Score ${verdict.score}/5 — ${verdict.reason}`
+      actual: `Score ${verdict.score}/5 (threshold: ${threshold}) — ${verdict.reason}`
     };
   } catch (err) {
     return {
@@ -11822,7 +12289,10 @@ async function gradeResponse(botResponse, assertions, context) {
       continue;
     }
     if ("llm_judge" in assertion) {
-      const result = await gradeLLMJudge(botResponse, assertion.llm_judge, context);
+      const result = await gradeLLMJudge(botResponse, assertion.llm_judge, {
+        userMessage: context.userMessage,
+        passThreshold: context.judgePassThreshold
+      });
       results.push(result);
       continue;
     }
@@ -11974,6 +12444,7 @@ function gradeTools(toolCalls, assertions) {
 }
 
 // src/eval/graders/state.ts
+import { BUILT_IN_STATES } from "@botpress/runtime/internal";
 function parseStatePath(path42) {
   const dot = path42.indexOf(".");
   if (dot === -1) {
@@ -11983,11 +12454,16 @@ function parseStatePath(path42) {
   const field = path42.slice(dot + 1);
   switch (prefix) {
     case "bot":
-      return { type: "bot", stateName: "botState", stateId: (ctx) => ctx.botId, field };
+      return { type: "bot", stateName: BUILT_IN_STATES.bot, stateId: (ctx) => ctx.botId, field };
     case "user":
-      return { type: "user", stateName: "userState", stateId: (ctx) => ctx.userId, field };
+      return { type: "user", stateName: BUILT_IN_STATES.user, stateId: (ctx) => ctx.userId, field };
     case "conversation":
-      return { type: "conversation", stateName: "conversationState", stateId: (ctx) => ctx.conversationId, field };
+      return {
+        type: "conversation",
+        stateName: BUILT_IN_STATES.conversation,
+        stateId: (ctx) => ctx.conversationId,
+        field
+      };
     default:
       throw new Error(`Unknown state type "${prefix}" in path "${path42}" — expected bot, user, or conversation`);
   }
@@ -11998,7 +12474,9 @@ async function fetchState(client, type, id, name) {
     const payload = result.state?.payload;
     return payload?.value ?? payload ?? null;
   } catch (err) {
-    if (err?.code === 404 || err?.message?.includes("404") || err?.message?.includes("doesn't exist")) {
+    const code = err != null && typeof err === "object" && "code" in err ? err.code : undefined;
+    const message = err instanceof Error ? err.message : "";
+    if (code === 404 || message.includes("404") || message.includes("doesn't exist")) {
       return null;
     }
     throw err;
@@ -12022,7 +12500,7 @@ async function snapshotState(client, assertions, ctx) {
     if (assertion.changed === undefined)
       continue;
     const parsed = parseStatePath(assertion.path);
-    if (parsed.type === "conversation")
+    if (parsed.type === "conversation" && !ctx.conversationId)
       continue;
     const payload = await fetchState(client, parsed.type, parsed.stateId(ctx), parsed.stateName);
     snapshots.set(assertion.path, payload ? payload[parsed.field] : undefined);
@@ -12199,9 +12677,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 +12696,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;
@@ -12232,6 +12713,22 @@ function gradeWorkflows(spans, assertions) {
   return results;
 }
 
+// src/eval/graders/timing.ts
+function gradeTiming(botDuration, assertions) {
+  const results = [];
+  for (const assertion of assertions) {
+    const pass = matchValue(assertion.response_time, botDuration);
+    const expected = operatorToString(assertion.response_time);
+    results.push({
+      assertion: `response_time ${expected}`,
+      pass,
+      expected: `Response time ${expected}`,
+      actual: `${botDuration}ms`
+    });
+  }
+  return results;
+}
+
 // src/eval/graders/outcome.ts
 async function snapshotOutcomeState(client, evalDef, ctx) {
   if (!evalDef.outcome?.state) {
@@ -12261,8 +12758,65 @@ async function gradeOutcome(client, evalDef, ctx, traceSpans, preSnapshots) {
 
 // src/eval/runner.ts
 import { randomUUID } from "crypto";
+var DEFAULT_IDLE_TIMEOUT = 15000;
+var WORKFLOW_TRIGGER_TIMEOUT_MS = 5 * 60 * 1000;
+function buildStatePayload(value) {
+  return {
+    value,
+    location: { type: "state" }
+  };
+}
+async function seedEvalState(client, ctx, setup) {
+  const state = setup?.state;
+  if (!state)
+    return;
+  const writes = [];
+  if (state.bot) {
+    writes.push(client.setState({
+      type: "bot",
+      id: ctx.botId,
+      name: BUILT_IN_STATES2.bot,
+      payload: buildStatePayload(state.bot)
+    }));
+  }
+  if (state.user) {
+    writes.push(client.setState({
+      type: "user",
+      id: ctx.userId,
+      name: BUILT_IN_STATES2.user,
+      payload: buildStatePayload(state.user)
+    }));
+  }
+  if (state.conversation) {
+    if (!ctx.conversationId) {
+      throw new Error("Cannot seed conversation state before a conversation is created.");
+    }
+    writes.push(client.setState({
+      type: "conversation",
+      id: ctx.conversationId,
+      name: BUILT_IN_STATES2.conversation,
+      payload: buildStatePayload(state.conversation)
+    }));
+  }
+  await Promise.all(writes);
+}
+async function triggerEvalWorkflow(client, ctx, setup) {
+  const workflow = setup?.workflow;
+  if (!workflow)
+    return;
+  await client.createWorkflow({
+    name: workflow.trigger,
+    input: workflow.input ?? {},
+    status: "pending",
+    conversationId: ctx.conversationId,
+    userId: ctx.userId,
+    timeoutAt: new Date(Date.now() + WORKFLOW_TRIGGER_TIMEOUT_MS).toISOString()
+  });
+}
 async function runEval(evalDef, connection, options = {}) {
   const devServerUrl = options.devServerUrl || "http://localhost:3001";
+  const idleTimeout = evalDef.options?.idleTimeout ?? options.idleTimeout ?? DEFAULT_IDLE_TIMEOUT;
+  const judgePassThreshold = evalDef.options?.judgePassThreshold ?? options.judgePassThreshold;
   const start = Date.now();
   const turns = [];
   let outcomeAssertions = [];
@@ -12280,34 +12834,67 @@ async function runEval(evalDef, connection, options = {}) {
       }
       return bpClient;
     };
+    let lastConversationId = "";
+    if (evalDef.setup?.state?.conversation || evalDef.setup?.workflow) {
+      lastConversationId = await session.ensureConversation();
+    }
+    await seedEvalState(getBpClient(), {
+      botId: connection.botId,
+      userId: session.userId,
+      conversationId: lastConversationId || undefined
+    }, evalDef.setup);
+    await triggerEvalWorkflow(getBpClient(), {
+      userId: session.userId,
+      conversationId: lastConversationId || undefined
+    }, evalDef.setup);
     let preSnapshots = new Map;
     if (evalDef.outcome?.state) {
       const ctx = {
         botId: connection.botId,
         userId: session.userId,
-        conversationId: ""
+        conversationId: lastConversationId
       };
       preSnapshots = await snapshotOutcomeState(getBpClient(), evalDef, ctx);
     }
     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
-      });
+      if (turn.expectSilence && turn.assert?.response) {
+        throw new Error(`Turn ${i + 1}: 'expectSilence' and 'assert.response' are mutually exclusive.`);
+      }
+      if (turn.user && turn.event) {
+        throw new Error(`Turn ${i + 1}: 'user' and 'event' are mutually exclusive.`);
+      }
+      if (!turn.user && !turn.event) {
+        throw new Error(`Turn ${i + 1}: must have either 'user' or 'event'.`);
+      }
+      const sendOptions = { timeout: Math.max(30000, idleTimeout * 2), idleTimeout, expectSilence: turn.expectSilence };
+      const result = turn.event ? await session.sendEvent(turn.event.type, turn.event.payload ?? {}, sendOptions) : await session.sendMessage(turn.user, sendOptions);
       const botDuration = Date.now() - turnStart;
+      if (!turn.expectSilence && result.responses.length === 0) {
+        throw new Error(`Turn ${i + 1}: bot produced no response.`);
+      }
       lastConversationId = result.conversationId;
       const botResponse = result.responses.map((r) => r.text).join(`
 `);
+      const turnLabel = turn.event ? `[event: ${turn.event.type}]` : turn.user;
       const evalStart = Date.now();
       let assertions = [];
+      if (turn.expectSilence) {
+        const wasSilent = result.responses.length === 0;
+        assertions.push({
+          assertion: "no_response",
+          pass: wasSilent,
+          expected: "No response",
+          actual: wasSilent ? "No response" : `Bot responded: "${botResponse}"`
+        });
+      }
       if (turn.assert?.response) {
         assertions = await gradeResponse(botResponse, turn.assert.response, {
-          userMessage: turn.user
+          userMessage: turnLabel,
+          judgePassThreshold
         });
       }
       if (turn.assert?.tools) {
@@ -12318,7 +12905,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,20 +12952,24 @@ 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);
       }
+      if (turn.assert?.timing) {
+        const timingResults = gradeTiming(botDuration, turn.assert.timing);
+        assertions.push(...timingResults);
+      }
       const turnPass = assertions.every((a) => a.pass);
       const evalDuration = Date.now() - evalStart;
       turns.push({
         turnNumber: i + 1,
-        userMessage: turn.user,
+        userMessage: turnLabel,
         botResponse,
         assertions,
         pass: turnPass,
@@ -12387,10 +12978,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 +12990,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 = [
           {
@@ -12440,11 +13031,11 @@ async function runEval(evalDef, connection, options = {}) {
 async function runEvalSuite(config, filter) {
   const start = Date.now();
   const runId = randomUUID().replace(/-/g, "").slice(0, 26);
-  initLLMJudge({
+  await initLLMJudge({
     token: config.credentials.token,
     apiUrl: config.credentials.apiUrl,
     botId: config.credentials.botId
-  });
+  }, { model: config.evalOptions?.judgeModel, logger: config.logger });
   const evalsDir = `${config.agentPath}/evals`;
   const allEvals = await loadEvalsFromDir(evalsDir);
   const evals = filterEvals(allEvals, filter);
@@ -12476,7 +13067,11 @@ 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,
+      judgePassThreshold: config.evalOptions?.judgePassThreshold
+    });
     reports.push(report);
     config.onProgress?.({ type: "eval_complete", evalName: evalDef.name, index: i, report });
   }
@@ -12564,8 +13159,10 @@ export {
   dependenciesKeyOrder,
   defineEval,
   coerceConfigValue,
+  buildOpenCodeConfig,
   bpCliImporter,
   auth,
+  agentLocalInfoKeyOrder,
   agentInfoKeyOrder,
   ValidationSeverity,
   ValidationErrors,
@@ -12576,6 +13173,7 @@ export {
   PreflightFormatter,
   PreflightChecker,
   PluginParser,
+  OpenCodeCommand,
   KnowledgeManager,
   KBSyncOperation,
   KBSyncFormatter,
@@ -12611,4 +13209,4 @@ export {
   AgentProject
 };
 
-//# debugId=B46A4264E95B176864756E2164756E21
+//# debugId=984405F8F441F45F64756E2164756E21