@botpress/adk 1.16.7 → 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
     };
@@ -729,7 +776,7 @@ var _format = null, _formatLoaded = false, formatCode = async (code, filepath) =
 `));
     return code;
   }
-}, ADK_VERSION = "1.16.7", 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}`;
@@ -860,16 +907,31 @@ var init_integration_action_types = __esm(() => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@botpress/adk",
-    version: "1.16.7",
+    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",
@@ -884,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.7",
-      "@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",
@@ -924,6 +971,7 @@ var require_package = __commonJS((exports, module) => {
       "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",
@@ -934,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"
   };
@@ -1104,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();
   }
@@ -1153,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.2.0";
+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");
@@ -1648,9 +1699,9 @@ class BpDevCommand extends BaseCommand {
     if (sourceMap) {
       bpArgs.push("--sourceMap");
     }
-    const consoleUrl = `http://localhost:${this.options.internalOtlpPort}`;
+    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_CONSOLE_URL=${consoleUrl}`];
+    const traceLines = [`[bp-dev] Trace endpoints:`, `  ADK_SPAN_INGEST_URL=${spanIngestUrl}`];
     if (otlpEndpoint) {
       traceLines.push(`  OTEL_EXPORTER_OTLP_ENDPOINT=${otlpEndpoint}`);
     }
@@ -1673,7 +1724,7 @@ class BpDevCommand extends BaseCommand {
         },
         WORKER_MODE: "true",
         WORKER_LIFETIME_MS: process.env.WORKER_LIFETIME_MS || "120000",
-        ADK_CONSOLE_URL: consoleUrl,
+        ADK_SPAN_INGEST_URL: spanIngestUrl,
         ...otlpEndpoint && { OTEL_EXPORTER_OTLP_ENDPOINT: otlpEndpoint },
         ...this.options.botName && { ADK_BOT_NAME: this.options.botName },
         ADK_DIRECTORY: join2(botPath, ".."),
@@ -1902,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;
     }
@@ -1986,8 +2038,8 @@ You also have access to Botpress documentation search for platform-level questio
 **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));
+  if (options.uiServerPort)
+    command.push("--port", String(options.uiServerPort));
   return {
     ...options.openCodePort && {
       server: {
@@ -2060,7 +2112,7 @@ class OpenCodeCommand extends BaseCommand {
     const opencodeConfig = JSON.stringify(buildOpenCodeConfig({
       adkBinPath: adkBin,
       agentPath: cwd,
-      devServerPort: this.options.devServerPort,
+      uiServerPort: this.options.uiServerPort,
       openCodePort: port,
       corsOrigins
     }));
@@ -2122,7 +2174,13 @@ class OpenCodeCommand extends BaseCommand {
       } catch {}
       await new Promise((r) => setTimeout(r, 500));
     }
-    this.emitReady();
+    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;
@@ -2207,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) {
@@ -2292,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: {}
@@ -2825,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_-]*$/;
@@ -2836,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 {
@@ -2938,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 {
@@ -2998,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));
         }
@@ -3269,7 +3328,7 @@ class IntegrationCache {
         }
       }
       return cached.definition;
-    } catch (error) {
+    } catch {
       return null;
     }
   }
@@ -4658,7 +4717,7 @@ async function expandExports(options) {
         });
         return {};
       }
-      currentError = currentError.cause;
+      currentError = currentError instanceof Error ? currentError.cause : undefined;
     }
     throw importError;
   }
@@ -4924,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) {
@@ -5128,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 ["*"];
@@ -5210,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 */,
@@ -5227,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 */,
@@ -5245,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 */,
@@ -5262,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 */,
@@ -5279,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 */,
@@ -5296,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 */,
@@ -5619,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
 
@@ -5694,7 +5840,7 @@ class AgentProjectGenerator {
         deploy: "adk deploy"
       },
       dependencies: {
-        "@botpress/runtime": `^${"1.16.7"}`
+        "@botpress/runtime": `^${"1.17.0"}`
       },
       devDependencies: {
         typescript: "^5.9.3"
@@ -5797,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/
@@ -6227,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";
 
@@ -6255,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");
 };
@@ -6487,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();
@@ -6606,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}`);
           }
@@ -6926,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;
@@ -7075,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];
@@ -7864,7 +8022,7 @@ class DevIdManager {
       if (!project.agentInfo) {
         throw ValidationErrors.agentNotLinked();
       }
-      await project.updateAgentInfo({
+      await project.updateAgentLocalInfo({
         devId: projectCache.devId
       });
     }
@@ -7891,7 +8049,7 @@ class DevIdManager {
         const client = await this.getClient();
         await client.getBot({ id: agentInfo.devId });
         return true;
-      } catch (error) {
+      } catch {
         return false;
       }
     }
@@ -8264,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);
@@ -9281,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 = {};
@@ -9569,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;
@@ -9600,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";
   }
@@ -9617,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) {
@@ -9633,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;
     }
@@ -10862,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";
@@ -10904,7 +11070,7 @@ class FileWatcher2 extends EventEmitter3 {
           this.updateFileState(fullPath);
         }
       }
-    } catch (error) {}
+    } catch {}
   }
   watchFile(filePath) {
     if (this.watchers.has(filePath)) {
@@ -10937,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;
@@ -10957,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) {
@@ -10976,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());
@@ -11755,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";
@@ -11775,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;
@@ -11808,7 +12015,7 @@ class ChatSession {
       };
       const overallTimer = setTimeout(() => {
         if (!resolved) {
-          if (responses.length > 0) {
+          if (responses.length > 0 || options.expectSilence) {
             done();
           } else {
             resolved = true;
@@ -11831,10 +12038,7 @@ class ChatSession {
           done();
         }
       });
-      this.client.createMessage({
-        conversationId,
-        payload: { type: "text", text: message }
-      }).then(() => {
+      trigger().then(() => {
         resetIdle();
       }).catch((err) => {
         clearTimeout(overallTimer);
@@ -11845,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 });
@@ -11852,7 +12070,7 @@ 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;
@@ -11914,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
@@ -11937,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,
@@ -11970,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",
@@ -11999,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 {
@@ -12049,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;
     }
@@ -12201,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) {
@@ -12210,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`);
   }
@@ -12225,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;
@@ -12249,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);
@@ -12462,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) {
@@ -12492,9 +12759,64 @@ 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 = [];
@@ -12512,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 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: Math.max(30000, idleTimeout * 2),
-        idleTimeout
-      });
+      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) {
@@ -12606,11 +12961,15 @@ async function runEval(evalDef, connection, options = {}) {
         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,
@@ -12672,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);
@@ -12708,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, idleTimeout: config.evalOptions?.idleTimeout });
+    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 });
   }
@@ -12799,6 +13162,7 @@ export {
   buildOpenCodeConfig,
   bpCliImporter,
   auth,
+  agentLocalInfoKeyOrder,
   agentInfoKeyOrder,
   ValidationSeverity,
   ValidationErrors,
@@ -12845,4 +13209,4 @@ export {
   AgentProject
 };
 
-//# debugId=BA9CF8B5F775A63B64756E2164756E21
+//# debugId=984405F8F441F45F64756E2164756E21