@standardagents/builder 0.12.8 → 0.13.0-next.c55f029

package/dist/plugin.js

@@ -1,5 +1,5 @@
-import * as fs2 from 'fs';
-import fs2__default from 'fs';
+import * as fs4 from 'fs';
+import fs4__default from 'fs';
 import * as path8 from 'path';
 import path8__default from 'path';
 import { fileURLToPath } from 'url';
@@ -40,15 +40,15 @@ function extractSchemaFields(content) {
 }
 function scanPromptsWithSchemas(dir) {
   const results = [];
-  if (!fs2__default.existsSync(dir)) {
+  if (!fs4__default.existsSync(dir)) {
     return results;
   }
   try {
-    const entries = fs2__default.readdirSync(dir, { withFileTypes: true });
+    const entries = fs4__default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".ts")) {
         const filePath = path8__default.join(dir, entry.name);
-        const content = fs2__default.readFileSync(filePath, "utf-8");
+        const content = fs4__default.readFileSync(filePath, "utf-8");
         const nameMatch = content.match(/name:\s*['"]([^'"]+)['"]/);
         if (nameMatch) {
           const name = nameMatch[1];
@@ -64,15 +64,15 @@ function scanPromptsWithSchemas(dir) {
 }
 function scanAgentsWithSideA(dir) {
   const results = [];
-  if (!fs2__default.existsSync(dir)) {
+  if (!fs4__default.existsSync(dir)) {
     return results;
   }
   try {
-    const entries = fs2__default.readdirSync(dir, { withFileTypes: true });
+    const entries = fs4__default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".ts")) {
         const filePath = path8__default.join(dir, entry.name);
-        const content = fs2__default.readFileSync(filePath, "utf-8");
+        const content = fs4__default.readFileSync(filePath, "utf-8");
         const nameMatch = content.match(/name:\s*['"]([^'"]+)['"]/);
         if (nameMatch) {
           const name = nameMatch[1];
@@ -92,15 +92,15 @@ function scanAgentsWithSideA(dir) {
 }
 function scanForNames(dir, useFilename = false) {
   const names = [];
-  if (!fs2__default.existsSync(dir)) {
+  if (!fs4__default.existsSync(dir)) {
     return names;
   }
   try {
-    const entries = fs2__default.readdirSync(dir, { withFileTypes: true });
+    const entries = fs4__default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".ts")) {
         const filePath = path8__default.join(dir, entry.name);
-        const content = fs2__default.readFileSync(filePath, "utf-8");
+        const content = fs4__default.readFileSync(filePath, "utf-8");
         if (useFilename) {
           const toolName = entry.name.replace(/\.ts$/, "");
           if (content.includes("defineTool")) {
@@ -121,18 +121,18 @@ function scanForNames(dir, useFilename = false) {
 }
 function scanHooksForIds(dir) {
   const hookIds = [];
-  if (!fs2__default.existsSync(dir)) {
+  if (!fs4__default.existsSync(dir)) {
     return hookIds;
   }
   try {
-    const entries = fs2__default.readdirSync(dir, { withFileTypes: true });
+    const entries = fs4__default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".ts")) {
         if (entry.name === "index.ts") {
           continue;
         }
         const filePath = path8__default.join(dir, entry.name);
-        const content = fs2__default.readFileSync(filePath, "utf-8");
+        const content = fs4__default.readFileSync(filePath, "utf-8");
         const idMatch = content.match(/defineHook\s*\(\s*\{[^}]*id:\s*['"]([^'"]+)['"]/s);
         if (idMatch) {
           hookIds.push(idMatch[1]);
@@ -350,6 +350,8 @@ declare module 'virtual:@standardagents/builder' {
       agent_id: string;
       user_id: string | null;
       tags: string[];
+      parent?: string | null;
+      terminated?: number | null;
       created_at: number;
     };
     agent: {
@@ -403,11 +405,48 @@ declare module 'virtual:@standardagents/builder' {
       initial_messages?: any[],
       data?: any
     ): Promise<Response>;
+    executeBlocking(
+      threadId: string,
+      agentId: string,
+      initial_messages?: any[],
+      data?: any
+    ): Promise<{
+      status: 'success' | 'error';
+      result?: string;
+      error?: string;
+      attachments?: unknown[];
+    }>;
     sendMessage(
       threadId: string,
       content: string,
       role?: string
     ): Promise<Response>;
+    queueMessage(
+      threadId: string,
+      message: {
+        role: 'user' | 'assistant';
+        content: string;
+        attachments?: unknown[];
+        silent?: boolean;
+        metadata?: Record<string, unknown>;
+      }
+    ): Promise<void>;
+    getChildrenRegistry(threadId: string): Promise<Array<{
+      reference: string;
+      name: string;
+      description: string;
+      status: string;
+    }>>;
+    upsertChildRegistry(threadId: string, entry: {
+      reference: string;
+      name: string;
+      description: string;
+      status: string;
+    }): Promise<void>;
+    updateChildRegistryStatus(threadId: string, reference: string, status: string): Promise<void>;
+    removeChildRegistry(threadId: string, reference: string): Promise<void>;
+    getTerminated(threadId: string): Promise<number | null>;
+    terminateThread(threadId: string): Promise<{ success: boolean; terminated: number }>;
     stop(): Promise<Response>;
     shouldStop(): Promise<boolean>;
 
@@ -468,6 +507,10 @@ declare module 'virtual:@standardagents/builder' {
     agent_name: string;
     user_id: string | null;
     tags: string[] | null;
+    tenvs?: Record<string, unknown> | null;
+    properties?: Record<string, unknown> | null;
+    parent: string | null;
+    terminated: number | null;
     created_at: number;
   }
 
@@ -528,6 +571,9 @@ declare module 'virtual:@standardagents/builder' {
       agent_name: string;
       user_id?: string;
       tags?: string[];
+      tenvs?: Record<string, unknown>;
+      properties?: Record<string, unknown>;
+      parent?: string;
     }): Promise<ThreadRegistryEntry>;
     getThread(id: string): Promise<ThreadRegistryEntry | null>;
     listThreads(params?: {
@@ -539,6 +585,7 @@ declare module 'virtual:@standardagents/builder' {
       limit?: number;
       offset?: number;
     }): Promise<{ threads: ThreadRegistryEntry[]; total: number }>;
+    getThreadTreeIds(rootThreadId: string): Promise<string[]>;
     deleteThread(id: string): Promise<boolean>;
     updateThreadAgent(id: string, agent_name: string): Promise<boolean>;
     updateThread(id: string, params: UpdateThreadParams): Promise<ThreadRegistryEntry | null>;
@@ -679,35 +726,35 @@ declare module 'virtual:@standardagents/router' {
 `;
 }
 function ensureDir(dir) {
-  if (!fs2__default.existsSync(dir)) {
-    fs2__default.mkdirSync(dir, { recursive: true });
+  if (!fs4__default.existsSync(dir)) {
+    fs4__default.mkdirSync(dir, { recursive: true });
   }
 }
 function generateTypes(config) {
   ensureDir(config.outputDir);
   const typesContent = generateTypesContent(config);
-  fs2__default.writeFileSync(path8__default.join(config.outputDir, "types.d.ts"), typesContent);
+  fs4__default.writeFileSync(path8__default.join(config.outputDir, "types.d.ts"), typesContent);
   const virtualModuleContent = generateVirtualModuleContent();
-  fs2__default.writeFileSync(path8__default.join(config.outputDir, "virtual-module.d.ts"), virtualModuleContent);
-  fs2__default.writeFileSync(path8__default.join(config.outputDir, "tsconfig.json"), TSCONFIG_CONTENT);
-  fs2__default.writeFileSync(path8__default.join(config.outputDir, ".gitignore"), "*\n");
+  fs4__default.writeFileSync(path8__default.join(config.outputDir, "virtual-module.d.ts"), virtualModuleContent);
+  fs4__default.writeFileSync(path8__default.join(config.outputDir, "tsconfig.json"), TSCONFIG_CONTENT);
+  fs4__default.writeFileSync(path8__default.join(config.outputDir, ".gitignore"), "*\n");
 }
 function needsRegeneration(config) {
   const typesPath = path8__default.join(config.outputDir, "types.d.ts");
-  if (!fs2__default.existsSync(typesPath)) {
+  if (!fs4__default.existsSync(typesPath)) {
     return true;
   }
-  const typesMtime = fs2__default.statSync(typesPath).mtime;
+  const typesMtime = fs4__default.statSync(typesPath).mtime;
   const dirs = [config.modelsDir, config.promptsDir, config.agentsDir, config.toolsDir, config.hooksDir];
   for (const dir of dirs) {
-    if (!fs2__default.existsSync(dir)) {
+    if (!fs4__default.existsSync(dir)) {
       continue;
     }
-    const entries = fs2__default.readdirSync(dir, { withFileTypes: true });
+    const entries = fs4__default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".ts")) {
         const filePath = path8__default.join(dir, entry.name);
-        const fileMtime = fs2__default.statSync(filePath).mtime;
+        const fileMtime = fs4__default.statSync(filePath).mtime;
         if (fileMtime > typesMtime) {
           return true;
         }
@@ -982,10 +1029,18 @@ function generatePromptFile(data) {
   if (data.toolChoice && data.toolChoice !== "auto") {
     lines.push(`  toolChoice: '${data.toolChoice}',`);
   }
+  if (data.variables && data.variables.length > 0) {
+    const variablesCode = formatVariablesArray(data.variables);
+    lines.push(`  variables: ${variablesCode},`);
+  }
   if (data.tools && data.tools.length > 0) {
     const toolsCode = formatToolsArray(data.tools);
     lines.push(`  tools: ${toolsCode},`);
   }
+  const promptEnv = data.env ?? (data.tenvs || void 0);
+  if (promptEnv && Object.keys(promptEnv).length > 0) {
+    lines.push(`  env: ${JSON.stringify(promptEnv)},`);
+  }
   if (data.reasoning && hasNonNullProperties(data.reasoning)) {
     const reasoningCode = formatReasoningConfig(data.reasoning);
     lines.push(`  reasoning: ${reasoningCode},`);
@@ -1020,6 +1075,30 @@ function formatToolsArray(tools) {
 ${indented}
   ]`;
 }
+function formatVariablesArray(variables) {
+  const normalized = variables.filter((entry) => typeof entry.name === "string" && entry.name.trim().length > 0).map((entry) => ({
+    name: entry.name.trim(),
+    type: entry.type === "secret" ? "secret" : "text",
+    required: !!entry.required,
+    description: typeof entry.description === "string" ? entry.description : ""
+  }));
+  if (normalized.length === 0) return "[]";
+  const formatted = normalized.map((entry) => {
+    const parts = [
+      `name: '${escapeString2(entry.name)}'`,
+      `type: '${entry.type}'`,
+      `required: ${entry.required}`,
+      `description: '${escapeString2(entry.description)}'`
+    ];
+    return `{ ${parts.join(", ")} }`;
+  });
+  if (formatted.length === 1) {
+    return `[${formatted[0]}]`;
+  }
+  return `[
+    ${formatted.join(",\n    ")}
+  ]`;
+}
 function formatToolConfig(config) {
   const parts = [];
   parts.push(`name: '${escapeString2(config.name)}'`);
@@ -1038,8 +1117,56 @@ function formatToolConfig(config) {
   if (config.init_attachments_property !== void 0 && config.init_attachments_property !== null) {
     parts.push(`initAttachmentsProperty: '${escapeString2(config.init_attachments_property)}'`);
   }
-  if (config.tenvs && Object.keys(config.tenvs).length > 0) {
-    parts.push(`tenvs: ${JSON.stringify(config.tenvs)}`);
+  if (config.init_agent_name_property !== void 0 && config.init_agent_name_property !== null) {
+    parts.push(`initAgentNameProperty: '${escapeString2(config.init_agent_name_property)}'`);
+  }
+  if (config.blocking !== void 0 && config.blocking !== true) {
+    parts.push(`blocking: ${config.blocking}`);
+  }
+  if (config.optional !== void 0 && config.optional !== null && config.optional !== "") {
+    parts.push(`optional: '${escapeString2(config.optional)}'`);
+  }
+  if (config.immediate !== void 0) {
+    if (typeof config.immediate === "boolean") {
+      if (config.immediate) {
+        parts.push(`immediate: true`);
+      }
+    } else if (config.immediate && typeof config.immediate === "object") {
+      const immediateParts = [];
+      if (config.immediate.name_env) {
+        immediateParts.push(`nameEnv: '${escapeString2(config.immediate.name_env)}'`);
+      }
+      if (config.immediate.description_env) {
+        immediateParts.push(`descriptionEnv: '${escapeString2(config.immediate.description_env)}'`);
+      }
+      if (config.immediate.scoped_env && config.immediate.scoped_env.length > 0) {
+        const scoped = config.immediate.scoped_env.map((entry) => `'${escapeString2(entry)}'`).join(", ");
+        immediateParts.push(`scopedEnv: [${scoped}]`);
+      }
+      parts.push(`immediate: { ${immediateParts.join(", ")} }`);
+    }
+  }
+  if (config.resumable !== void 0) {
+    if (config.resumable === false) {
+      parts.push(`resumable: false`);
+    } else if (config.resumable && typeof config.resumable === "object") {
+      const resumableParts = [
+        `receives_messages: '${config.resumable.receives_messages}'`
+      ];
+      if (config.resumable.max_instances !== void 0 && config.resumable.max_instances !== null) {
+        resumableParts.push(`maxInstances: ${config.resumable.max_instances}`);
+      }
+      if (config.resumable.parent_communication !== void 0 && config.resumable.parent_communication !== null) {
+        resumableParts.push(
+          `parentCommunication: '${config.resumable.parent_communication}'`
+        );
+      }
+      parts.push(`resumable: { ${resumableParts.join(", ")} }`);
+    }
+  }
+  const env = config.env ?? (config.tenvs || void 0);
+  if (env && Object.keys(env).length > 0) {
+    parts.push(`env: ${JSON.stringify(env)}`);
   }
   return `{ ${parts.join(", ")} }`;
 }
@@ -1120,6 +1247,9 @@ function formatStructuredPrompt(parts) {
     } else if (part.type === "include") {
       const promptName = part.prompt || "";
       return `    { type: 'include', prompt: '${escapeString2(promptName)}' }`;
+    } else if (part.type === "env") {
+      const property = part.property || "";
+      return `    { type: 'env', property: '${escapeString2(property)}' }`;
     }
     return `    // Unknown part type: ${part.type}`;
   });
@@ -1134,6 +1264,9 @@ function normalizePart(part) {
   if (part.type === "include") {
     return { type: "include", prompt: part.prompt || "" };
   }
+  if (part.type === "env") {
+    return { type: "env", property: part.property || part.value || "" };
+  }
   if (part.type === "string") {
     return { type: "text", content: part.value || "" };
   }
@@ -1185,8 +1318,9 @@ function generateAgentFile(data) {
   if (data.toolDescription) {
     lines.push(`  toolDescription: '${escapeString3(data.toolDescription)}',`);
   }
-  if (data.tenvs && Object.keys(data.tenvs).length > 0) {
-    lines.push(`  tenvs: ${JSON.stringify(data.tenvs)},`);
+  const env = data.env ?? (data.tenvs || void 0);
+  if (env && Object.keys(env).length > 0) {
+    lines.push(`  env: ${JSON.stringify(env)},`);
   }
   lines.push(`});`);
   lines.push("");
@@ -1210,9 +1344,21 @@ function formatSideConfig(config) {
   if (config.maxSteps !== void 0) {
     parts.push(`    maxSteps: ${config.maxSteps},`);
   }
-  if (config.endSessionTool) {
+  if (config.sessionStop) {
+    parts.push(`    sessionStop: ${formatSessionBinding(config.sessionStop)},`);
+  } else if (config.endSessionTool) {
     parts.push(`    endSessionTool: '${escapeString3(config.endSessionTool)}',`);
   }
+  if (config.sessionFail) {
+    parts.push(`    sessionFail: ${formatSessionBinding(config.sessionFail)},`);
+  } else if (config.failSessionTool) {
+    parts.push(`    failSessionTool: '${escapeString3(config.failSessionTool)}',`);
+  }
+  if (config.sessionStatus) {
+    parts.push(`    sessionStatus: ${formatSessionBinding(config.sessionStatus)},`);
+  } else if (config.statusTool) {
+    parts.push(`    statusTool: '${escapeString3(config.statusTool)}',`);
+  }
   if (config.manualStopCondition) {
     parts.push(`    manualStopCondition: ${config.manualStopCondition},`);
   }
@@ -1222,6 +1368,19 @@ function formatSideConfig(config) {
 function escapeString3(str) {
   return str.replace(/'/g, "\\'").replace(/\\/g, "\\\\");
 }
+function formatSessionBinding(binding) {
+  if (typeof binding === "string") {
+    return `'${escapeString3(binding)}'`;
+  }
+  const parts = [`name: '${escapeString3(binding.name)}'`];
+  if (binding.messageProperty) {
+    parts.push(`messageProperty: '${escapeString3(binding.messageProperty)}'`);
+  }
+  if (binding.attachmentsProperty) {
+    parts.push(`attachmentsProperty: '${escapeString3(binding.attachmentsProperty)}'`);
+  }
+  return `{ ${parts.join(", ")} }`;
+}
 
 // src/sdk/persistence/index.ts
 var PROVIDER_PACKAGE_MAP = {
@@ -1240,15 +1399,15 @@ function getModelFilePath(modelsDir, name) {
 }
 function modelExists(modelsDir, name) {
   const filePath = getModelFilePath(modelsDir, name);
-  return fs2__default.existsSync(filePath);
+  return fs4__default.existsSync(filePath);
 }
 async function saveModel(modelsDir, data, overwrite = false) {
   try {
-    if (!fs2__default.existsSync(modelsDir)) {
-      fs2__default.mkdirSync(modelsDir, { recursive: true });
+    if (!fs4__default.existsSync(modelsDir)) {
+      fs4__default.mkdirSync(modelsDir, { recursive: true });
     }
     const filePath = getModelFilePath(modelsDir, data.name);
-    if (!overwrite && fs2__default.existsSync(filePath)) {
+    if (!overwrite && fs4__default.existsSync(filePath)) {
       return {
         success: false,
         error: `Model file already exists: ${filePath}. Use update to modify existing models.`
@@ -1265,7 +1424,7 @@ async function saveModel(modelsDir, data, overwrite = false) {
       providerName: providerInfo.name,
       providerPackage: providerInfo.package
     });
-    await fs2__default.promises.writeFile(filePath, content, "utf-8");
+    await fs4__default.promises.writeFile(filePath, content, "utf-8");
     return {
       success: true,
       filePath
@@ -1280,13 +1439,13 @@ async function saveModel(modelsDir, data, overwrite = false) {
 async function deleteModel(modelsDir, name) {
   try {
     const filePath = getModelFilePath(modelsDir, name);
-    if (!fs2__default.existsSync(filePath)) {
+    if (!fs4__default.existsSync(filePath)) {
       return {
         success: false,
         error: `Model file not found: ${filePath}`
       };
     }
-    await fs2__default.promises.unlink(filePath);
+    await fs4__default.promises.unlink(filePath);
     return {
       success: true,
       filePath
@@ -1322,49 +1481,135 @@ function transformModelData(data) {
   return transformed;
 }
 function validateModelData(data) {
+  const errors = {};
   if (!data.name || typeof data.name !== "string") {
-    return "Model name is required and must be a string";
+    errors["name"] = "Model name is required";
   }
   if (!data.provider || typeof data.provider !== "string") {
-    return "Model provider is required and must be a string";
-  }
-  const validProviders = Object.keys(PROVIDER_PACKAGE_MAP);
-  if (!validProviders.includes(data.provider)) {
-    return `Invalid provider '${data.provider}'. Must be one of: ${validProviders.join(", ")}`;
+    errors["provider"] = "Provider is required";
+  } else {
+    const validProviders = Object.keys(PROVIDER_PACKAGE_MAP);
+    if (!validProviders.includes(data.provider)) {
+      errors["provider"] = `Invalid provider '${data.provider}'. Must be one of: ${validProviders.join(", ")}`;
+    }
   }
   if (!data.model || typeof data.model !== "string") {
-    return "Model ID is required and must be a string";
+    errors["model"] = "Model ID is required";
   }
   if (data.inputPrice !== void 0 && typeof data.inputPrice !== "number") {
-    return "inputPrice must be a number";
+    errors["input_price"] = "Input price must be a number";
   }
   if (data.outputPrice !== void 0 && typeof data.outputPrice !== "number") {
-    return "outputPrice must be a number";
+    errors["output_price"] = "Output price must be a number";
   }
   if (data.cachedPrice !== void 0 && typeof data.cachedPrice !== "number") {
-    return "cachedPrice must be a number";
+    errors["cached_price"] = "Cached price must be a number";
   }
   if (data.fallbacks !== void 0) {
     if (!Array.isArray(data.fallbacks)) {
-      return "fallbacks must be an array";
-    }
-    for (const fallback of data.fallbacks) {
-      if (typeof fallback !== "string") {
-        return "Each fallback must be a string (model name)";
+      errors["fallbacks"] = "Fallbacks must be an array";
+    } else {
+      for (const fallback of data.fallbacks) {
+        if (typeof fallback !== "string") {
+          errors["fallbacks"] = "Each fallback must be a string (model name)";
+          break;
+        }
       }
     }
   }
   if (data.includedProviders !== void 0) {
     if (!Array.isArray(data.includedProviders)) {
-      return "includedProviders must be an array";
-    }
-    for (const provider of data.includedProviders) {
-      if (typeof provider !== "string") {
-        return "Each includedProvider must be a string";
+      errors["included_providers"] = "Included providers must be an array";
+    } else {
+      for (const provider of data.includedProviders) {
+        if (typeof provider !== "string") {
+          errors["included_providers"] = "Each included provider must be a string";
+          break;
+        }
       }
     }
   }
-  return null;
+  return Object.keys(errors).length > 0 ? errors : null;
+}
+function normalizeStringEnvRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const normalized = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (!key) continue;
+    if (entry === void 0 || entry === null || entry === "") continue;
+    normalized[key] = String(entry);
+  }
+  return normalized;
+}
+function normalizeVariableDeclarations(value) {
+  if (!Array.isArray(value)) {
+    return void 0;
+  }
+  const declarations = value.filter((entry) => !!entry && typeof entry === "object").map((entry) => {
+    const name = typeof entry.name === "string" ? entry.name.trim() : "";
+    const description = typeof entry.description === "string" ? entry.description.trim() : "";
+    return {
+      name,
+      type: entry.type === "secret" ? "secret" : "text",
+      required: !!entry.required,
+      description
+    };
+  }).filter((entry) => entry.name.length > 0);
+  return declarations;
+}
+function normalizeStringArray(value) {
+  if (!Array.isArray(value)) return void 0;
+  const normalized = value.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+  return normalized;
+}
+function normalizePromptToolConfig(tool) {
+  const next = { ...tool };
+  const toolEnv = normalizeStringEnvRecord(next.env ?? next.tenvs);
+  if (toolEnv) {
+    next.env = toolEnv;
+  }
+  delete next.tenvs;
+  if (typeof next.init_agent_name_property === "string") {
+    next.initAgentNameProperty = next.init_agent_name_property;
+  }
+  delete next.init_agent_name_property;
+  if (next.immediate && typeof next.immediate === "object" && !Array.isArray(next.immediate)) {
+    const immediate = { ...next.immediate };
+    if (typeof immediate.name_env === "string") {
+      immediate.nameEnv = immediate.name_env;
+    }
+    if (typeof immediate.description_env === "string") {
+      immediate.descriptionEnv = immediate.description_env;
+    }
+    const scopedEnv = normalizeStringArray(immediate.scoped_env);
+    if (scopedEnv) {
+      immediate.scopedEnv = scopedEnv;
+    }
+    delete immediate.name_env;
+    delete immediate.description_env;
+    delete immediate.scoped_env;
+    next.immediate = immediate;
+  }
+  if (next.resumable && typeof next.resumable === "object" && !Array.isArray(next.resumable)) {
+    const resumable = { ...next.resumable };
+    if (typeof resumable.max_instances === "number") {
+      resumable.maxInstances = resumable.max_instances;
+    } else if (typeof resumable.max_instances === "string" && resumable.max_instances.trim() !== "") {
+      const parsed = Number(resumable.max_instances);
+      if (!Number.isNaN(parsed)) {
+        resumable.maxInstances = parsed;
+      }
+    }
+    if (typeof resumable.parent_communication === "string") {
+      resumable.parentCommunication = resumable.parent_communication;
+    }
+    delete resumable.max_instances;
+    delete resumable.parent_communication;
+    next.resumable = resumable;
+  }
+  return next;
 }
 function transformPromptData(data) {
   const transformed = {};
@@ -1395,8 +1640,11 @@ function transformPromptData(data) {
     if (transformed.reasoningEffort) {
       transformed.reasoning.effort = transformed.reasoningEffort;
     }
-    if (transformed.reasoningMaxTokens) {
-      transformed.reasoning.maxTokens = transformed.reasoningMaxTokens;
+    if (transformed.reasoningMaxTokens !== void 0 && transformed.reasoningMaxTokens !== null && transformed.reasoningMaxTokens !== "") {
+      const num = Number(transformed.reasoningMaxTokens);
+      if (!isNaN(num)) {
+        transformed.reasoning.maxTokens = num;
+      }
     }
     if (transformed.reasoningExclude !== void 0) {
       transformed.reasoning.exclude = transformed.reasoningExclude;
@@ -1409,6 +1657,22 @@ function transformPromptData(data) {
     delete transformed.reasoningExclude;
     delete transformed.includeReasoning;
   }
+  if (Array.isArray(transformed.tools)) {
+    transformed.tools = transformed.tools.map((tool) => {
+      if (!tool || typeof tool !== "object" || Array.isArray(tool)) {
+        return tool;
+      }
+      return normalizePromptToolConfig(tool);
+    });
+  }
+  if (transformed.env !== void 0 || transformed.tenvs !== void 0) {
+    transformed.env = normalizeStringEnvRecord(transformed.env ?? transformed.tenvs) ?? {};
+    delete transformed.tenvs;
+  }
+  const normalizedVariables = normalizeVariableDeclarations(transformed.variables);
+  if (normalizedVariables !== void 0) {
+    transformed.variables = normalizedVariables;
+  }
   return transformed;
 }
 function getPromptFilePath(promptsDir, name) {
@@ -1417,22 +1681,22 @@ function getPromptFilePath(promptsDir, name) {
 }
 function promptExists(promptsDir, name) {
   const filePath = getPromptFilePath(promptsDir, name);
-  return fs2__default.existsSync(filePath);
+  return fs4__default.existsSync(filePath);
 }
 async function savePrompt(promptsDir, data, overwrite = false) {
   try {
-    if (!fs2__default.existsSync(promptsDir)) {
-      fs2__default.mkdirSync(promptsDir, { recursive: true });
+    if (!fs4__default.existsSync(promptsDir)) {
+      fs4__default.mkdirSync(promptsDir, { recursive: true });
     }
     const filePath = getPromptFilePath(promptsDir, data.name);
-    if (!overwrite && fs2__default.existsSync(filePath)) {
+    if (!overwrite && fs4__default.existsSync(filePath)) {
       return {
         success: false,
         error: `Prompt file already exists: ${filePath}. Use update to modify existing prompts.`
       };
     }
     const content = generatePromptFile(data);
-    await fs2__default.promises.writeFile(filePath, content, "utf-8");
+    await fs4__default.promises.writeFile(filePath, content, "utf-8");
     return {
       success: true,
       filePath
@@ -1447,13 +1711,13 @@ async function savePrompt(promptsDir, data, overwrite = false) {
 async function deletePrompt(promptsDir, name) {
   try {
     const filePath = getPromptFilePath(promptsDir, name);
-    if (!fs2__default.existsSync(filePath)) {
+    if (!fs4__default.existsSync(filePath)) {
       return {
         success: false,
         error: `Prompt file not found: ${filePath}`
       };
     }
-    await fs2__default.promises.unlink(filePath);
+    await fs4__default.promises.unlink(filePath);
     return {
       success: true,
       filePath
@@ -1469,25 +1733,25 @@ async function renamePrompt(promptsDir, oldName, newName) {
   try {
     const oldFilePath = getPromptFilePath(promptsDir, oldName);
     const newFilePath = getPromptFilePath(promptsDir, newName);
-    if (!fs2__default.existsSync(oldFilePath)) {
+    if (!fs4__default.existsSync(oldFilePath)) {
       return {
         success: false,
         error: `Prompt file not found: ${oldFilePath}`
       };
     }
-    if (fs2__default.existsSync(newFilePath)) {
+    if (fs4__default.existsSync(newFilePath)) {
       return {
         success: false,
         error: `Prompt file already exists: ${newFilePath}`
       };
     }
-    const content = await fs2__default.promises.readFile(oldFilePath, "utf-8");
+    const content = await fs4__default.promises.readFile(oldFilePath, "utf-8");
     const updatedContent = content.replace(
       /name:\s*['"]([^'"]+)['"]/,
       `name: '${newName}'`
     );
-    await fs2__default.promises.writeFile(newFilePath, updatedContent, "utf-8");
-    await fs2__default.promises.unlink(oldFilePath);
+    await fs4__default.promises.writeFile(newFilePath, updatedContent, "utf-8");
+    await fs4__default.promises.unlink(oldFilePath);
     return {
       success: true,
       filePath: newFilePath
@@ -1500,56 +1764,165 @@ async function renamePrompt(promptsDir, oldName, newName) {
   }
 }
 function validatePromptData(data) {
+  const errors = {};
   if (!data.name || typeof data.name !== "string") {
-    return "Prompt name is required and must be a string";
-  }
-  if (data.name.includes("/")) {
-    return "Prompt name cannot contain '/'. Reserved for namespace qualification.";
+    errors["name"] = "Prompt name is required";
+  } else if (data.name.includes("/")) {
+    errors["name"] = "Prompt name cannot contain '/'";
   }
   if (!data.model || typeof data.model !== "string") {
-    return "Prompt model is required and must be a string";
+    errors["model_id"] = "Model is required";
   }
   if (data.toolDescription !== void 0 && typeof data.toolDescription !== "string") {
-    return "toolDescription must be a string";
+    errors["tool_description"] = "Tool description must be a string";
   }
-  if (data.prompt !== void 0 && typeof data.prompt !== "string") {
-    return "prompt must be a string";
+  if (data.prompt !== void 0 && typeof data.prompt !== "string" && !Array.isArray(data.prompt)) {
+    errors["prompt"] = "Prompt must be a string or structured prompt array";
   }
-  const booleanFields = ["includeChat", "includePastTools", "parallelToolCalls"];
-  for (const field of booleanFields) {
-    if (data[field] !== void 0 && typeof data[field] !== "boolean") {
-      return `${field} must be a boolean`;
+  const booleanFieldMap = {
+    includeChat: "include_chat",
+    includePastTools: "include_past_tools",
+    parallelToolCalls: "parallel_tool_calls"
+  };
+  for (const [camelField, snakeField] of Object.entries(booleanFieldMap)) {
+    if (data[camelField] !== void 0 && typeof data[camelField] !== "boolean") {
+      errors[snakeField] = `${snakeField} must be a boolean`;
     }
   }
   if (data.toolChoice !== void 0) {
     const validChoices = ["auto", "none", "required"];
     if (!validChoices.includes(data.toolChoice)) {
-      return `Invalid toolChoice '${data.toolChoice}'. Must be one of: ${validChoices.join(", ")}`;
+      errors["tool_choice"] = `Invalid tool choice '${data.toolChoice}'. Must be one of: ${validChoices.join(", ")}`;
     }
   }
   if (data.tools !== void 0 && !Array.isArray(data.tools)) {
-    return "tools must be an array";
+    errors["tools"] = "Tools must be an array";
+  } else if (Array.isArray(data.tools)) {
+    for (const tool of data.tools) {
+      if (typeof tool === "string") continue;
+      if (!tool || typeof tool !== "object" || Array.isArray(tool)) {
+        errors["tools"] = "Each tool must be a string or object";
+        break;
+      }
+      if (typeof tool.name !== "string" || tool.name.trim().length === 0) {
+        errors["tools"] = "Each tool config requires a non-empty name";
+        break;
+      }
+      if (tool.blocking !== void 0 && typeof tool.blocking !== "boolean") {
+        errors["tools"] = "Tool blocking must be a boolean";
+        break;
+      }
+      if (tool.optional !== void 0 && typeof tool.optional !== "string") {
+        errors["tools"] = "Tool optional must be a string";
+        break;
+      }
+      if (tool.immediate !== void 0 && typeof tool.immediate !== "boolean" && (typeof tool.immediate !== "object" || Array.isArray(tool.immediate) || tool.immediate === null)) {
+        errors["tools"] = "Tool immediate must be a boolean or object";
+        break;
+      }
+      if (tool.immediate && typeof tool.immediate === "object" && !Array.isArray(tool.immediate)) {
+        const immediate = tool.immediate;
+        if (immediate.nameEnv !== void 0 && typeof immediate.nameEnv !== "string") {
+          errors["tools"] = "Tool immediate.nameEnv must be a string";
+          break;
+        }
+        if (immediate.descriptionEnv !== void 0 && typeof immediate.descriptionEnv !== "string") {
+          errors["tools"] = "Tool immediate.descriptionEnv must be a string";
+          break;
+        }
+        if (immediate.scopedEnv !== void 0 && (!Array.isArray(immediate.scopedEnv) || immediate.scopedEnv.some((entry) => typeof entry !== "string"))) {
+          errors["tools"] = "Tool immediate.scopedEnv must be an array of strings";
+          break;
+        }
+      }
+      if (tool.resumable !== void 0 && tool.resumable !== false && (typeof tool.resumable !== "object" || Array.isArray(tool.resumable) || tool.resumable === null)) {
+        errors["tools"] = "Tool resumable must be false or an object";
+        break;
+      }
+      if (tool.resumable && typeof tool.resumable === "object" && !Array.isArray(tool.resumable)) {
+        const resumable = tool.resumable;
+        if (resumable.receives_messages !== void 0 && resumable.receives_messages !== "side_a" && resumable.receives_messages !== "side_b") {
+          errors["tools"] = 'Tool resumable.receives_messages must be "side_a" or "side_b"';
+          break;
+        }
+        if (resumable.maxInstances !== void 0 && (typeof resumable.maxInstances !== "number" || !Number.isFinite(resumable.maxInstances))) {
+          errors["tools"] = "Tool resumable.maxInstances must be a number";
+          break;
+        }
+        if (resumable.parentCommunication !== void 0 && resumable.parentCommunication !== "implicit" && resumable.parentCommunication !== "explicit") {
+          errors["tools"] = 'Tool resumable.parentCommunication must be "implicit" or "explicit"';
+          break;
+        }
+      }
+    }
   }
-  if (data.reasoning !== void 0) {
-    if (typeof data.reasoning !== "object") {
-      return "reasoning must be an object";
+  if (data.env !== void 0) {
+    if (!data.env || typeof data.env !== "object" || Array.isArray(data.env)) {
+      errors["env"] = "env must be an object of string values";
+    } else if (Object.values(data.env).some((value) => value !== void 0 && value !== null && typeof value !== "string")) {
+      errors["env"] = "env values must be strings";
     }
-    if (data.reasoning.effort !== void 0) {
-      const validEfforts = ["low", "medium", "high"];
-      if (!validEfforts.includes(data.reasoning.effort)) {
-        return `Invalid reasoning.effort '${data.reasoning.effort}'. Must be one of: ${validEfforts.join(", ")}`;
+  }
+  if (data.variables !== void 0) {
+    if (!Array.isArray(data.variables)) {
+      errors["variables"] = "variables must be an array";
+    } else {
+      for (const variable of data.variables) {
+        if (!variable || typeof variable !== "object") {
+          errors["variables"] = "Each variable declaration must be an object";
+          break;
+        }
+        if (typeof variable.name !== "string" || variable.name.trim().length === 0) {
+          errors["variables"] = "Each variable declaration requires a non-empty name";
+          break;
+        }
+        if (variable.type !== "text" && variable.type !== "secret") {
+          errors["variables"] = 'Variable type must be "text" or "secret"';
+          break;
+        }
+        if (typeof variable.required !== "boolean") {
+          errors["variables"] = "Variable required must be a boolean";
+          break;
+        }
+        if (typeof variable.description !== "string") {
+          errors["variables"] = "Variable description must be a string";
+          break;
+        }
       }
     }
-    if (data.reasoning.maxTokens !== void 0 && typeof data.reasoning.maxTokens !== "number") {
-      return "reasoning.maxTokens must be a number";
+  }
+  if (data.reasoning !== void 0) {
+    if (typeof data.reasoning !== "object") {
+      errors["reasoning_effort"] = "Reasoning configuration is invalid";
+    } else {
+      if (data.reasoning.effort !== void 0) {
+        const validEfforts = ["low", "medium", "high"];
+        if (!validEfforts.includes(data.reasoning.effort)) {
+          errors["reasoning_effort"] = `Invalid reasoning effort '${data.reasoning.effort}'. Must be one of: ${validEfforts.join(", ")}`;
+        }
+      }
+      if (data.reasoning.maxTokens !== void 0 && typeof data.reasoning.maxTokens !== "number") {
+        errors["reasoning_max_tokens"] = "Max reasoning tokens must be a number";
+      }
     }
   }
-  return null;
+  return Object.keys(errors).length > 0 ? errors : null;
 }
 function transformAgentData(data) {
   const transformed = {
     name: data.name
   };
+  const toSessionBinding = (toolName, messageProperty, attachmentsProperty) => {
+    if (!toolName) return void 0;
+    if (messageProperty || attachmentsProperty) {
+      return {
+        name: toolName,
+        ...messageProperty ? { messageProperty } : {},
+        ...attachmentsProperty ? { attachmentsProperty } : {}
+      };
+    }
+    return toolName;
+  };
   if (data.title) {
     transformed.title = data.title;
   }
@@ -1577,9 +1950,36 @@ function transformAgentData(data) {
   if (data.side_a_max_steps !== void 0) {
     transformed.sideA.maxSteps = data.side_a_max_steps;
   }
-  if (data.side_a_end_session_tool) {
+  const sideASessionStop = toSessionBinding(
+    data.side_a_session_stop_tool ?? data.side_a_end_session_tool,
+    data.side_a_session_stop_message_property,
+    data.side_a_session_stop_attachments_property
+  );
+  if (sideASessionStop !== void 0) {
+    transformed.sideA.sessionStop = sideASessionStop;
+  } else if (data.side_a_end_session_tool) {
     transformed.sideA.endSessionTool = data.side_a_end_session_tool;
   }
+  const sideASessionFail = toSessionBinding(
+    data.side_a_session_fail_tool ?? data.side_a_fail_session_tool,
+    data.side_a_session_fail_message_property,
+    data.side_a_session_fail_attachments_property
+  );
+  if (sideASessionFail !== void 0) {
+    transformed.sideA.sessionFail = sideASessionFail;
+  } else if (data.side_a_fail_session_tool) {
+    transformed.sideA.failSessionTool = data.side_a_fail_session_tool;
+  }
+  const sideASessionStatus = toSessionBinding(
+    data.side_a_session_status_tool ?? data.side_a_status_tool,
+    data.side_a_session_status_message_property,
+    data.side_a_session_status_attachments_property
+  );
+  if (sideASessionStatus !== void 0) {
+    transformed.sideA.sessionStatus = sideASessionStatus;
+  } else if (data.side_a_status_tool) {
+    transformed.sideA.statusTool = data.side_a_status_tool;
+  }
   if (data.side_a_manual_stop_condition !== void 0) {
     transformed.sideA.manualStopCondition = data.side_a_manual_stop_condition;
   }
@@ -1602,9 +2002,36 @@ function transformAgentData(data) {
     if (data.side_b_max_steps !== void 0) {
       transformed.sideB.maxSteps = data.side_b_max_steps;
     }
-    if (data.side_b_end_session_tool) {
+    const sideBSessionStop = toSessionBinding(
+      data.side_b_session_stop_tool ?? data.side_b_end_session_tool,
+      data.side_b_session_stop_message_property,
+      data.side_b_session_stop_attachments_property
+    );
+    if (sideBSessionStop !== void 0) {
+      transformed.sideB.sessionStop = sideBSessionStop;
+    } else if (data.side_b_end_session_tool) {
       transformed.sideB.endSessionTool = data.side_b_end_session_tool;
     }
+    const sideBSessionFail = toSessionBinding(
+      data.side_b_session_fail_tool ?? data.side_b_fail_session_tool,
+      data.side_b_session_fail_message_property,
+      data.side_b_session_fail_attachments_property
+    );
+    if (sideBSessionFail !== void 0) {
+      transformed.sideB.sessionFail = sideBSessionFail;
+    } else if (data.side_b_fail_session_tool) {
+      transformed.sideB.failSessionTool = data.side_b_fail_session_tool;
+    }
+    const sideBSessionStatus = toSessionBinding(
+      data.side_b_session_status_tool ?? data.side_b_status_tool,
+      data.side_b_session_status_message_property,
+      data.side_b_session_status_attachments_property
+    );
+    if (sideBSessionStatus !== void 0) {
+      transformed.sideB.sessionStatus = sideBSessionStatus;
+    } else if (data.side_b_status_tool) {
+      transformed.sideB.statusTool = data.side_b_status_tool;
+    }
     if (data.side_b_manual_stop_condition !== void 0) {
       transformed.sideB.manualStopCondition = data.side_b_manual_stop_condition;
     }
@@ -1615,6 +2042,9 @@ function transformAgentData(data) {
   if (data.tool_description) {
     transformed.toolDescription = data.tool_description;
   }
+  if (data.env !== void 0 || data.tenvs !== void 0) {
+    transformed.env = normalizeStringEnvRecord(data.env ?? data.tenvs) ?? {};
+  }
   return transformed;
 }
 function getAgentFilePath(agentsDir, name) {
@@ -1623,11 +2053,11 @@ function getAgentFilePath(agentsDir, name) {
 }
 function agentExists(agentsDir, name) {
   const filePath = getAgentFilePath(agentsDir, name);
-  return fs2__default.existsSync(filePath);
+  return fs4__default.existsSync(filePath);
 }
 function extractAgentMetadata(filePath) {
   try {
-    const content = fs2__default.readFileSync(filePath, "utf-8");
+    const content = fs4__default.readFileSync(filePath, "utf-8");
     const metadata = {};
     const packageNameMatch = content.match(/packageName:\s*['"]([^'"]+)['"]/);
     if (packageNameMatch) metadata.packageName = packageNameMatch[1];
@@ -1644,17 +2074,17 @@ function extractAgentMetadata(filePath) {
 }
 async function saveAgent(agentsDir, data, overwrite = false) {
   try {
-    if (!fs2__default.existsSync(agentsDir)) {
-      fs2__default.mkdirSync(agentsDir, { recursive: true });
+    if (!fs4__default.existsSync(agentsDir)) {
+      fs4__default.mkdirSync(agentsDir, { recursive: true });
     }
     const filePath = getAgentFilePath(agentsDir, data.name);
-    if (!overwrite && fs2__default.existsSync(filePath)) {
+    if (!overwrite && fs4__default.existsSync(filePath)) {
       return {
         success: false,
         error: `Agent file already exists: ${filePath}. Use update to modify existing agents.`
       };
     }
-    if (overwrite && fs2__default.existsSync(filePath)) {
+    if (overwrite && fs4__default.existsSync(filePath)) {
       const existingMetadata = extractAgentMetadata(filePath);
       if (existingMetadata.packageName && !data.packageName) {
         data.packageName = existingMetadata.packageName;
@@ -1670,7 +2100,7 @@ async function saveAgent(agentsDir, data, overwrite = false) {
       }
     }
     const content = generateAgentFile(data);
-    await fs2__default.promises.writeFile(filePath, content, "utf-8");
+    await fs4__default.promises.writeFile(filePath, content, "utf-8");
     return {
       success: true,
       filePath
@@ -1685,13 +2115,13 @@ async function saveAgent(agentsDir, data, overwrite = false) {
 async function deleteAgent(agentsDir, name) {
   try {
     const filePath = getAgentFilePath(agentsDir, name);
-    if (!fs2__default.existsSync(filePath)) {
+    if (!fs4__default.existsSync(filePath)) {
       return {
         success: false,
         error: `Agent file not found: ${filePath}`
       };
     }
-    await fs2__default.promises.unlink(filePath);
+    await fs4__default.promises.unlink(filePath);
     return {
       success: true,
       filePath
@@ -1707,25 +2137,25 @@ async function renameModel(modelsDir, oldName, newName) {
   try {
     const oldFilePath = getModelFilePath(modelsDir, oldName);
     const newFilePath = getModelFilePath(modelsDir, newName);
-    if (!fs2__default.existsSync(oldFilePath)) {
+    if (!fs4__default.existsSync(oldFilePath)) {
       return {
         success: false,
         error: `Model file not found: ${oldFilePath}`
       };
     }
-    if (fs2__default.existsSync(newFilePath)) {
+    if (fs4__default.existsSync(newFilePath)) {
       return {
         success: false,
         error: `Model file already exists: ${newFilePath}`
       };
     }
-    const content = await fs2__default.promises.readFile(oldFilePath, "utf-8");
+    const content = await fs4__default.promises.readFile(oldFilePath, "utf-8");
     const updatedContent = content.replace(
       /name:\s*['"]([^'"]+)['"]/,
       `name: '${newName}'`
     );
-    await fs2__default.promises.writeFile(newFilePath, updatedContent, "utf-8");
-    await fs2__default.promises.unlink(oldFilePath);
+    await fs4__default.promises.writeFile(newFilePath, updatedContent, "utf-8");
+    await fs4__default.promises.unlink(oldFilePath);
     return {
       success: true,
       filePath: newFilePath
@@ -1739,17 +2169,17 @@ async function renameModel(modelsDir, oldName, newName) {
 }
 async function updateModelReferencesInPrompts(promptsDir, oldModelName, newModelName) {
   const updatedFiles = [];
-  if (!fs2__default.existsSync(promptsDir)) {
+  if (!fs4__default.existsSync(promptsDir)) {
     return updatedFiles;
   }
-  const files = fs2__default.readdirSync(promptsDir).filter((f) => f.endsWith(".ts"));
+  const files = fs4__default.readdirSync(promptsDir).filter((f) => f.endsWith(".ts"));
   for (const file of files) {
     const filePath = path8__default.join(promptsDir, file);
-    let content = await fs2__default.promises.readFile(filePath, "utf-8");
+    let content = await fs4__default.promises.readFile(filePath, "utf-8");
     const modelRegex = new RegExp(`model:\\s*['"]${escapeRegExp(oldModelName)}['"]`, "g");
     if (modelRegex.test(content)) {
       content = content.replace(modelRegex, `model: '${newModelName}'`);
-      await fs2__default.promises.writeFile(filePath, content, "utf-8");
+      await fs4__default.promises.writeFile(filePath, content, "utf-8");
       updatedFiles.push(filePath);
     }
   }
@@ -1757,13 +2187,13 @@ async function updateModelReferencesInPrompts(promptsDir, oldModelName, newModel
 }
 async function updatePromptReferencesInPrompts(promptsDir, oldPromptName, newPromptName) {
   const updatedFiles = [];
-  if (!fs2__default.existsSync(promptsDir)) {
+  if (!fs4__default.existsSync(promptsDir)) {
     return updatedFiles;
   }
-  const files = fs2__default.readdirSync(promptsDir).filter((f) => f.endsWith(".ts"));
+  const files = fs4__default.readdirSync(promptsDir).filter((f) => f.endsWith(".ts"));
   for (const file of files) {
     const filePath = path8__default.join(promptsDir, file);
-    let content = await fs2__default.promises.readFile(filePath, "utf-8");
+    let content = await fs4__default.promises.readFile(filePath, "utf-8");
     let modified = false;
     const toolsArrayRegex = /tools:\s*\[([^\]]*)\]/gs;
     const newContent = content.replace(toolsArrayRegex, (match) => {
@@ -1776,7 +2206,7 @@ async function updatePromptReferencesInPrompts(promptsDir, oldPromptName, newPro
       return replaced;
     });
     if (modified) {
-      await fs2__default.promises.writeFile(filePath, newContent, "utf-8");
+      await fs4__default.promises.writeFile(filePath, newContent, "utf-8");
       updatedFiles.push(filePath);
     }
   }
@@ -1784,17 +2214,17 @@ async function updatePromptReferencesInPrompts(promptsDir, oldPromptName, newPro
 }
 async function updatePromptReferencesInAgents(agentsDir, oldPromptName, newPromptName) {
   const updatedFiles = [];
-  if (!fs2__default.existsSync(agentsDir)) {
+  if (!fs4__default.existsSync(agentsDir)) {
     return updatedFiles;
   }
-  const files = fs2__default.readdirSync(agentsDir).filter((f) => f.endsWith(".ts"));
+  const files = fs4__default.readdirSync(agentsDir).filter((f) => f.endsWith(".ts"));
   for (const file of files) {
     const filePath = path8__default.join(agentsDir, file);
-    let content = await fs2__default.promises.readFile(filePath, "utf-8");
+    let content = await fs4__default.promises.readFile(filePath, "utf-8");
     const promptRegex = new RegExp(`prompt:\\s*['"]${escapeRegExp(oldPromptName)}['"]`, "g");
     if (promptRegex.test(content)) {
       content = content.replace(promptRegex, `prompt: '${newPromptName}'`);
-      await fs2__default.promises.writeFile(filePath, content, "utf-8");
+      await fs4__default.promises.writeFile(filePath, content, "utf-8");
       updatedFiles.push(filePath);
     }
   }
@@ -1804,69 +2234,74 @@ function escapeRegExp(string) {
   return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function validateAgentData(data) {
+  const errors = {};
   if (!data.name || typeof data.name !== "string") {
-    return "Agent name is required and must be a string";
-  }
-  if (data.name.includes("/")) {
-    return "Agent name cannot contain '/'. Reserved for namespace qualification.";
+    errors["name"] = "Agent name is required";
+  } else if (data.name.includes("/")) {
+    errors["name"] = "Agent name cannot contain '/'";
   }
   if (data.title !== void 0 && typeof data.title !== "string") {
-    return "Agent title must be a string if provided";
+    errors["title"] = "Agent title must be a string";
   }
   if (data.type !== void 0) {
     const validTypes = ["ai_human", "dual_ai"];
     if (!validTypes.includes(data.type)) {
-      return `Invalid type '${data.type}'. Must be one of: ${validTypes.join(", ")}`;
+      errors["type"] = `Invalid type '${data.type}'. Must be one of: ${validTypes.join(", ")}`;
     }
   }
   if (!data.sideA || typeof data.sideA !== "object") {
-    return "sideA configuration is required";
-  }
-  if (!data.sideA.prompt || typeof data.sideA.prompt !== "string") {
-    return "sideA.prompt is required and must be a string";
-  }
-  if (data.sideA.label !== void 0 && typeof data.sideA.label !== "string") {
-    return "sideA.label must be a string";
-  }
-  if (data.sideA.stopOnResponse !== void 0 && typeof data.sideA.stopOnResponse !== "boolean") {
-    return "sideA.stopOnResponse must be a boolean";
-  }
-  if (data.sideA.stopTool !== void 0 && typeof data.sideA.stopTool !== "string") {
-    return "sideA.stopTool must be a string";
-  }
-  if (data.sideA.stopTool && !data.sideA.stopToolResponseProperty) {
-    return "sideA.stopToolResponseProperty is required when sideA.stopTool is set";
-  }
-  if (data.sideA.maxSteps !== void 0) {
-    if (typeof data.sideA.maxSteps !== "number" || data.sideA.maxSteps <= 0) {
-      return "sideA.maxSteps must be a positive number";
+    errors["side_a_agent_prompt"] = "Side A configuration is required";
+  } else {
+    if (!data.sideA.prompt || typeof data.sideA.prompt !== "string") {
+      errors["side_a_agent_prompt"] = "Side A prompt is required";
     }
-  }
-  if (data.type === "dual_ai") {
-    if (!data.sideB || typeof data.sideB !== "object") {
-      return "sideB configuration is required for dual_ai type";
+    if (data.sideA.label !== void 0 && typeof data.sideA.label !== "string") {
+      errors["side_a_label"] = "Side A label must be a string";
     }
-    if (!data.sideB.prompt || typeof data.sideB.prompt !== "string") {
-      return "sideB.prompt is required for dual_ai type";
+    if (data.sideA.stopTool && !data.sideA.stopToolResponseProperty) {
+      errors["side_a_stop_tool_response_property"] = "Response property is required when stop tool is set";
     }
-    if (data.sideB.stopTool && !data.sideB.stopToolResponseProperty) {
-      return "sideB.stopToolResponseProperty is required when sideB.stopTool is set";
+    if (data.sideA.maxSteps !== void 0) {
+      if (typeof data.sideA.maxSteps !== "number" || data.sideA.maxSteps <= 0) {
+        errors["side_a_max_steps"] = "Max steps must be a positive number";
+      }
     }
-    if (data.sideB.maxSteps !== void 0) {
-      if (typeof data.sideB.maxSteps !== "number" || data.sideB.maxSteps <= 0) {
-        return "sideB.maxSteps must be a positive number";
+  }
+  if (data.type === "dual_ai") {
+    if (!data.sideB || typeof data.sideB !== "object") {
+      errors["side_b_agent_prompt"] = "Side B configuration is required for dual_ai type";
+    } else {
+      if (!data.sideB.prompt || typeof data.sideB.prompt !== "string") {
+        errors["side_b_agent_prompt"] = "Side B prompt is required for dual_ai type";
+      }
+      if (data.sideB.stopTool && !data.sideB.stopToolResponseProperty) {
+        errors["side_b_stop_tool_response_property"] = "Response property is required when stop tool is set";
+      }
+      if (data.sideB.maxSteps !== void 0) {
+        if (typeof data.sideB.maxSteps !== "number" || data.sideB.maxSteps <= 0) {
+          errors["side_b_max_steps"] = "Max steps must be a positive number";
+        }
       }
     }
   }
   if (data.exposeAsTool && !data.toolDescription) {
-    return "toolDescription is required when exposeAsTool is true";
+    errors["tool_description"] = "Tool description is required when expose as tool is enabled";
   }
   if (data.maxSessionTurns !== void 0 && data.maxSessionTurns !== null) {
     if (typeof data.maxSessionTurns !== "number" || data.maxSessionTurns <= 0) {
-      return "maxSessionTurns must be a positive number";
+      errors["max_session_turns"] = "Max session turns must be a positive number";
     }
   }
-  return null;
+  if (data.env !== void 0) {
+    if (!data.env || typeof data.env !== "object" || Array.isArray(data.env)) {
+      errors["env"] = "env must be an object of string values";
+    } else if (Object.values(data.env).some(
+      (value) => value !== void 0 && value !== null && typeof value !== "string"
+    )) {
+      errors["env"] = "env values must be strings";
+    }
+  }
+  return Object.keys(errors).length > 0 ? errors : null;
 }
 var MetadataService = class {
   metadataDir;
@@ -1886,11 +2321,11 @@ var MetadataService = class {
    */
   async read(agentName) {
     const filePath = this.getMetadataPath(agentName);
-    if (!fs2.existsSync(filePath)) {
+    if (!fs4.existsSync(filePath)) {
       return null;
     }
     try {
-      const content = fs2.readFileSync(filePath, "utf-8");
+      const content = fs4.readFileSync(filePath, "utf-8");
       return JSON.parse(content);
     } catch {
       return null;
@@ -1903,11 +2338,11 @@ var MetadataService = class {
    * @param metadata - Metadata to write
    */
   async write(agentName, metadata) {
-    if (!fs2.existsSync(this.metadataDir)) {
-      fs2.mkdirSync(this.metadataDir, { recursive: true });
+    if (!fs4.existsSync(this.metadataDir)) {
+      fs4.mkdirSync(this.metadataDir, { recursive: true });
     }
     const filePath = this.getMetadataPath(agentName);
-    fs2.writeFileSync(filePath, JSON.stringify(metadata, null, 2));
+    fs4.writeFileSync(filePath, JSON.stringify(metadata, null, 2));
   }
   /**
    * Delete metadata for an agent.
@@ -1916,8 +2351,8 @@ var MetadataService = class {
    */
   async delete(agentName) {
     const filePath = this.getMetadataPath(agentName);
-    if (fs2.existsSync(filePath)) {
-      fs2.unlinkSync(filePath);
+    if (fs4.existsSync(filePath)) {
+      fs4.unlinkSync(filePath);
     }
   }
   /**
@@ -2372,7 +2807,7 @@ var PackingService = class {
   resolvePackageVersion(pkgName, rootDir) {
     const pkgJsonPath = path8.join(rootDir, "node_modules", pkgName, "package.json");
     try {
-      const pkgJson = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+      const pkgJson = JSON.parse(fs4.readFileSync(pkgJsonPath, "utf-8"));
       return `^${pkgJson.version}`;
     } catch {
       return "*";
@@ -2398,13 +2833,17 @@ var PackingService = class {
         tools: [],
         models: [],
         hooks: [],
-        agents: []
+        effects: [],
+        agents: [],
+        threadEndpoints: []
       },
       shared: {
         prompts: [],
         tools: [],
         models: [],
-        hooks: []
+        hooks: [],
+        effects: [],
+        threadEndpoints: []
       },
       warnings: [],
       errors: []
@@ -2420,7 +2859,7 @@ var PackingService = class {
       discoveredVia: "static",
       sharedWith: []
     });
-    const agentSource = fs2.readFileSync(agentFilePath, "utf-8");
+    const agentSource = fs4.readFileSync(agentFilePath, "utf-8");
     const agentPrompts = await extractAgentPrompts(agentSource);
     if (agentPrompts.sideA) {
       analysis.primaryPrompt = agentPrompts.sideA;
@@ -2429,6 +2868,8 @@ var PackingService = class {
     if (agentPrompts.sideB) {
       await this.analyzePrompt(agentPrompts.sideB, agentsDir, analysis, /* @__PURE__ */ new Set(), `agent:${agentName}`);
     }
+    await this.analyzeThreadEndpoints(agentsDir, analysis);
+    await this.analyzeEffects(agentsDir, analysis);
     await this.checkSharedItems(agentsDir, analysis);
     return analysis;
   }
@@ -2449,7 +2890,7 @@ var PackingService = class {
     const agentItem = analysis.constituents.agents.find((a) => a.name === analysis.agent);
     if (agentItem?.filePath) {
       try {
-        const agentSource = fs2.readFileSync(agentItem.filePath, "utf-8");
+        const agentSource = fs4.readFileSync(agentItem.filePath, "utf-8");
         agentDescription = await extractAgentDescription(agentSource) || void 0;
       } catch {
       }
@@ -2466,6 +2907,138 @@ var PackingService = class {
     );
     return { generatedReadme, agentDescription };
   }
+  /**
+   * Analyze thread endpoints from agents/api and include them as packed constituents.
+   *
+   * Thread endpoints are not directly referenced by agent/prompt definitions, so we
+   * include all endpoint modules discovered under agents/api.
+   */
+  async analyzeThreadEndpoints(agentsDir, analysis) {
+    const apiDir = path8.join(agentsDir, "api");
+    const endpoints = this.scanThreadEndpointFiles(apiDir);
+    for (const endpoint of endpoints) {
+      if (analysis.constituents.threadEndpoints.some((item) => item.name === endpoint.name)) {
+        continue;
+      }
+      analysis.constituents.threadEndpoints.push({
+        name: endpoint.name,
+        filePath: endpoint.filePath,
+        discoveredVia: "thread-endpoint",
+        sharedWith: []
+      });
+    }
+  }
+  /**
+   * Recursively scan agents/api for endpoint source files.
+   *
+   * Returns endpoint keys like:
+   * - `status.get`
+   * - `admin/users/[userId]/sync.post`
+   */
+  scanThreadEndpointFiles(apiDir, relativeDir = "") {
+    if (!fs4.existsSync(apiDir)) {
+      return [];
+    }
+    const endpoints = [];
+    const currentDir = relativeDir ? path8.join(apiDir, relativeDir) : apiDir;
+    if (!fs4.existsSync(currentDir)) {
+      return endpoints;
+    }
+    const entries = fs4.readdirSync(currentDir, { withFileTypes: true });
+    if (entries.length > 0 && typeof entries[0] === "string") {
+      return endpoints;
+    }
+    for (const entry of entries) {
+      const entryName = typeof entry === "string" ? entry : entry.name;
+      const isDirectory = typeof entry === "string" ? false : entry.isDirectory();
+      const isFile = typeof entry === "string" ? true : entry.isFile();
+      const entryRelative = relativeDir ? path8.posix.join(relativeDir.replace(/\\/g, "/"), entryName) : entryName;
+      const absolutePath = path8.join(apiDir, entryRelative);
+      if (isDirectory) {
+        endpoints.push(...this.scanThreadEndpointFiles(apiDir, entryRelative));
+        continue;
+      }
+      if (!isFile) {
+        continue;
+      }
+      if (!entryName.endsWith(".ts")) {
+        continue;
+      }
+      const endpointKey = entryRelative.replace(/\.ts$/, "").replace(/\\/g, "/");
+      endpoints.push({
+        name: endpointKey,
+        filePath: absolutePath
+      });
+    }
+    endpoints.sort((a, b) => a.name.localeCompare(b.name));
+    return endpoints;
+  }
+  /**
+   * Analyze effects from agents/effects and include them as packed constituents.
+   *
+   * Effects are referenced by string names at runtime via scheduleEffect(), so we
+   * include all effect modules discovered under agents/effects.
+   */
+  async analyzeEffects(agentsDir, analysis) {
+    const effectsDir = path8.join(agentsDir, "effects");
+    const effects = this.scanEffectFiles(effectsDir);
+    for (const effect of effects) {
+      if (analysis.constituents.effects.some((item) => item.name === effect.name)) {
+        continue;
+      }
+      analysis.constituents.effects.push({
+        name: effect.name,
+        filePath: effect.filePath,
+        discoveredVia: "effect",
+        sharedWith: []
+      });
+    }
+  }
+  /**
+   * Recursively scan agents/effects for effect source files.
+   *
+   * Returns effect keys like:
+   * - `send_email`
+   * - `notifications/digest`
+   */
+  scanEffectFiles(effectsDir, relativeDir = "") {
+    if (!fs4.existsSync(effectsDir)) {
+      return [];
+    }
+    const effects = [];
+    const currentDir = relativeDir ? path8.join(effectsDir, relativeDir) : effectsDir;
+    if (!fs4.existsSync(currentDir)) {
+      return effects;
+    }
+    const entries = fs4.readdirSync(currentDir, { withFileTypes: true });
+    if (entries.length > 0 && typeof entries[0] === "string") {
+      return effects;
+    }
+    for (const entry of entries) {
+      const entryName = typeof entry === "string" ? entry : entry.name;
+      const isDirectory = typeof entry === "string" ? false : entry.isDirectory();
+      const isFile = typeof entry === "string" ? true : entry.isFile();
+      const entryRelative = relativeDir ? path8.posix.join(relativeDir.replace(/\\/g, "/"), entryName) : entryName;
+      const absolutePath = path8.join(effectsDir, entryRelative);
+      if (isDirectory) {
+        effects.push(...this.scanEffectFiles(effectsDir, entryRelative));
+        continue;
+      }
+      if (!isFile || !entryName.endsWith(".ts")) {
+        continue;
+      }
+      if (entryName === "CLAUDE.md" || entryName === "AGENTS.md" || entryName.startsWith("_")) {
+        continue;
+      }
+      const effectKey = entryRelative.replace(/\.ts$/, "").replace(/\\/g, "/");
+      effects.push({
+        name: effectKey,
+        filePath: absolutePath
+      });
+    }
+    effects.sort((a, b) => a.name.localeCompare(b.name));
+    return effects;
+  }
   /**
    * Recursively analyze a prompt and its dependencies.
    */
@@ -2489,7 +3062,7 @@ var PackingService = class {
       return;
     }
     visited.add(`prompt:${promptName}`);
-    const promptSource = fs2.readFileSync(promptFilePath, "utf-8");
+    const promptSource = fs4.readFileSync(promptFilePath, "utf-8");
     const modelName = await extractPromptModel(promptSource);
     if (modelName) {
       await this.analyzeModel(modelName, agentsDir, analysis, visited, thisKey);
@@ -2543,7 +3116,7 @@ var PackingService = class {
       return;
     }
     visited.add(`tool:${toolName}`);
-    const toolSource = fs2.readFileSync(toolFilePath, "utf-8");
+    const toolSource = fs4.readFileSync(toolFilePath, "utf-8");
     const { uses } = await extractToolUses(toolSource);
     for (const usedItem of uses) {
       await this.analyzeTool(usedItem, agentsDir, analysis, visited, "uses", thisKey);
@@ -2572,7 +3145,7 @@ var PackingService = class {
       return;
     }
     visited.add(`agent:${agentName}`);
-    const agentSource = fs2.readFileSync(agentFilePath, "utf-8");
+    const agentSource = fs4.readFileSync(agentFilePath, "utf-8");
     const agentPrompts = await extractAgentPrompts(agentSource);
     if (agentPrompts.sideA) {
       await this.analyzePrompt(agentPrompts.sideA, agentsDir, analysis, visited, thisKey);
@@ -2604,7 +3177,7 @@ var PackingService = class {
       return;
     }
     visited.add(`model:${modelName}`);
-    const modelSource = fs2.readFileSync(modelFilePath, "utf-8");
+    const modelSource = fs4.readFileSync(modelFilePath, "utf-8");
     const fallbacks = await extractModelFallbacks(modelSource);
     for (const fallbackName of fallbacks) {
       await this.analyzeModel(fallbackName, agentsDir, analysis, visited, thisKey);
@@ -2615,8 +3188,8 @@ var PackingService = class {
    */
   async checkSharedItems(agentsDir, analysis) {
     const agentsPath = path8.join(agentsDir, "agents");
-    if (!fs2.existsSync(agentsPath)) return;
-    const agentFiles = fs2.readdirSync(agentsPath).filter((f) => f.endsWith(".ts"));
+    if (!fs4.existsSync(agentsPath)) return;
+    const agentFiles = fs4.readdirSync(agentsPath).filter((f) => f.endsWith(".ts"));
     for (const agentFile of agentFiles) {
       const otherAgentName = agentFile.replace(".ts", "");
       if (otherAgentName === analysis.agent) continue;
@@ -2656,7 +3229,7 @@ var PackingService = class {
     const visited = /* @__PURE__ */ new Set();
     const agentFilePath = await this.findFile(path8.join(agentsDir, "agents"), agentName);
     if (!agentFilePath) return result;
-    const agentSource = fs2.readFileSync(agentFilePath, "utf-8");
+    const agentSource = fs4.readFileSync(agentFilePath, "utf-8");
     const agentPrompts = await extractAgentPrompts(agentSource);
     const analyzePromptLight = async (promptName) => {
       if (visited.has(promptName)) return;
@@ -2664,7 +3237,7 @@ var PackingService = class {
       result.prompts.push(promptName);
       const promptFilePath = await this.findFile(path8.join(agentsDir, "prompts"), promptName);
       if (!promptFilePath) return;
-      const promptSource = fs2.readFileSync(promptFilePath, "utf-8");
+      const promptSource = fs4.readFileSync(promptFilePath, "utf-8");
       const modelName = await extractPromptModel(promptSource);
       if (modelName && !result.models.includes(modelName)) {
         result.models.push(modelName);
@@ -2689,6 +3262,8 @@ var PackingService = class {
    *
    * The packing format creates:
    * - dist/{type}/{name}.js - Individual bundled files per constituent
+   * - dist/effects/** - Packed effect modules
+   * - dist/thread-endpoints/** - Packed thread endpoint modules
    * - dist/index.js - Re-exports and lazy loaders
    * - dist/index.d.ts - TypeScript type definitions
    * - package.json - With standardagent field and dependencies
@@ -2736,11 +3311,13 @@ var PackingService = class {
       }
       result.warnings = analysis.warnings;
       const pkgOutputDir = path8.join(outputDir, packageId);
-      fs2.mkdirSync(path8.join(pkgOutputDir, "dist", "agents"), { recursive: true });
-      fs2.mkdirSync(path8.join(pkgOutputDir, "dist", "prompts"), { recursive: true });
-      fs2.mkdirSync(path8.join(pkgOutputDir, "dist", "tools"), { recursive: true });
-      fs2.mkdirSync(path8.join(pkgOutputDir, "dist", "models"), { recursive: true });
-      fs2.mkdirSync(path8.join(pkgOutputDir, "dist", "hooks"), { recursive: true });
+      fs4.mkdirSync(path8.join(pkgOutputDir, "dist", "agents"), { recursive: true });
+      fs4.mkdirSync(path8.join(pkgOutputDir, "dist", "prompts"), { recursive: true });
+      fs4.mkdirSync(path8.join(pkgOutputDir, "dist", "tools"), { recursive: true });
+      fs4.mkdirSync(path8.join(pkgOutputDir, "dist", "models"), { recursive: true });
+      fs4.mkdirSync(path8.join(pkgOutputDir, "dist", "hooks"), { recursive: true });
+      fs4.mkdirSync(path8.join(pkgOutputDir, "dist", "effects"), { recursive: true });
+      fs4.mkdirSync(path8.join(pkgOutputDir, "dist", "thread-endpoints"), { recursive: true });
       const seenItems = /* @__PURE__ */ new Set();
       const allItems = [];
       for (const a of analysis.constituents.agents) {
@@ -2778,6 +3355,20 @@ var PackingService = class {
           allItems.push({ ...h, type: "hook" });
         }
       }
+      for (const effect of analysis.constituents.effects) {
+        const key = `effect:${effect.name}`;
+        if (!seenItems.has(key)) {
+          seenItems.add(key);
+          allItems.push({ ...effect, type: "effect" });
+        }
+      }
+      for (const endpoint of analysis.constituents.threadEndpoints) {
+        const key = `thread-endpoint:${endpoint.name}`;
+        if (!seenItems.has(key)) {
+          seenItems.add(key);
+          allItems.push({ ...endpoint, type: "thread-endpoint" });
+        }
+      }
       const externalDeps = /* @__PURE__ */ new Map();
       for (const item of allItems) {
         const outputPath = path8.join(
@@ -2786,6 +3377,7 @@ var PackingService = class {
           this.getTypeDir(item.type),
           `${item.name}.js`
         );
+        fs4.mkdirSync(path8.dirname(outputPath), { recursive: true });
         const deps = await this.bundleFile(item.filePath, outputPath, rootDir);
         for (const [depName, depVersion] of deps) {
           if (!externalDeps.has(depName)) {
@@ -2796,28 +3388,30 @@ var PackingService = class {
       }
       const indexJs = this.generateReExportIndex(analysis, meta);
       const indexJsPath = path8.join(pkgOutputDir, "dist", "index.js");
-      fs2.writeFileSync(indexJsPath, indexJs);
+      fs4.writeFileSync(indexJsPath, indexJs);
       result.filesCreated.push(indexJsPath);
       const indexDts = this.generateIndexDts(analysis);
       const indexDtsPath = path8.join(pkgOutputDir, "dist", "index.d.ts");
-      fs2.writeFileSync(indexDtsPath, indexDts);
+      fs4.writeFileSync(indexDtsPath, indexDts);
       result.filesCreated.push(indexDtsPath);
       const pkgJson = this.generatePackageJson(
         finalPackageName,
         version,
         agentName,
+        this.deduplicateConstituents(analysis).effects.map((effect) => effect.name),
+        this.deduplicateConstituents(analysis).threadEndpoints.map((endpoint) => endpoint.name),
         externalDeps,
         rootDir,
         license,
         licenseOwner
       );
       const pkgJsonPath = path8.join(pkgOutputDir, "package.json");
-      fs2.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
+      fs4.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
       result.filesCreated.push(pkgJsonPath);
       if (license) {
         const licenseContent = this.generateLicenseFile(license, licenseOwner);
         const licensePath = path8.join(pkgOutputDir, "LICENSE");
-        fs2.writeFileSync(licensePath, licenseContent);
+        fs4.writeFileSync(licensePath, licenseContent);
         result.filesCreated.push(licensePath);
       }
       let readmeContent = readme;
@@ -2825,7 +3419,7 @@ var PackingService = class {
         const agentItem = analysis.constituents.agents.find((a) => a.name === agentName);
         let agentDescription;
         if (agentItem?.filePath) {
-          const agentSource = fs2.readFileSync(agentItem.filePath, "utf-8");
+          const agentSource = fs4.readFileSync(agentItem.filePath, "utf-8");
           agentDescription = await extractAgentDescription(agentSource) || void 0;
         }
         readmeContent = this.generateReadme(
@@ -2837,15 +3431,15 @@ var PackingService = class {
         );
       }
       const readmePath = path8.join(pkgOutputDir, "README.md");
-      fs2.writeFileSync(readmePath, readmeContent);
+      fs4.writeFileSync(readmePath, readmeContent);
       result.filesCreated.push(readmePath);
       if (removeOriginals || itemSelections) {
         result.filesRemoved = [];
         for (const item of allItems) {
           const selection = itemSelections?.find((s) => s.name === item.name && s.type === item.type);
-          const shouldRemove = selection ? selection.mode === "extract" : removeOriginals && item.sharedWith.length === 0;
-          if (shouldRemove && fs2.existsSync(item.filePath)) {
-            fs2.unlinkSync(item.filePath);
+          const shouldRemove = selection ? selection.mode === "extract" : removeOriginals && item.sharedWith.length === 0 && item.type !== "thread-endpoint" && item.type !== "effect";
+          if (shouldRemove && fs4.existsSync(item.filePath)) {
+            fs4.unlinkSync(item.filePath);
             result.filesRemoved.push(item.filePath);
           }
         }
@@ -2896,11 +3490,11 @@ var PackingService = class {
           const resolved = path8.resolve(path8.dirname(importer), source);
           let tsResolved = resolved;
           if (!resolved.endsWith(".ts") && !resolved.endsWith(".js")) {
-            if (fs2.existsSync(`${resolved}.ts`)) {
+            if (fs4.existsSync(`${resolved}.ts`)) {
               tsResolved = `${resolved}.ts`;
-            } else if (fs2.existsSync(`${resolved}.js`)) {
+            } else if (fs4.existsSync(`${resolved}.js`)) {
               tsResolved = `${resolved}.js`;
-            } else if (fs2.existsSync(`${resolved}/index.ts`)) {
+            } else if (fs4.existsSync(`${resolved}/index.ts`)) {
               tsResolved = `${resolved}/index.ts`;
             }
           }
@@ -2953,7 +3547,7 @@ var PackingService = class {
 // Local dependencies have been inlined
 
 `;
-      fs2.writeFileSync(outputPath, header + bundledCode);
+      fs4.writeFileSync(outputPath, header + bundledCode);
       await bundle.close();
     } catch (error) {
       await bundle.close();
@@ -2976,6 +3570,10 @@ var PackingService = class {
         return "models";
       case "hook":
         return "hooks";
+      case "effect":
+        return "effects";
+      case "thread-endpoint":
+        return "thread-endpoints";
     }
   }
   /**
@@ -2995,7 +3593,9 @@ var PackingService = class {
       prompts: dedupe(analysis.constituents.prompts),
       tools: dedupe(analysis.constituents.tools),
       models: dedupe(analysis.constituents.models),
-      hooks: dedupe(analysis.constituents.hooks)
+      hooks: dedupe(analysis.constituents.hooks),
+      effects: dedupe(analysis.constituents.effects),
+      threadEndpoints: dedupe(analysis.constituents.threadEndpoints)
     };
   }
   /**
@@ -3040,6 +3640,9 @@ var PackingService = class {
     for (const hook of constituents.hooks) {
       lines.push(`export { default as ${this.quoteName(hook.name)} } from './hooks/${hook.name}.js';`);
     }
+    for (const effect of constituents.effects) {
+      lines.push(`export { default as ${this.quoteName(effect.name)} } from './effects/${effect.name}.js';`);
+    }
     lines.push("");
     lines.push("// Registry exports for lazy loading");
     lines.push("export const agents = {");
@@ -3072,6 +3675,18 @@ var PackingService = class {
     }
     lines.push("};");
     lines.push("");
+    lines.push("export const effects = {");
+    for (const effect of constituents.effects) {
+      lines.push(`  ${this.quoteName(effect.name)}: async () => (await import('./effects/${effect.name}.js')).default,`);
+    }
+    lines.push("};");
+    lines.push("");
+    lines.push("export const threadEndpoints = {");
+    for (const endpoint of constituents.threadEndpoints) {
+      lines.push(`  ${this.quoteName(endpoint.name)}: async () => (await import('./thread-endpoints/${endpoint.name}.js')).default,`);
+    }
+    lines.push("};");
+    lines.push("");
     lines.push("export const __meta = " + JSON.stringify(meta, null, 2) + ";");
     lines.push("");
     return lines.join("\n");
@@ -3087,6 +3702,9 @@ var PackingService = class {
       "  PromptDefinition,",
       "  ToolDefinition,",
       "  ModelDefinition,",
+      "  EffectDefinition,",
+      "  Controller,",
+      "  MarkedThreadEndpoint,",
       "  PackedMeta,",
       "} from '@standardagents/spec';",
       "",
@@ -3118,6 +3736,11 @@ var PackingService = class {
         lines.push(`export declare const ${hook.name}: unknown;`);
       }
     }
+    for (const effect of constituents.effects) {
+      if (this.isValidIdentifier(effect.name)) {
+        lines.push(`export declare const ${effect.name}: EffectDefinition<any, any>;`);
+      }
+    }
     lines.push("");
     lines.push("export declare const agents: {");
     for (const agent of constituents.agents) {
@@ -3149,6 +3772,18 @@ var PackingService = class {
     }
     lines.push("};");
     lines.push("");
+    lines.push("export declare const effects: {");
+    for (const effect of constituents.effects) {
+      lines.push(`  readonly ${this.quoteName(effect.name)}: DefinitionLoader<EffectDefinition<any, any>>;`);
+    }
+    lines.push("};");
+    lines.push("");
+    lines.push("export declare const threadEndpoints: {");
+    for (const endpoint of constituents.threadEndpoints) {
+      lines.push(`  readonly ${this.quoteName(endpoint.name)}: DefinitionLoader<MarkedThreadEndpoint | Controller>;`);
+    }
+    lines.push("};");
+    lines.push("");
     lines.push("export declare const __meta: PackedMeta;");
     lines.push("");
     return lines.join("\n");
@@ -3156,7 +3791,7 @@ var PackingService = class {
   /**
    * Generate the package.json file with dependencies.
    */
-  generatePackageJson(packageName, version, agentName, externalDeps, rootDir, license, licenseOwner) {
+  generatePackageJson(packageName, version, agentName, effects, threadEndpoints, externalDeps, rootDir, license, licenseOwner) {
     const dependencies = {
       "@standardagents/spec": this.resolvePackageVersion("@standardagents/spec", rootDir)
     };
@@ -3177,7 +3812,9 @@ var PackingService = class {
       },
       keywords: ["standardagent"],
       standardagent: {
-        entryAgents: [agentName]
+        entryAgents: [agentName],
+        ...effects.length > 0 ? { effects } : {},
+        ...threadEndpoints.length > 0 ? { threadEndpoints } : {}
       },
       files: license ? ["dist", "LICENSE", "README.md"] : ["dist", "README.md"],
       dependencies
@@ -3337,11 +3974,11 @@ Copyright (c) ${year} ${copyrightHolder}
   getPackedInfo(packageId, rootDir) {
     const packedDir = path8.join(rootDir, "agents", "packed");
     let packageDir = path8.join(packedDir, packageId);
-    if (!fs2.existsSync(packageDir)) {
-      if (!fs2.existsSync(packedDir)) {
+    if (!fs4.existsSync(packageDir)) {
+      if (!fs4.existsSync(packedDir)) {
         return null;
       }
-      const dirs = fs2.readdirSync(packedDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+      const dirs = fs4.readdirSync(packedDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
       const matchingDir = dirs.find(
         (d) => d === packageId || d === `standardagent-${packageId}` || d === `standardagent-${packageId.replace(/_/g, "-")}`
       );
@@ -3351,14 +3988,14 @@ Copyright (c) ${year} ${copyrightHolder}
       packageDir = path8.join(packedDir, matchingDir);
     }
     const pkgJsonPath = path8.join(packageDir, "package.json");
-    if (!fs2.existsSync(pkgJsonPath)) {
+    if (!fs4.existsSync(pkgJsonPath)) {
       return null;
     }
-    const pkgJson = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+    const pkgJson = JSON.parse(fs4.readFileSync(pkgJsonPath, "utf-8"));
     let readme;
     const readmePath = path8.join(packageDir, "README.md");
-    if (fs2.existsSync(readmePath)) {
-      readme = fs2.readFileSync(readmePath, "utf-8");
+    if (fs4.existsSync(readmePath)) {
+      readme = fs4.readFileSync(readmePath, "utf-8");
     }
     return {
       packageName: pkgJson.name,
@@ -3377,10 +4014,10 @@ Copyright (c) ${year} ${copyrightHolder}
    */
   listPackedPackages(rootDir) {
     const packedDir = path8.join(rootDir, "agents", "packed");
-    if (!fs2.existsSync(packedDir)) {
+    if (!fs4.existsSync(packedDir)) {
       return [];
     }
-    return fs2.readdirSync(packedDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    return fs4.readdirSync(packedDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
   }
   /**
    * Generate README.md content for a packed agent.
@@ -3427,17 +4064,17 @@ ${license || "See LICENSE file"}
    * Find a file by name in a directory.
    */
   async findFile(dir, name) {
-    if (!fs2.existsSync(dir)) {
+    if (!fs4.existsSync(dir)) {
       return null;
     }
     const exactPath = path8.join(dir, `${name}.ts`);
-    if (fs2.existsSync(exactPath)) {
+    if (fs4.existsSync(exactPath)) {
       return exactPath;
     }
-    const files = fs2.readdirSync(dir).filter((f) => f.endsWith(".ts"));
+    const files = fs4.readdirSync(dir).filter((f) => f.endsWith(".ts"));
     for (const file of files) {
       const filePath = path8.join(dir, file);
-      const source = fs2.readFileSync(filePath, "utf-8");
+      const source = fs4.readFileSync(filePath, "utf-8");
       const extractedName = await extractDefinitionName(source);
       if (extractedName === name) {
         return filePath;
@@ -3450,14 +4087,14 @@ ${license || "See LICENSE file"}
    */
   async listAgents(rootDir) {
     const agentsDir = path8.join(rootDir, "agents", "agents");
-    if (!fs2.existsSync(agentsDir)) {
+    if (!fs4.existsSync(agentsDir)) {
       return [];
     }
-    const files = fs2.readdirSync(agentsDir).filter((f) => f.endsWith(".ts"));
+    const files = fs4.readdirSync(agentsDir).filter((f) => f.endsWith(".ts"));
     const agents = [];
     for (const file of files) {
       const filePath = path8.join(agentsDir, file);
-      const source = fs2.readFileSync(filePath, "utf-8");
+      const source = fs4.readFileSync(filePath, "utf-8");
       const name = await extractDefinitionName(source);
       if (name) {
         agents.push(name);
@@ -3507,7 +4144,7 @@ var PackageDiscoveryService = class {
   async discoverNpmPackages() {
     const packages = [];
     const nodeModulesDir = path8.join(this.config.rootDir, "node_modules");
-    if (!fs2.existsSync(nodeModulesDir)) {
+    if (!fs4.existsSync(nodeModulesDir)) {
       return packages;
     }
     const rootEntries = await this.scanDirectory(nodeModulesDir);
@@ -3543,11 +4180,11 @@ var PackageDiscoveryService = class {
    */
   async checkNpmPackage(pkgDir, pkgName) {
     const pkgJsonPath = path8.join(pkgDir, "package.json");
-    if (!fs2.existsSync(pkgJsonPath)) {
+    if (!fs4.existsSync(pkgJsonPath)) {
       return null;
     }
     try {
-      const pkgJson = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+      const pkgJson = JSON.parse(fs4.readFileSync(pkgJsonPath, "utf-8"));
       const isStandardAgent = (
         // Has "standardagent" keyword
         pkgJson.keywords?.includes("standardagent") || // Has "standardagent-*" prefix
@@ -3561,12 +4198,16 @@ var PackageDiscoveryService = class {
       if (!pkgJson.standardagent?.entryAgents) {
         return null;
       }
+      const effects = Array.isArray(pkgJson.standardagent.effects) && pkgJson.standardagent.effects.every((effectName) => typeof effectName === "string") ? pkgJson.standardagent.effects : void 0;
+      const threadEndpoints = Array.isArray(pkgJson.standardagent.threadEndpoints) && pkgJson.standardagent.threadEndpoints.every((endpoint) => typeof endpoint === "string") ? pkgJson.standardagent.threadEndpoints : void 0;
       return {
         packageId: pkgJson.name || pkgName,
         version: pkgJson.version || "0.0.0",
         source: "npm",
         path: pkgDir,
         entryAgents: pkgJson.standardagent.entryAgents,
+        ...effects ? { effects } : {},
+        ...threadEndpoints ? { threadEndpoints } : {},
         description: pkgJson.description
       };
     } catch (error) {
@@ -3580,21 +4221,21 @@ var PackageDiscoveryService = class {
    */
   async discoverLocalPackages() {
     const packages = [];
-    if (!fs2.existsSync(this.config.packedDir)) {
+    if (!fs4.existsSync(this.config.packedDir)) {
       return packages;
     }
     const entries = await this.scanDirectory(this.config.packedDir);
     for (const entry of entries) {
       if (entry.startsWith(".")) continue;
       const pkgDir = path8.join(this.config.packedDir, entry);
-      const stat = fs2.statSync(pkgDir);
+      const stat = fs4.statSync(pkgDir);
       if (!stat.isDirectory()) continue;
       if (entry.startsWith("@")) {
         const scopeEntries = await this.scanDirectory(pkgDir);
         for (const scopedPkg of scopeEntries) {
           if (scopedPkg.startsWith(".")) continue;
           const scopedPkgDir = path8.join(pkgDir, scopedPkg);
-          const scopedStat = fs2.statSync(scopedPkgDir);
+          const scopedStat = fs4.statSync(scopedPkgDir);
           if (!scopedStat.isDirectory()) continue;
           const fullName = `${entry}/${scopedPkg}`;
           const pkg = await this.checkLocalPackage(scopedPkgDir, fullName);
@@ -3618,20 +4259,24 @@ var PackageDiscoveryService = class {
    */
   async checkLocalPackage(pkgDir, dirName) {
     const pkgJsonPath = path8.join(pkgDir, "package.json");
-    if (!fs2.existsSync(pkgJsonPath)) {
+    if (!fs4.existsSync(pkgJsonPath)) {
       return null;
     }
     try {
-      const pkgJson = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+      const pkgJson = JSON.parse(fs4.readFileSync(pkgJsonPath, "utf-8"));
       if (!pkgJson.standardagent?.entryAgents) {
         return null;
       }
+      const effects = Array.isArray(pkgJson.standardagent.effects) && pkgJson.standardagent.effects.every((effectName) => typeof effectName === "string") ? pkgJson.standardagent.effects : void 0;
+      const threadEndpoints = Array.isArray(pkgJson.standardagent.threadEndpoints) && pkgJson.standardagent.threadEndpoints.every((endpoint) => typeof endpoint === "string") ? pkgJson.standardagent.threadEndpoints : void 0;
       return {
         packageId: pkgJson.name || dirName,
         version: pkgJson.version || "0.0.0",
         source: "local",
         path: pkgDir,
         entryAgents: pkgJson.standardagent.entryAgents,
+        ...effects ? { effects } : {},
+        ...threadEndpoints ? { threadEndpoints } : {},
         description: pkgJson.description
       };
     } catch (error) {
@@ -3643,10 +4288,10 @@ var PackageDiscoveryService = class {
    * Scan a directory and return entry names.
    */
   async scanDirectory(dir) {
-    if (!fs2.existsSync(dir)) {
+    if (!fs4.existsSync(dir)) {
       return [];
     }
-    const entries = fs2.readdirSync(dir);
+    const entries = fs4.readdirSync(dir);
     return entries;
   }
   /**
@@ -3657,7 +4302,10 @@ var PackageDiscoveryService = class {
       return false;
     }
     const f = field;
-    return Array.isArray(f.entryAgents) && f.entryAgents.length > 0 && f.entryAgents.every((e) => typeof e === "string");
+    const hasValidEntryAgents = Array.isArray(f.entryAgents) && f.entryAgents.length > 0 && f.entryAgents.every((e) => typeof e === "string");
+    const hasValidEffects = f.effects === void 0 || Array.isArray(f.effects) && f.effects.every((effectName) => typeof effectName === "string");
+    const hasValidThreadEndpoints = f.threadEndpoints === void 0 || Array.isArray(f.threadEndpoints) && f.threadEndpoints.every((endpoint) => typeof endpoint === "string");
+    return hasValidEntryAgents && hasValidEffects && hasValidThreadEndpoints;
   }
   /**
    * Get a package by ID.
@@ -3688,7 +4336,27 @@ var TYPE_TO_DIR = {
   prompt: "prompts",
   tool: "tools",
   model: "models",
-  hook: "hooks"
+  hook: "hooks",
+  effect: "effects",
+  "thread-endpoint": "thread-endpoints"
+};
+var TYPE_TO_TARGET_DIR = {
+  agent: "agents",
+  prompt: "prompts",
+  tool: "tools",
+  model: "models",
+  hook: "hooks",
+  effect: "effects",
+  "thread-endpoint": "api"
+};
+var TYPE_TO_REGISTRY_NAME = {
+  agent: "agents",
+  prompt: "prompts",
+  tool: "tools",
+  model: "models",
+  hook: "hooks",
+  effect: "effects",
+  "thread-endpoint": "threadEndpoints"
 };
 var UnpackingService = class {
   /**
@@ -3717,11 +4385,11 @@ var UnpackingService = class {
       analysis.version = pkg.version;
       analysis.source = pkg.source;
       const indexPath = path8.join(pkg.path, "dist", "index.js");
-      if (!fs2.existsSync(indexPath)) {
+      if (!fs4.existsSync(indexPath)) {
         analysis.errors.push(`Package index not found: ${indexPath}`);
         return analysis;
       }
-      const indexContent = fs2.readFileSync(indexPath, "utf-8");
+      const indexContent = fs4.readFileSync(indexPath, "utf-8");
       const registryItems = await this.parseIndexExports(indexContent);
       const availableItems = /* @__PURE__ */ new Map();
       for (const item of registryItems) {
@@ -3730,15 +4398,15 @@ var UnpackingService = class {
       const agentsDir = path8.join(rootDir, "agents");
       const itemsWithRelations = [];
       for (const item of registryItems) {
-        const targetPath = path8.join(agentsDir, TYPE_TO_DIR[item.type], `${item.name}.ts`);
+        const targetPath = path8.join(agentsDir, TYPE_TO_TARGET_DIR[item.type], `${item.name}.ts`);
         const sourcePath = path8.join(pkg.path, "dist", TYPE_TO_DIR[item.type], `${item.name}.js`);
         const existsGlobally = this.fileExists(targetPath);
-        const sourceExists = fs2.existsSync(sourcePath);
+        const sourceExists = fs4.existsSync(sourcePath);
         if (!sourceExists) {
           analysis.warnings.push(`Source file not found for ${item.type} "${item.name}": ${sourcePath}`);
           continue;
         }
-        const bundledCode = fs2.readFileSync(sourcePath, "utf-8");
+        const bundledCode = fs4.readFileSync(sourcePath, "utf-8");
         const children = await this.discoverRelationships(item.type, item.name, bundledCode, availableItems);
         itemsWithRelations.push({
           name: item.name,
@@ -3748,10 +4416,10 @@ var UnpackingService = class {
           action: existsGlobally ? "skip" : "generate"
         });
         for (const child of children) {
-          const childTargetPath = path8.join(agentsDir, TYPE_TO_DIR[child.type], `${child.name}.ts`);
+          const childTargetPath = path8.join(agentsDir, TYPE_TO_TARGET_DIR[child.type], `${child.name}.ts`);
           const childSourcePath = path8.join(pkg.path, "dist", TYPE_TO_DIR[child.type], `${child.name}.js`);
           const childExists = this.fileExists(childTargetPath);
-          const childSourceExists = fs2.existsSync(childSourcePath);
+          const childSourceExists = fs4.existsSync(childSourcePath);
           if (!childSourceExists) {
             continue;
           }
@@ -3855,7 +4523,7 @@ var UnpackingService = class {
       }
       const itemsToProcess = this.applySelections(analysis.items, itemSelections);
       const pkgJsonPath = path8.join(pkg.path, "package.json");
-      const pkgJson = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+      const pkgJson = JSON.parse(fs4.readFileSync(pkgJsonPath, "utf-8"));
       let author = "";
       if (typeof pkgJson.author === "string") {
         author = pkgJson.author;
@@ -3881,16 +4549,16 @@ var UnpackingService = class {
         }
         try {
           const sourcePath = path8.join(pkg.path, "dist", TYPE_TO_DIR[item.type], `${item.name}.js`);
-          const bundledCode = fs2.readFileSync(sourcePath, "utf-8");
+          const bundledCode = fs4.readFileSync(sourcePath, "utf-8");
           let tsCode = await transformBundledJs(bundledCode);
           if (item.type === "agent") {
             tsCode = await injectAgentMetadata(tsCode, agentMetadata);
           }
           const dir = path8.dirname(item.targetPath);
-          if (!fs2.existsSync(dir)) {
-            fs2.mkdirSync(dir, { recursive: true });
+          if (!fs4.existsSync(dir)) {
+            fs4.mkdirSync(dir, { recursive: true });
           }
-          fs2.writeFileSync(item.targetPath, tsCode);
+          fs4.writeFileSync(item.targetPath, tsCode);
           result.filesGenerated.push(item.targetPath);
         } catch (error) {
           result.warnings.push(
@@ -3935,7 +4603,7 @@ var UnpackingService = class {
       true
     );
     const items = [];
-    const registryTypes = ["agent", "prompt", "tool", "model", "hook"];
+    const registryTypes = ["agent", "prompt", "tool", "model", "hook", "effect", "thread-endpoint"];
     function visit(node) {
       if (ts.isVariableStatement(node) && node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)) {
         for (const decl of node.declarationList.declarations) {
@@ -3943,7 +4611,7 @@ var UnpackingService = class {
           const varName = decl.name.text;
           let itemType = null;
           for (const type of registryTypes) {
-            if (varName === TYPE_TO_DIR[type]) {
+            if (varName === TYPE_TO_REGISTRY_NAME[type]) {
               itemType = type;
               break;
             }
@@ -3981,9 +4649,9 @@ var UnpackingService = class {
     if (pkgIdentifier.startsWith("/") || pkgIdentifier.startsWith("./")) {
       const absolutePath = path8.isAbsolute(pkgIdentifier) ? pkgIdentifier : path8.join(rootDir, pkgIdentifier);
       const pkgJsonPath2 = path8.join(absolutePath, "package.json");
-      if (fs2.existsSync(pkgJsonPath2)) {
+      if (fs4.existsSync(pkgJsonPath2)) {
         try {
-          const pkgJson = JSON.parse(fs2.readFileSync(pkgJsonPath2, "utf-8"));
+          const pkgJson = JSON.parse(fs4.readFileSync(pkgJsonPath2, "utf-8"));
           if (pkgJson.standardagent?.entryAgents) {
             return {
               packageId: pkgJson.name || path8.basename(absolutePath),
@@ -4000,9 +4668,9 @@ var UnpackingService = class {
     }
     const packedDir = path8.join(rootDir, "agents", "packed", pkgIdentifier);
     const pkgJsonPath = path8.join(packedDir, "package.json");
-    if (fs2.existsSync(pkgJsonPath)) {
+    if (fs4.existsSync(pkgJsonPath)) {
       try {
-        const pkgJson = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+        const pkgJson = JSON.parse(fs4.readFileSync(pkgJsonPath, "utf-8"));
         if (pkgJson.standardagent?.entryAgents) {
           return {
             packageId: pkgJson.name || pkgIdentifier,
@@ -4043,18 +4711,18 @@ var UnpackingService = class {
    * Check if a file exists.
    */
   fileExists(filePath) {
-    if (fs2.existsSync(filePath)) {
+    if (fs4.existsSync(filePath)) {
       return true;
     }
     const withoutExt = filePath.replace(/\.(ts|js)$/, "");
-    return fs2.existsSync(`${withoutExt}.ts`) || fs2.existsSync(`${withoutExt}.js`);
+    return fs4.existsSync(`${withoutExt}.ts`) || fs4.existsSync(`${withoutExt}.js`);
   }
   /**
    * Recursively delete a directory.
    */
   deleteDirectory(dirPath) {
-    if (fs2.existsSync(dirPath)) {
-      fs2.rmSync(dirPath, { recursive: true, force: true });
+    if (fs4.existsSync(dirPath)) {
+      fs4.rmSync(dirPath, { recursive: true, force: true });
     }
   }
   /**
@@ -4131,7 +4799,7 @@ var NpmPublishService = class {
       };
     }
     const pkgJsonPath = path8.join(packageDir, "package.json");
-    if (!fs2.existsSync(pkgJsonPath)) {
+    if (!fs4.existsSync(pkgJsonPath)) {
       return {
         success: false,
         output: "",
@@ -4141,7 +4809,7 @@ var NpmPublishService = class {
     let packageName;
     let version;
     try {
-      const pkgJson = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+      const pkgJson = JSON.parse(fs4.readFileSync(pkgJsonPath, "utf-8"));
       packageName = pkgJson.name;
       version = pkgJson.version;
     } catch (e) {
@@ -4157,7 +4825,7 @@ var NpmPublishService = class {
 registry=${registry}
 `;
     try {
-      fs2.writeFileSync(npmrcPath, npmrcContent, { mode: 384 });
+      fs4.writeFileSync(npmrcPath, npmrcContent, { mode: 384 });
       const args = ["publish"];
       if (dryRun) {
         args.push("--dry-run");
@@ -4189,8 +4857,8 @@ registry=${registry}
       };
     } finally {
       try {
-        if (fs2.existsSync(npmrcPath)) {
-          fs2.unlinkSync(npmrcPath);
+        if (fs4.existsSync(npmrcPath)) {
+          fs4.unlinkSync(npmrcPath);
         }
       } catch {
       }
@@ -4257,11 +4925,11 @@ var VIRTUAL_BUILDER_ID = "virtual:@standardagents/builder";
 var RESOLVED_VIRTUAL_BUILDER_ID = "\0" + VIRTUAL_BUILDER_ID;
 function scanApiDirectory(dir, baseRoute = "") {
   const routes = [];
-  if (!fs2__default.existsSync(dir)) {
+  if (!fs4__default.existsSync(dir)) {
     return routes;
   }
   try {
-    const entries = fs2__default.readdirSync(dir, { withFileTypes: true });
+    const entries = fs4__default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = path8__default.join(dir, entry.name);
       if (entry.isDirectory()) {
@@ -4308,12 +4976,114 @@ function scanApiDirectory(dir, baseRoute = "") {
     return [];
   }
 }
+function parseThreadEndpointKey(endpointKey) {
+  const normalized = endpointKey.replace(/\\/g, "/");
+  const parts = normalized.split("/");
+  const rawFileName = parts.pop() || "index";
+  const convertedSegments = parts.filter(Boolean).map((segment) => segment.replace(/\[([^\]]+)\]/g, ":$1"));
+  let routePath = convertedSegments.length > 0 ? `/${convertedSegments.join("/")}` : "";
+  let method = "";
+  if (rawFileName.includes(".")) {
+    const fileParts = rawFileName.split(".");
+    const methodPart = fileParts[fileParts.length - 1].toUpperCase();
+    if (["GET", "POST", "PUT", "DELETE", "PATCH"].includes(methodPart)) {
+      method = methodPart;
+      const pathPart = fileParts.slice(0, -1).join(".");
+      if (pathPart !== "index") {
+        const convertedPath = pathPart.replace(/\[([^\]]+)\]/g, ":$1");
+        routePath += `/${convertedPath}`;
+      }
+    } else if (rawFileName !== "index") {
+      const convertedPath = rawFileName.replace(/\[([^\]]+)\]/g, ":$1");
+      routePath += `/${convertedPath}`;
+    }
+  } else if (rawFileName !== "index") {
+    const convertedPath = rawFileName.replace(/\[([^\]]+)\]/g, ":$1");
+    routePath += `/${convertedPath}`;
+  }
+  return {
+    method,
+    route: routePath || "/"
+  };
+}
+function discoverPackedPackageDirectories(packedDir) {
+  if (!fs4__default.existsSync(packedDir)) {
+    return [];
+  }
+  const packageDirs = [];
+  const entries = fs4__default.readdirSync(packedDir, { withFileTypes: true }).filter((entry) => entry.isDirectory());
+  for (const entry of entries) {
+    const fullPath = path8__default.join(packedDir, entry.name);
+    const packageJsonPath = path8__default.join(fullPath, "package.json");
+    if (fs4__default.existsSync(packageJsonPath)) {
+      packageDirs.push(fullPath);
+      continue;
+    }
+    if (!entry.name.startsWith("@")) {
+      continue;
+    }
+    const scopedEntries = fs4__default.readdirSync(fullPath, { withFileTypes: true }).filter((scopedEntry) => scopedEntry.isDirectory());
+    for (const scopedEntry of scopedEntries) {
+      const scopedPackagePath = path8__default.join(fullPath, scopedEntry.name);
+      const scopedPackageJson = path8__default.join(scopedPackagePath, "package.json");
+      if (fs4__default.existsSync(scopedPackageJson)) {
+        packageDirs.push(scopedPackagePath);
+      }
+    }
+  }
+  return packageDirs;
+}
+function scanPackedDistDirectory(packagePath, outputDir, subDir) {
+  const fullPath = path8__default.join(packagePath, outputDir, subDir);
+  if (!fs4__default.existsSync(fullPath)) {
+    return [];
+  }
+  return fs4__default.readdirSync(fullPath).filter((fileName) => fileName.endsWith(".js") || fileName.endsWith(".ts")).map((fileName) => ({
+    name: fileName.replace(/\.(js|ts)$/, ""),
+    path: path8__default.join(fullPath, fileName).replace(/\\/g, "/")
+  }));
+}
+function scanPackedThreadEndpoints(packagePath, outputDir) {
+  const rootDir = path8__default.join(packagePath, outputDir, "thread-endpoints");
+  if (!fs4__default.existsSync(rootDir)) {
+    return [];
+  }
+  const endpoints = [];
+  const scan = (dir, relativeDir = "") => {
+    const entries = fs4__default.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const nextRelative = relativeDir ? path8__default.posix.join(relativeDir, entry.name) : entry.name;
+      const absolutePath = path8__default.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        scan(absolutePath, nextRelative);
+        continue;
+      }
+      if (!entry.isFile()) {
+        continue;
+      }
+      if (!entry.name.endsWith(".js") && !entry.name.endsWith(".ts")) {
+        continue;
+      }
+      const key = nextRelative.replace(/\.(js|ts)$/, "").replace(/\\/g, "/");
+      const parsed = parseThreadEndpointKey(key);
+      endpoints.push({
+        name: key,
+        path: absolutePath.replace(/\\/g, "/"),
+        method: parsed.method,
+        route: parsed.route
+      });
+    }
+  };
+  scan(rootDir);
+  endpoints.sort((a, b) => a.name.localeCompare(b.name));
+  return endpoints;
+}
 function isSnakeCase(str) {
   return /^[a-z][a-z0-9_]*[a-z0-9]$/.test(str) || /^[a-z]$/.test(str);
 }
 function validateToolFile(filePath, fileName) {
   try {
-    const content = fs2__default.readFileSync(filePath, "utf-8");
+    const content = fs4__default.readFileSync(filePath, "utf-8");
     const hasDefaultExport = /export\s+default\s+defineTool/.test(content);
     if (!hasDefaultExport) {
       return `Tool file '${fileName}.ts' must have a default export using defineTool()`;
@@ -4325,10 +5095,10 @@ function validateToolFile(filePath, fileName) {
 }
 async function scanToolsDirectory(dir) {
   const tools = [];
-  if (!fs2__default.existsSync(dir)) {
+  if (!fs4__default.existsSync(dir)) {
     return tools;
   }
-  const entries = await fs2__default.promises.readdir(dir, { withFileTypes: true });
+  const entries = await fs4__default.promises.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isFile() && entry.name.endsWith(".ts")) {
       const fileName = entry.name.replace(".ts", "");
@@ -4360,10 +5130,10 @@ async function scanToolsDirectory(dir) {
 }
 async function scanHooksDirectory(dir) {
   const hooks = [];
-  if (!fs2__default.existsSync(dir)) {
+  if (!fs4__default.existsSync(dir)) {
     return hooks;
   }
-  const entries = await fs2__default.promises.readdir(dir, { withFileTypes: true });
+  const entries = await fs4__default.promises.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isFile() && entry.name.endsWith(".ts")) {
       const fileName = entry.name.replace(".ts", "");
@@ -4373,7 +5143,7 @@ async function scanHooksDirectory(dir) {
       const filePath = path8__default.join(dir, entry.name);
       const importPath = "./" + path8__default.relative(process.cwd(), filePath).replace(/\\/g, "/");
       try {
-        const content = fs2__default.readFileSync(filePath, "utf-8");
+        const content = fs4__default.readFileSync(filePath, "utf-8");
         const idMatch = content.match(/id:\s*['"]([^'"]+)['"]/);
         const hookMatch = content.match(/hook:\s*['"]([^'"]+)['"]/);
         if (idMatch && hookMatch) {
@@ -4396,16 +5166,16 @@ async function scanHooksDirectory(dir) {
 }
 async function scanConfigDirectory(dir, definePattern) {
   const items = [];
-  if (!fs2__default.existsSync(dir)) {
+  if (!fs4__default.existsSync(dir)) {
     return items;
   }
-  const entries = await fs2__default.promises.readdir(dir, { withFileTypes: true });
+  const entries = await fs4__default.promises.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isFile() && entry.name.endsWith(".ts")) {
       const filePath = path8__default.join(dir, entry.name);
       const importPath = "./" + path8__default.relative(process.cwd(), filePath).replace(/\\/g, "/");
       try {
-        const content = fs2__default.readFileSync(filePath, "utf-8");
+        const content = fs4__default.readFileSync(filePath, "utf-8");
         const hasDefaultExport = definePattern.test(content);
         if (!hasDefaultExport) {
           items.push({
@@ -4447,10 +5217,10 @@ async function scanAgentsDirectory(dir) {
 }
 async function scanEffectsDirectory(dir) {
   const effects = [];
-  if (!fs2__default.existsSync(dir)) {
+  if (!fs4__default.existsSync(dir)) {
     return effects;
   }
-  const entries = await fs2__default.promises.readdir(dir, { withFileTypes: true });
+  const entries = await fs4__default.promises.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isFile() && entry.name.endsWith(".ts")) {
       const fileName = entry.name.replace(".ts", "");
@@ -4460,7 +5230,7 @@ async function scanEffectsDirectory(dir) {
         continue;
       }
       try {
-        const content = fs2__default.readFileSync(filePath, "utf-8");
+        const content = fs4__default.readFileSync(filePath, "utf-8");
         if (!content.includes("defineEffect")) {
           continue;
         }
@@ -4522,7 +5292,7 @@ function agentbuilder(options = {}) {
   const rou3Path = path8__default.join(__dirname, "../dist/rou3.js");
   let rou3Code = "";
   try {
-    rou3Code = fs2__default.readFileSync(rou3Path, "utf-8").replace(/^export \{[^}]+\};?\s*$/gm, "").replace(/\/\/# sourceMappingURL=.+$/gm, "").trim();
+    rou3Code = fs4__default.readFileSync(rou3Path, "utf-8").replace(/^export \{[^}]+\};?\s*$/gm, "").replace(/\/\/# sourceMappingURL=.+$/gm, "").trim();
   } catch (err) {
     console.warn("[vite-plugin-agent] Could not read rou3.js for inlining:", err);
   }
@@ -4873,7 +5643,7 @@ function agentbuilder(options = {}) {
       );
       return {
         // Set publicDir to builder's client assets so Cloudflare plugin preserves assets config
-        publicDir: fs2__default.existsSync(builderClientDir) ? builderClientDir : void 0,
+        publicDir: fs4__default.existsSync(builderClientDir) ? builderClientDir : void 0,
         build: {
           rollupOptions: {
             // The packing system dynamically imports rollup, typescript, and related
@@ -5041,6 +5811,7 @@ ${toolsCode}
       }
       if (id === RESOLVED_VIRTUAL_ROUTES_ID) {
         const threadRoutes = scanApiDirectory(threadApiDir);
+        const toAbsolutePath = (inputPath) => path8__default.resolve(process.cwd(), inputPath).replace(/\\/g, "/");
         const threadRouteCode = threadRoutes.map(({ method, route, importPath }) => {
           const apiRoute = `/api/threads/:id${route}`;
           return `  addRoute(
@@ -5048,6 +5819,44 @@ ${toolsCode}
     "${method}",
     "${apiRoute}",
     /* v${routesVersion} */ async () => (await import("${importPath}")).default
+  );`;
+        }).join("\n");
+        const packedThreadRoutes = [];
+        const packedDir = path8__default.resolve(process.cwd(), "agents/packed");
+        const packedPackageDirs = discoverPackedPackageDirectories(packedDir);
+        for (const packagePath of packedPackageDirs) {
+          const packageJsonPath = path8__default.join(packagePath, "package.json");
+          if (!fs4__default.existsSync(packageJsonPath)) {
+            continue;
+          }
+          try {
+            const packageJson = JSON.parse(fs4__default.readFileSync(packageJsonPath, "utf-8"));
+            if (!packageJson.standardagent) {
+              continue;
+            }
+            const packageId = String(packageJson.name || path8__default.basename(packagePath));
+            const packageIdSegment = encodeURIComponent(packageId);
+            const mainEntry = packageJson.main || "./dist/index.js";
+            const outputDir2 = path8__default.dirname(mainEntry).replace(/^\.\//, "");
+            const threadEndpoints = scanPackedThreadEndpoints(packagePath, outputDir2);
+            for (const endpoint of threadEndpoints) {
+              const apiRoute = `/api/packages/${packageIdSegment}/threads/:id${endpoint.route}`;
+              packedThreadRoutes.push({
+                method: endpoint.method,
+                route: apiRoute,
+                importPath: endpoint.path
+              });
+            }
+          } catch (error) {
+            console.warn(`[vite-plugin-agent] Failed to parse packed package routes in ${packagePath}:`, error);
+          }
+        }
+        const packedThreadRouteCode = packedThreadRoutes.map(({ method, route, importPath }) => {
+          return `  addRoute(
+    router,
+    "${method}",
+    "${route}",
+    /* v${routesVersion} */ async () => (await import("${toAbsolutePath(importPath)}")).default
   );`;
         }).join("\n");
         return `// Inline rou3 router code (no external imports) /* v${routesVersion} */
@@ -5089,6 +5898,11 @@ function isPublicRoute(routePath) {
     return true;
   }
 
+  // Packed thread routes are also public
+  if (routePath.startsWith('/api/packages/') && routePath.includes('/threads/')) {
+    return true;
+  }
+
   // Provider icon routes are public (used by <img src>)
   if (routePath.startsWith('/api/providers/') && routePath.includes('/icon')) {
     return true;
@@ -5171,6 +5985,9 @@ export async function router(request, env) {
   // Register user thread API routes
 ${threadRouteCode}
 
+  // Register packed thread API routes
+${packedThreadRouteCode}
+
   const routeMatch = findRoute(
     router,
     request.method.toUpperCase(),
@@ -5458,6 +6275,7 @@ ${allProviders.map((p) => `  "${p.name}": async () => (await import("${p.package
         const models = await scanModelsDirectory(modelsDir);
         const prompts = await scanPromptsDirectory(promptsDir);
         const agents = await scanAgentsDirectory(agentsDir);
+        const effects = await scanEffectsDirectory(effectsDir);
         const toAbsolutePath = (relativePath) => {
           if (relativePath.startsWith("./")) {
             return path8__default.resolve(process.cwd(), relativePath).replace(/\\/g, "/");
@@ -5484,49 +6302,45 @@ ${allProviders.map((p) => `  "${p.name}": async () => (await import("${p.package
           const absPath = toAbsolutePath(importPath);
           return `    "${id2}": async () => (await import("${absPath}")).default,`;
         }).join("\n");
+        const globalEffectsCode = effects.filter((e) => !e.error).map(({ name, importPath }) => {
+          const absPath = toAbsolutePath(importPath);
+          return `    "${name}": async () => (await import("${absPath}")).default,`;
+        }).join("\n");
         const packedDir = path8__default.resolve(process.cwd(), "agents/packed");
         const packedPackages = [];
-        if (fs2__default.existsSync(packedDir)) {
+        if (fs4__default.existsSync(packedDir)) {
           console.log(`[vite-plugin-agent] Scanning packed directory: ${packedDir}`);
-          const pkgDirs = fs2__default.readdirSync(packedDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
-          console.log(`[vite-plugin-agent] Found package dirs: ${pkgDirs.join(", ")}`);
-          for (const pkgDirName of pkgDirs) {
-            const pkgPath = path8__default.join(packedDir, pkgDirName);
+          const packageDirs = discoverPackedPackageDirectories(packedDir);
+          console.log(`[vite-plugin-agent] Found package dirs: ${packageDirs.join(", ")}`);
+          for (const pkgPath of packageDirs) {
             const pkgJsonPath = path8__default.join(pkgPath, "package.json");
-            if (fs2__default.existsSync(pkgJsonPath)) {
+            if (fs4__default.existsSync(pkgJsonPath)) {
               try {
-                const pkgJson = JSON.parse(fs2__default.readFileSync(pkgJsonPath, "utf-8"));
-                console.log(`[vite-plugin-agent] Loaded ${pkgDirName} package.json, standardagent:`, pkgJson.standardagent);
+                const pkgJson = JSON.parse(fs4__default.readFileSync(pkgJsonPath, "utf-8"));
+                console.log(`[vite-plugin-agent] Loaded ${pkgPath} package.json, standardagent:`, pkgJson.standardagent);
                 if (!pkgJson.standardagent) {
                   continue;
                 }
                 const mainEntry = pkgJson.main || "./dist/index.js";
                 const outputDir2 = path8__default.dirname(mainEntry).replace(/^\.\//, "");
-                const scanPackedDir = async (subDir) => {
-                  const fullPath = path8__default.join(pkgPath, outputDir2, subDir);
-                  if (!fs2__default.existsSync(fullPath)) return [];
-                  const files = fs2__default.readdirSync(fullPath).filter((f) => f.endsWith(".js") || f.endsWith(".ts")).map((f) => ({
-                    name: f.replace(/\.(js|ts)$/, ""),
-                    path: path8__default.join(fullPath, f).replace(/\\/g, "/")
-                  }));
-                  return files;
-                };
                 const pkg = {
                   packageId: pkgJson.name,
                   version: pkgJson.version,
                   entryAgents: pkgJson.standardagent.entryAgents || [],
                   items: {
-                    agents: await scanPackedDir("agents"),
-                    prompts: await scanPackedDir("prompts"),
-                    tools: await scanPackedDir("tools"),
-                    models: await scanPackedDir("models"),
-                    hooks: await scanPackedDir("hooks")
+                    agents: scanPackedDistDirectory(pkgPath, outputDir2, "agents"),
+                    prompts: scanPackedDistDirectory(pkgPath, outputDir2, "prompts"),
+                    tools: scanPackedDistDirectory(pkgPath, outputDir2, "tools"),
+                    models: scanPackedDistDirectory(pkgPath, outputDir2, "models"),
+                    hooks: scanPackedDistDirectory(pkgPath, outputDir2, "hooks"),
+                    effects: scanPackedDistDirectory(pkgPath, outputDir2, "effects"),
+                    threadEndpoints: scanPackedThreadEndpoints(pkgPath, outputDir2)
                   }
                 };
                 console.log(`[vite-plugin-agent] Scanned package ${pkgJson.name}:`, pkg.items.agents);
                 packedPackages.push(pkg);
               } catch (err) {
-                console.warn(`[vite-plugin-agent] Failed to load packed package ${pkgDirName}:`, err);
+                console.warn(`[vite-plugin-agent] Failed to load packed package ${pkgPath}:`, err);
               }
             }
           }
@@ -5547,6 +6361,12 @@ ${allProviders.map((p) => `  "${p.name}": async () => (await import("${p.package
         return { ...mod.default, __package: ${signature} };
       },`
           ).join("\n");
+          const genThreadEndpointLoaders = (items) => items.map(
+            (item) => `      "${item.name}": async () => (await import("${item.path}")).default,`
+          ).join("\n");
+          const genEffectLoaders = (items) => items.map(
+            (item) => `      "${item.name}": async () => (await import("${item.path}")).default,`
+          ).join("\n");
           return `  "${pkg.packageId}": {
     agents: {
 ${genLoaders(pkg.items.agents)}
@@ -5562,6 +6382,12 @@ ${genLoaders(pkg.items.models)}
     },
     hooks: {
 ${genLoaders(pkg.items.hooks)}
+    },
+    effects: {
+${genEffectLoaders(pkg.items.effects)}
+    },
+    threadEndpoints: {
+${genThreadEndpointLoaders(pkg.items.threadEndpoints)}
     },
     entryAgents: ${JSON.stringify(pkg.entryAgents)},
     signature: ${signature},
@@ -5587,6 +6413,10 @@ ${globalModelsCode}
     hooks: {
 ${globalHooksCode}
     },
+    effects: {
+${globalEffectsCode}
+    },
+    threadEndpoints: {},
   },
   packages: {
 ${packagesCode}
@@ -5865,11 +6695,11 @@ export class DurableAgentBuilder extends _BaseDurableAgentBuilder {
           try {
             const rawBody = await parseRequestBody(req);
             const body = transformModelData(rawBody);
-            const validationError = validateModelData(body);
-            if (validationError) {
+            const fieldErrors = validateModelData(body);
+            if (fieldErrors) {
               res.statusCode = 400;
               res.setHeader("Content-Type", "application/json");
-              res.end(JSON.stringify({ error: validationError }));
+              res.end(JSON.stringify({ error: "Validation failed", fieldErrors }));
               return;
             }
             if (modelExists(modelsDir, body.name)) {
@@ -5910,11 +6740,11 @@ export class DurableAgentBuilder extends _BaseDurableAgentBuilder {
             const body = transformModelData(rawBody);
             const newName = body.name;
             const isNameChange = newName && newName !== urlModelName;
-            const validationError = validateModelData(body);
-            if (validationError) {
+            const fieldErrors = validateModelData(body);
+            if (fieldErrors) {
               res.statusCode = 400;
               res.setHeader("Content-Type", "application/json");
-              res.end(JSON.stringify({ error: validationError }));
+              res.end(JSON.stringify({ error: "Validation failed", fieldErrors }));
               return;
             }
             let updatedPrompts = [];
@@ -5989,11 +6819,11 @@ export class DurableAgentBuilder extends _BaseDurableAgentBuilder {
           try {
             const rawBody = await parseRequestBody(req);
             const body = transformPromptData(rawBody);
-            const validationError = validatePromptData(body);
-            if (validationError) {
+            const fieldErrors = validatePromptData(body);
+            if (fieldErrors) {
               res.statusCode = 400;
               res.setHeader("Content-Type", "application/json");
-              res.end(JSON.stringify({ error: validationError }));
+              res.end(JSON.stringify({ error: "Validation failed", fieldErrors }));
               return;
             }
             if (promptExists(promptsDir, body.name)) {
@@ -6034,11 +6864,11 @@ export class DurableAgentBuilder extends _BaseDurableAgentBuilder {
             const body = transformPromptData(rawBody);
             const newName = body.name;
             const isNameChange = newName && newName !== urlPromptName;
-            const validationError = validatePromptData(body);
-            if (validationError) {
+            const fieldErrors = validatePromptData(body);
+            if (fieldErrors) {
               res.statusCode = 400;
               res.setHeader("Content-Type", "application/json");
-              res.end(JSON.stringify({ error: validationError }));
+              res.end(JSON.stringify({ error: "Validation failed", fieldErrors }));
               return;
             }
             let updatedPrompts = [];
@@ -6114,11 +6944,11 @@ export class DurableAgentBuilder extends _BaseDurableAgentBuilder {
           try {
             const rawBody = await parseRequestBody(req);
             const body = transformAgentData(rawBody);
-            const validationError = validateAgentData(body);
-            if (validationError) {
+            const fieldErrors = validateAgentData(body);
+            if (fieldErrors) {
               res.statusCode = 400;
               res.setHeader("Content-Type", "application/json");
-              res.end(JSON.stringify({ error: validationError }));
+              res.end(JSON.stringify({ error: "Validation failed", fieldErrors }));
               return;
             }
             if (agentExists(agentsDir, body.name)) {
@@ -6158,11 +6988,11 @@ export class DurableAgentBuilder extends _BaseDurableAgentBuilder {
             const rawBody = await parseRequestBody(req);
             const body = transformAgentData(rawBody);
             body.name = agentName;
-            const validationError = validateAgentData(body);
-            if (validationError) {
+            const fieldErrors = validateAgentData(body);
+            if (fieldErrors) {
               res.statusCode = 400;
               res.setHeader("Content-Type", "application/json");
-              res.end(JSON.stringify({ error: validationError }));
+              res.end(JSON.stringify({ error: "Validation failed", fieldErrors }));
               return;
             }
             const result = await saveAgent(agentsDir, body, true);
@@ -6404,14 +7234,14 @@ export class DurableAgentBuilder extends _BaseDurableAgentBuilder {
             const rootDir = process.cwd();
             const packedDir = path8__default.join(rootDir, "agents", "packed");
             let packageDir = path8__default.join(packedDir, packageId);
-            if (!fs2__default.existsSync(packageDir)) {
-              if (!fs2__default.existsSync(packedDir)) {
+            if (!fs4__default.existsSync(packageDir)) {
+              if (!fs4__default.existsSync(packedDir)) {
                 res.statusCode = 400;
                 res.setHeader("Content-Type", "application/json");
                 res.end(JSON.stringify({ error: "No packed packages found. Pack the agent first." }));
                 return;
               }
-              const dirs = fs2__default.readdirSync(packedDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+              const dirs = fs4__default.readdirSync(packedDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
               const matchingDir = dirs.find(
                 (d) => d === packageId || d === `standardagent-${packageId}` || d === `standardagent-${packageId.replace(/_/g, "-")}`
               );
@@ -6429,8 +7259,8 @@ export class DurableAgentBuilder extends _BaseDurableAgentBuilder {
             let tokenSource = body.token ? "provided" : "environment";
             if (!token) {
               const devVarsPath = path8__default.join(rootDir, ".dev.vars");
-              if (fs2__default.existsSync(devVarsPath)) {
-                const devVars = fs2__default.readFileSync(devVarsPath, "utf-8");
+              if (fs4__default.existsSync(devVarsPath)) {
+                const devVars = fs4__default.readFileSync(devVarsPath, "utf-8");
                 const match = devVars.match(/^NPM_TOKEN=(.+)$/m);
                 if (match) {
                   token = match[1].trim();
@@ -6582,11 +7412,11 @@ export class DurableAgentBuilder extends _BaseDurableAgentBuilder {
             filePath = path8__default.join(clientDir, "index.html");
           }
           try {
-            if (fs2__default.existsSync(filePath)) {
-              let content = fs2__default.readFileSync(filePath);
+            if (fs4__default.existsSync(filePath)) {
+              let content = fs4__default.readFileSync(filePath);
               const ext = path8__default.extname(filePath).toLowerCase();
               if (ext === ".html") {
-                const configScript = `<script>window.__AGENTBUILDER_CONFIG__ = { mountPoint: "${mountPoint}" };</script>`;
+                const configScript = `<script>window.__AGENTBUILDER_CONFIG__ = { mountPoint: "${mountPoint}", devMode: true };</script>`;
                 let htmlContent = content.toString();
                 const assetPrefix = mountPoint === "/" ? "/" : `${mountPoint}/`;
                 htmlContent = htmlContent.replace(/\/agents\//g, assetPrefix);
@@ -6629,21 +7459,21 @@ export class DurableAgentBuilder extends _BaseDurableAgentBuilder {
         currentDir,
         isInDist ? "./client" : "../dist/client"
       );
-      if (!fs2__default.existsSync(clientDir)) {
+      if (!fs4__default.existsSync(clientDir)) {
         console.warn(`[agentbuilder] Client directory not found at ${clientDir}`);
         return;
       }
-      fs2__default.mkdirSync(mountDir, { recursive: true });
+      fs4__default.mkdirSync(mountDir, { recursive: true });
       function copyRecursive(src, dest) {
-        const entries = fs2__default.readdirSync(src, { withFileTypes: true });
+        const entries = fs4__default.readdirSync(src, { withFileTypes: true });
         for (const entry of entries) {
           const srcPath = path8__default.join(src, entry.name);
           const destPath = path8__default.join(dest, entry.name);
           if (entry.isDirectory()) {
-            fs2__default.mkdirSync(destPath, { recursive: true });
+            fs4__default.mkdirSync(destPath, { recursive: true });
             copyRecursive(srcPath, destPath);
           } else {
-            let content = fs2__default.readFileSync(srcPath);
+            let content = fs4__default.readFileSync(srcPath);
             if (entry.name === "index.html") {
               const configScript = `<script>window.__AGENTBUILDER_CONFIG__ = { mountPoint: "${mountPoint}" };</script>`;
               let htmlContent = content.toString();
@@ -6652,7 +7482,7 @@ export class DurableAgentBuilder extends _BaseDurableAgentBuilder {
               htmlContent = htmlContent.replace("</head>", `${configScript}</head>`);
               content = Buffer.from(htmlContent);
             }
-            fs2__default.writeFileSync(destPath, content);
+            fs4__default.writeFileSync(destPath, content);
           }
         }
       }