@hasna/testers 0.0.34 → 0.0.36

package/dist/mcp/index.js

@@ -52,7 +52,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/testers",
-    version: "0.0.33",
+    version: "0.0.36",
     description: "AI-powered QA testing CLI \u2014 spawns cheap AI agents to test web apps with headless browsers",
     type: "module",
     main: "dist/index.js",
@@ -76,10 +76,10 @@ var init_package = __esm(() => {
     ],
     scripts: {
       build: "bun run build:dashboard && bun run build:cli && bun run build:mcp && bun run build:server && bun run build:lib && bun run build:types",
-      "build:cli": "bun build src/cli/index.tsx --outdir dist/cli --target bun --external ink --external react --external chalk --external @modelcontextprotocol/sdk --external @anthropic-ai/sdk --external playwright --external @hasna/browser",
-      "build:mcp": "bun build src/mcp/index.ts --outdir dist/mcp --target bun --external @modelcontextprotocol/sdk --external @anthropic-ai/sdk --external playwright --external @hasna/browser",
-      "build:server": "bun build src/server/index.ts --outdir dist/server --target bun --external @anthropic-ai/sdk --external playwright --external @hasna/browser",
-      "build:lib": "bun build src/index.ts --outdir dist --target bun --external playwright --external @anthropic-ai/sdk --external @modelcontextprotocol/sdk --external @hasna/browser",
+      "build:cli": "bun build src/cli/index.tsx --outdir dist/cli --target bun --external ink --external react --external chalk --external @modelcontextprotocol/sdk --external @anthropic-ai/sdk --external playwright --external @hasna/browser --external @hasna/sandboxes",
+      "build:mcp": "bun build src/mcp/index.ts --outdir dist/mcp --target bun --external @modelcontextprotocol/sdk --external @anthropic-ai/sdk --external playwright --external @hasna/browser --external @hasna/sandboxes",
+      "build:server": "bun build src/server/index.ts --outdir dist/server --target bun --external @anthropic-ai/sdk --external playwright --external @hasna/browser --external @hasna/sandboxes",
+      "build:lib": "bun build src/index.ts --outdir dist --target bun --external playwright --external @anthropic-ai/sdk --external @modelcontextprotocol/sdk --external @hasna/browser --external @hasna/sandboxes",
       "build:types": "NODE_OPTIONS='--max-old-space-size=8192' tsc --emitDeclarationOnly --outDir dist --skipLibCheck || true",
       "build:dashboard": "cd dashboard && bun run build",
       "build:ext": "cd extension && bun run build",
@@ -93,10 +93,11 @@ var init_package = __esm(() => {
     },
     dependencies: {
       "@anthropic-ai/sdk": "^0.52.0",
-      "@hasna/browser": "^0.4.5",
+      "@hasna/browser": "^0.4.12",
       "@hasna/cloud": "^0.1.24",
       "@hasna/contacts": "^0.6.8",
       "@hasna/projects": "^0.1.42",
+      "@hasna/sandboxes": "^0.1.27",
       "@modelcontextprotocol/sdk": "^1.12.1",
       ai: "^6.0.175",
       chalk: "^5.4.1",
@@ -5399,9 +5400,9 @@ async function syncTransfer(source, target, options, _direction) {
           const batch = rows.slice(offset, offset + batchSize);
           try {
             if (isAsyncAdapter(target)) {
-              await batchUpsertPg(target, table, columns, updateCols, pkColumns, batch, columns.includes(conflictColumn) ? conflictColumn : undefined);
+              await batchUpsertPg(target, table, columns, updateCols, pkColumns, batch);
             } else {
-              batchUpsertSqlite(target, table, columns, updateCols, pkColumns, batch, columns.includes(conflictColumn) ? conflictColumn : undefined);
+              batchUpsertSqlite(target, table, columns, updateCols, pkColumns, batch);
             }
             result.rowsWritten += batch.length;
           } catch (err) {
@@ -5448,7 +5449,7 @@ async function syncTransfer(source, target, options, _direction) {
   }
   return results;
 }
-async function batchUpsertPg(target, table, columns, updateCols, primaryKeys, batch, conflictColumn) {
+async function batchUpsertPg(target, table, columns, updateCols, primaryKeys, batch) {
   if (batch.length === 0)
     return;
   const colList = columns.map((c) => `"${c}"`).join(", ");
@@ -5458,22 +5459,20 @@ async function batchUpsertPg(target, table, columns, updateCols, primaryKeys, ba
   }).join(", ");
   const pkList = primaryKeys.map((c) => `"${c}"`).join(", ");
   const setClause = updateCols.length > 0 ? updateCols.map((c) => `"${c}" = EXCLUDED."${c}"`).join(", ") : `"${primaryKeys[0]}" = EXCLUDED."${primaryKeys[0]}"`;
-  const whereClause = conflictColumn && updateCols.includes(conflictColumn) ? ` WHERE "${table}"."${conflictColumn}" IS NULL OR EXCLUDED."${conflictColumn}" >= "${table}"."${conflictColumn}"` : "";
   const sql = `INSERT INTO "${table}" (${colList}) VALUES ${valuePlaceholders}
-    ON CONFLICT (${pkList}) DO UPDATE SET ${setClause}${whereClause}`;
+    ON CONFLICT (${pkList}) DO UPDATE SET ${setClause}`;
   const params = batch.flatMap((row) => columns.map((c) => row[c] ?? null));
   await target.run(sql, ...params);
 }
-function batchUpsertSqlite(target, table, columns, updateCols, primaryKeys, batch, conflictColumn) {
+function batchUpsertSqlite(target, table, columns, updateCols, primaryKeys, batch) {
   if (batch.length === 0)
     return;
   const colList = columns.map((c) => `"${c}"`).join(", ");
   const valuePlaceholders = batch.map(() => `(${columns.map(() => "?").join(", ")})`).join(", ");
   const pkList = primaryKeys.map((c) => `"${c}"`).join(", ");
   const setClause = updateCols.length > 0 ? updateCols.map((c) => `"${c}" = EXCLUDED."${c}"`).join(", ") : `"${primaryKeys[0]}" = EXCLUDED."${primaryKeys[0]}"`;
-  const whereClause = conflictColumn && updateCols.includes(conflictColumn) ? ` WHERE "${table}"."${conflictColumn}" IS NULL OR EXCLUDED."${conflictColumn}" >= "${table}"."${conflictColumn}"` : "";
   const sql = `INSERT INTO "${table}" (${colList}) VALUES ${valuePlaceholders}
-    ON CONFLICT (${pkList}) DO UPDATE SET ${setClause}${whereClause}`;
+    ON CONFLICT (${pkList}) DO UPDATE SET ${setClause}`;
   const params = batch.flatMap((row) => columns.map((c) => coerceForSqlite(row[c])));
   target.run(sql, ...params);
 }
@@ -5698,7 +5697,7 @@ class SyncProgressTracker {
     }
   }
 }
-function registerCloudTools(server, serviceName, opts = {}) {
+function registerCloudTools(server, serviceName) {
   server.tool(`${serviceName}_cloud_status`, "Show cloud configuration and connection health", {}, async () => {
     const config = getCloudConfig();
     const lines = [
@@ -5731,13 +5730,8 @@ function registerCloudTools(server, serviceName, opts = {}) {
         isError: true
       };
     }
-    const local = new SqliteAdapter(opts.dbPath ?? getDbPath(serviceName));
+    const local = new SqliteAdapter(getDbPath(serviceName));
     const cloud = new PgAdapterAsync(getConnectionString(serviceName));
-    if (opts.migrations?.length) {
-      for (const sql of opts.migrations) {
-        await cloud.run(sql);
-      }
-    }
     const tableList = tablesStr ? tablesStr.split(",").map((t) => t.trim()) : listSqliteTables(local);
     const results = await syncPush(local, cloud, { tables: tableList });
     local.close();
@@ -5759,7 +5753,7 @@ function registerCloudTools(server, serviceName, opts = {}) {
         isError: true
       };
     }
-    const local = new SqliteAdapter(opts.dbPath ?? getDbPath(serviceName));
+    const local = new SqliteAdapter(getDbPath(serviceName));
     const cloud = new PgAdapterAsync(getConnectionString(serviceName));
     let tableList;
     if (tablesStr) {
@@ -14141,6 +14135,56 @@ See https://www.postgresql.org/docs/current/libpq-ssl.html for libpq SSL mode de
 });
 
 // src/types/index.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value : undefined;
+}
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function stringMap(value) {
+  if (!isRecord(value))
+    return;
+  const entries = Object.entries(value).filter((entry) => typeof entry[1] === "string");
+  return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+function cleanupValue(value) {
+  if (value === "delete" || value === "stop" || value === "keep")
+    return value;
+  return;
+}
+function workflowExecutionFromValue(value) {
+  const input = isRecord(value) ? value : {};
+  const rawTarget = stringValue(input["target"]) ?? "local";
+  if (rawTarget === "local") {
+    const timeoutMs2 = numberValue(input["timeoutMs"]);
+    return timeoutMs2 === undefined ? { target: "local" } : { target: "local", timeoutMs: timeoutMs2 };
+  }
+  if (rawTarget !== "sandbox" && rawTarget !== "connector:e2b") {
+    throw new Error(`Unsupported workflow execution target: ${rawTarget}`);
+  }
+  const provider = rawTarget === "connector:e2b" ? "e2b" : stringValue(input["provider"]) ?? stringValue(input["connector"]);
+  const sandboxImage = stringValue(input["sandboxImage"]) ?? stringValue(input["sandboxTemplate"]);
+  const sandboxRemoteDir = stringValue(input["sandboxRemoteDir"]);
+  const sandboxCleanup = cleanupValue(input["sandboxCleanup"]);
+  const setupCommand = stringValue(input["setupCommand"]);
+  const packageSpec = stringValue(input["packageSpec"]);
+  const timeoutMs = numberValue(input["timeoutMs"]);
+  const env = stringMap(input["env"]);
+  return {
+    target: "sandbox",
+    ...provider ? { provider } : {},
+    ...sandboxImage ? { sandboxImage } : {},
+    ...sandboxRemoteDir ? { sandboxRemoteDir } : {},
+    ...sandboxCleanup ? { sandboxCleanup } : {},
+    ...setupCommand ? { setupCommand } : {},
+    ...packageSpec ? { packageSpec } : {},
+    ...timeoutMs !== undefined ? { timeoutMs } : {},
+    ...env ? { env } : {}
+  };
+}
 function workflowFromRow(row) {
   return {
     id: row.id,
@@ -14150,7 +14194,7 @@ function workflowFromRow(row) {
     scenarioFilter: JSON.parse(row.scenario_filter || "{}"),
     personaIds: JSON.parse(row.persona_ids || "[]"),
     goal: row.goal ? JSON.parse(row.goal) : null,
-    execution: JSON.parse(row.execution || '{"target":"local"}'),
+    execution: workflowExecutionFromValue(JSON.parse(row.execution || '{"target":"local"}')),
     settings: JSON.parse(row.settings || "{}"),
     enabled: row.enabled === 1,
     createdAt: row.created_at,
@@ -16556,6 +16600,10 @@ function loadConfig() {
   if (envApiKey) {
     config.anthropicApiKey = envApiKey;
   }
+  const envSelfHeal = process.env["TESTERS_SELF_HEAL"];
+  if (envSelfHeal !== undefined) {
+    config.selfHeal = ["1", "true", "yes", "on"].includes(envSelfHeal.toLowerCase());
+  }
   return config;
 }
 function resolveModel(nameOrId) {
@@ -16598,12 +16646,11 @@ Original selector that failed: "${request.failedSelector}"
 Please identify the correct selector from the screenshot.`;
   let rawResponse = "";
   try {
-    if (provider === "openai" || provider === "google") {
-      const baseUrl = provider === "openai" ? "https://api.openai.com/v1" : "https://generativelanguage.googleapis.com/v1beta/openai";
-      const apiKey = provider === "openai" ? process.env["OPENAI_API_KEY"] ?? "" : process.env["GOOGLE_API_KEY"] ?? "";
+    if (provider !== "anthropic") {
+      const compat = createOpenAICompatibleConfig(provider);
       const resp = await callOpenAICompatible({
-        baseUrl,
-        apiKey,
+        baseUrl: compat.baseUrl,
+        apiKey: compat.apiKey,
         model,
         system: HEAL_SYSTEM,
         messages: [{ role: "user", content: userMessage }],
@@ -16697,12 +16744,15 @@ var init_healer = __esm(() => {
 var exports_ai_client = {};
 __export(exports_ai_client, {
   runAgentLoop: () => runAgentLoop,
+  resolveProviderApiKeyForModel: () => resolveProviderApiKeyForModel,
   resolveModel: () => resolveModel2,
   executeTool: () => executeTool,
   detectProvider: () => detectProvider,
+  createOpenAICompatibleConfig: () => createOpenAICompatibleConfig,
   createClientForModel: () => createClientForModel,
   createClient: () => createClient,
   callOpenAICompatible: () => callOpenAICompatible,
+  buildScenarioUserMessage: () => buildScenarioUserMessage,
   BROWSER_TOOLS: () => BROWSER_TOOLS
 });
 import Anthropic2 from "@anthropic-ai/sdk";
@@ -17115,7 +17165,6 @@ async function executeTool(page, screenshotter, toolName, toolInput, context) {
         const assertionType = toolInput.assertion_type;
         const selector = toolInput.selector;
         const expected = toolInput.expected;
-        const sessionId = context.sessionId ?? "default";
         switch (assertionType) {
           case "element_exists": {
             if (!selector)
@@ -17180,7 +17229,6 @@ async function executeTool(page, screenshotter, toolName, toolInput, context) {
       case "browser_intercept": {
         const action = toolInput.action;
         const pattern = toolInput.pattern;
-        const interceptAction = toolInput.intercept_action;
         const statusCode = toolInput.status_code;
         const body = toolInput.body;
         const sessionId = context.sessionId ?? "default";
@@ -17257,7 +17305,28 @@ ${JSON.stringify(har, null, 2)}` };
       }
       case "browser_a11y": {
         const level = toolInput.level ?? "AA";
-        const snapshot = await page.accessibility.snapshot();
+        const snapshot = await page.evaluate(() => {
+          function readRole(el) {
+            return el.getAttribute("role") ?? el.tagName.toLowerCase();
+          }
+          function readName(el) {
+            const labelledBy = el.getAttribute("aria-labelledby");
+            if (labelledBy) {
+              const labelledText = labelledBy.split(/\s+/).map((id) => document.getElementById(id)?.textContent?.trim()).filter(Boolean).join(" ");
+              if (labelledText)
+                return labelledText;
+            }
+            return el.getAttribute("aria-label") ?? el.getAttribute("alt") ?? el.textContent?.trim() ?? "";
+          }
+          function walk(el) {
+            return {
+              role: readRole(el),
+              name: readName(el),
+              children: Array.from(el.children).map((child) => walk(child))
+            };
+          }
+          return document.body ? walk(document.body) : null;
+        });
         if (!snapshot)
           return { result: "Error: could not capture accessibility tree" };
         const issues = [];
@@ -17299,6 +17368,38 @@ ${filtered.join(`
     return { result: `Error executing ${toolName}: ${message}` };
   }
 }
+function resolveStartUrl(baseUrl, targetPath) {
+  try {
+    return new URL(targetPath, baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`).toString();
+  } catch {
+    return `${baseUrl.replace(/\/+$/, "")}/${targetPath.replace(/^\/+/, "")}`;
+  }
+}
+function buildScenarioUserMessage(scenario, baseUrl) {
+  const userParts = [
+    `**Scenario:** ${scenario.name}`,
+    `**Description:** ${scenario.description}`
+  ];
+  if (baseUrl) {
+    const normalizedBaseUrl = baseUrl.replace(/\/+$/, "");
+    userParts.push(`**Base URL:** ${normalizedBaseUrl}`);
+    if (scenario.targetPath) {
+      userParts.push(`**Start URL:** ${resolveStartUrl(normalizedBaseUrl, scenario.targetPath)}`);
+    }
+    userParts.push("**Navigation Boundary:** Treat the Base URL as the application under test. Resolve relative paths and in-app navigation against this origin. Do not navigate to another host unless a step explicitly includes an absolute external URL.");
+  }
+  if (scenario.targetPath) {
+    userParts.push(`**Target Path:** ${scenario.targetPath}`);
+  }
+  if (scenario.steps.length > 0) {
+    userParts.push("**Steps:**");
+    for (let i = 0;i < scenario.steps.length; i++) {
+      userParts.push(`${i + 1}. ${scenario.steps[i]}`);
+    }
+  }
+  return userParts.join(`
+`);
+}
 async function runAgentLoop(options) {
   const {
     client,
@@ -17308,6 +17409,7 @@ async function runAgentLoop(options) {
     model,
     runId,
     sessionId,
+    baseUrl,
     maxTurns = 30,
     onStep,
     persona,
@@ -17355,21 +17457,7 @@ Instructions: ${persona.instructions}` : "",
     "- Verify both positive and negative states"
   ].join(`
 `) + personaSection;
-  const userParts = [
-    `**Scenario:** ${scenario.name}`,
-    `**Description:** ${scenario.description}`
-  ];
-  if (scenario.targetPath) {
-    userParts.push(`**Target Path:** ${scenario.targetPath}`);
-  }
-  if (scenario.steps.length > 0) {
-    userParts.push("**Steps:**");
-    for (let i = 0;i < scenario.steps.length; i++) {
-      userParts.push(`${i + 1}. ${scenario.steps[i]}`);
-    }
-  }
-  const userMessage = userParts.join(`
-`);
+  const userMessage = buildScenarioUserMessage(scenario, baseUrl);
   const screenshots = [];
   let tokensUsed = 0;
   let stepNumber = 0;
@@ -17432,7 +17520,7 @@ Instructions: ${persona.instructions}` : "",
         if (onStep) {
           onStep({ type: "tool_call", toolName: toolBlock.name, toolInput, stepNumber });
         }
-        const execResult = await executeTool(page, screenshotter, toolBlock.name, toolInput, { runId, scenarioSlug, stepNumber, sessionId, a11y });
+        const execResult = await executeTool(page, screenshotter, toolBlock.name, toolInput, { runId, scenarioSlug, stepNumber, sessionId: sessionId ?? runId, a11y });
         if (onStep) {
           onStep({ type: "tool_result", toolName: toolBlock.name, toolResult: execResult.result, stepNumber });
         }
@@ -17483,10 +17571,17 @@ function detectProvider(model) {
     return "openai";
   if (model.startsWith("gemini-"))
     return "google";
+  if (model.startsWith("glm-") || model.startsWith("zai/") || model.startsWith("zai-"))
+    return "zai";
   if (model.startsWith("llama-") || model.startsWith("qwen-") || model.includes("cerebras"))
     return "cerebras";
   return "anthropic";
 }
+function resolveProviderApiKeyForModel(model, explicitApiKey, configuredAnthropicApiKey) {
+  if (explicitApiKey)
+    return explicitApiKey;
+  return detectProvider(model) === "anthropic" ? configuredAnthropicApiKey : undefined;
+}
 function createClient(apiKey) {
   const key = apiKey ?? process.env["ANTHROPIC_API_KEY"];
   if (!key) {
@@ -17564,26 +17659,34 @@ async function callOpenAICompatible(options) {
   const usage = { input_tokens: data.usage?.prompt_tokens ?? 0, output_tokens: data.usage?.completion_tokens ?? 0 };
   return { content, stop_reason: stopReason, usage };
 }
-function createClientForModel(model, apiKey) {
-  const provider = detectProvider(model);
+function createOpenAICompatibleConfig(provider, apiKey) {
   if (provider === "openai") {
-    const key = apiKey ?? process.env["OPENAI_API_KEY"];
-    if (!key)
+    const key2 = apiKey ?? process.env["OPENAI_API_KEY"];
+    if (!key2)
       throw new AIClientError("No OpenAI API key. Set OPENAI_API_KEY or pass it explicitly.");
-    return { provider: "openai", baseUrl: "https://api.openai.com/v1", apiKey: key };
+    return { provider: "openai", baseUrl: "https://api.openai.com/v1", apiKey: key2 };
   }
   if (provider === "google") {
-    const key = apiKey ?? process.env["GOOGLE_API_KEY"];
-    if (!key)
+    const key2 = apiKey ?? process.env["GOOGLE_API_KEY"];
+    if (!key2)
       throw new AIClientError("No Google API key. Set GOOGLE_API_KEY or pass it explicitly.");
-    return { provider: "google", baseUrl: "https://generativelanguage.googleapis.com/v1beta/openai", apiKey: key };
+    return { provider: "google", baseUrl: "https://generativelanguage.googleapis.com/v1beta/openai", apiKey: key2 };
   }
   if (provider === "cerebras") {
-    const key = apiKey ?? process.env["CEREBRAS_API_KEY"];
-    if (!key)
+    const key2 = apiKey ?? process.env["CEREBRAS_API_KEY"];
+    if (!key2)
       throw new AIClientError("No Cerebras API key. Set CEREBRAS_API_KEY or pass it explicitly.");
-    return { provider: "cerebras", baseUrl: "https://api.cerebras.ai/v1", apiKey: key };
+    return { provider: "cerebras", baseUrl: "https://api.cerebras.ai/v1", apiKey: key2 };
   }
+  const key = apiKey ?? process.env["ZAI_API_KEY"];
+  if (!key)
+    throw new AIClientError("No Z.AI API key. Set ZAI_API_KEY or pass it explicitly.");
+  return { provider: "zai", baseUrl: "https://api.z.ai/api/paas/v4", apiKey: key };
+}
+function createClientForModel(model, apiKey) {
+  const provider = detectProvider(model);
+  if (provider !== "anthropic")
+    return createOpenAICompatibleConfig(provider, apiKey);
   return createClient(apiKey);
 }
 var activeHARs, activeCoverage, BROWSER_TOOLS;
@@ -18160,22 +18263,22 @@ function resolveJudgeModel(config) {
       apiKey = process.env["GOOGLE_API_KEY"];
     else if (provider === "cerebras")
       apiKey = process.env["CEREBRAS_API_KEY"];
+    else if (provider === "zai")
+      apiKey = process.env["ZAI_API_KEY"];
   }
   if (!apiKey) {
-    apiKey = process.env["ANTHROPIC_API_KEY"] ?? process.env["CEREBRAS_API_KEY"] ?? process.env["OPENAI_API_KEY"] ?? process.env["GOOGLE_API_KEY"] ?? globalConfig.anthropicApiKey;
-    if (!apiKey)
-      throw new AIClientError("No API key found for judge. Set ANTHROPIC_API_KEY, CEREBRAS_API_KEY, OPENAI_API_KEY, or GOOGLE_API_KEY.");
+    throw new AIClientError(`No API key found for ${provider} judge provider.`);
   }
   return { model, provider, apiKey };
 }
 async function callJudge(prompt, config) {
   const { model, provider, apiKey } = resolveJudgeModel(config);
   const threshold = 0.7;
-  if (provider === "openai" || provider === "google" || provider === "cerebras") {
-    const baseUrl = provider === "openai" ? "https://api.openai.com/v1" : provider === "cerebras" ? "https://api.cerebras.ai/v1" : "https://generativelanguage.googleapis.com/v1beta/openai";
+  if (provider !== "anthropic") {
+    const compat = createOpenAICompatibleConfig(provider, apiKey);
     const resp2 = await callOpenAICompatible({
-      baseUrl,
-      apiKey,
+      baseUrl: compat.baseUrl,
+      apiKey: compat.apiKey,
       model,
       system: LLM_SYSTEM,
       messages: [{ role: "user", content: prompt }],
@@ -20631,6 +20734,292 @@ var init_failure_pipeline = __esm(() => {
   init_todos_connector();
 });
 
+// src/lib/a11y-audit.ts
+async function runA11yAudit(page, options = {}) {
+  const { level = "AA", rules, exclude = [] } = options;
+  await page.addScriptTag({ url: "https://cdnjs.cloudflare.com/ajax/libs/axe-core/4.9.1/axe.min.js" });
+  const config = {
+    runOnly: {
+      type: level === "AAA" ? "standard" : "tag",
+      values: level === "AAA" ? undefined : [level, "best-practice"]
+    }
+  };
+  if (rules && rules.length > 0) {
+    config.rules = Object.fromEntries(rules.map((r) => [r, { enabled: true }]));
+  }
+  if (exclude.length > 0) {
+    config.exclude = exclude;
+  }
+  const result = await page.evaluate(async (auditConfig) => {
+    const axeResult = await window.axe.run(auditConfig);
+    return axeResult;
+  }, config);
+  const violations = (result.violations ?? []).map((v) => ({
+    id: v.id,
+    impact: v.impact,
+    description: v.description,
+    help: v.help,
+    helpUrl: v.helpUrl,
+    nodes: (v.nodes ?? []).map((n) => ({
+      html: n.html,
+      target: n.target,
+      failureSummary: n.failureSummary
+    }))
+  }));
+  const passes = (result.passes ?? []).map((p) => ({
+    id: p.id,
+    description: p.description
+  }));
+  const incomplete = (result.incomplete ?? []).map((i) => ({
+    id: i.id,
+    description: i.description,
+    impact: i.impact
+  }));
+  const criticalCount = violations.filter((v) => v.impact === "critical").length;
+  const seriousCount = violations.filter((v) => v.impact === "serious").length;
+  const moderateCount = violations.filter((v) => v.impact === "moderate").length;
+  const minorCount = violations.filter((v) => v.impact === "minor").length;
+  return {
+    violations,
+    passes,
+    incomplete,
+    url: page.url(),
+    timestamp: new Date().toISOString(),
+    totalViolations: violations.length,
+    criticalCount,
+    seriousCount,
+    moderateCount,
+    minorCount
+  };
+}
+
+// src/lib/assertions.ts
+async function evaluateAssertions(page, assertions, context = {}) {
+  const results = [];
+  for (const assertion of assertions) {
+    try {
+      const result = await evaluateOne(page, assertion, context);
+      results.push(result);
+    } catch (err) {
+      results.push({
+        assertion,
+        passed: false,
+        actual: "",
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return results;
+}
+async function evaluateOne(page, assertion, context) {
+  switch (assertion.type) {
+    case "visible": {
+      const visible = await page.locator(assertion.selector).isVisible();
+      return {
+        assertion,
+        passed: visible,
+        actual: String(visible)
+      };
+    }
+    case "not_visible": {
+      const visible = await page.locator(assertion.selector).isVisible();
+      return {
+        assertion,
+        passed: !visible,
+        actual: String(visible)
+      };
+    }
+    case "text_contains": {
+      const text = await page.locator(assertion.selector).textContent() ?? "";
+      const expected = String(assertion.expected ?? "");
+      return {
+        assertion,
+        passed: text.includes(expected),
+        actual: text
+      };
+    }
+    case "text_equals": {
+      const text = await page.locator(assertion.selector).textContent() ?? "";
+      const expected = String(assertion.expected ?? "");
+      return {
+        assertion,
+        passed: text.trim() === expected.trim(),
+        actual: text
+      };
+    }
+    case "element_count": {
+      const count = await page.locator(assertion.selector).count();
+      const expected = Number(assertion.expected ?? 0);
+      return {
+        assertion,
+        passed: count === expected,
+        actual: String(count)
+      };
+    }
+    case "no_console_errors": {
+      if (context.consoleErrors !== undefined) {
+        const errors2 = context.consoleErrors.filter(Boolean);
+        return {
+          assertion,
+          passed: errors2.length === 0,
+          actual: errors2.length === 0 ? "No console errors captured" : errors2.slice(0, 3).join(" | ")
+        };
+      }
+      const errorElements = await page.locator('[role="alert"], .error, .error-message, [data-testid="error"]').count();
+      return {
+        assertion,
+        passed: errorElements === 0,
+        actual: `${errorElements} error element(s) found`
+      };
+    }
+    case "no_a11y_violations": {
+      try {
+        const auditResult = await runA11yAudit(page);
+        const hasIssues = auditResult.violations.length > 0;
+        return {
+          assertion,
+          passed: !hasIssues,
+          actual: hasIssues ? `${auditResult.totalViolations} violation(s): ${auditResult.violations.map((v) => v.id).join(", ")}` : "No accessibility violations found"
+        };
+      } catch (err) {
+        return {
+          assertion,
+          passed: false,
+          actual: "",
+          error: err instanceof Error ? err.message : String(err)
+        };
+      }
+    }
+    case "url_contains": {
+      const url = page.url();
+      const expected = String(assertion.expected ?? "");
+      return {
+        assertion,
+        passed: url.includes(expected),
+        actual: url
+      };
+    }
+    case "title_contains": {
+      const title = await page.title();
+      const expected = String(assertion.expected ?? "");
+      return {
+        assertion,
+        passed: title.includes(expected),
+        actual: title
+      };
+    }
+    case "cookie_exists": {
+      const cookieName = assertion.expected;
+      const cookies = await page.context().cookies();
+      const found = cookies.some((c) => c.name === cookieName);
+      return {
+        assertion,
+        passed: found,
+        actual: found ? `Cookie "${cookieName}" exists` : `Cookie "${cookieName}" not found`
+      };
+    }
+    case "cookie_not_exists": {
+      const cookieName = assertion.expected;
+      const cookies = await page.context().cookies();
+      const found = cookies.some((c) => c.name === cookieName);
+      return {
+        assertion,
+        passed: !found,
+        actual: found ? `Cookie "${cookieName}" found (unexpected)` : `Cookie "${cookieName}" does not exist`
+      };
+    }
+    case "cookie_value": {
+      const [cookieName, expectedValue] = assertion.expected.split("=", 2);
+      const cookies = await page.context().cookies();
+      const cookie = cookies.find((c) => c.name === cookieName);
+      const actualValue = cookie?.value ?? "";
+      return {
+        assertion,
+        passed: actualValue === expectedValue,
+        actual: cookie ? `${cookieName}=${actualValue}` : `Cookie "${cookieName}" not found`
+      };
+    }
+    case "local_storage_exists": {
+      const key = assertion.expected;
+      const value = await page.evaluate((k) => localStorage.getItem(k), key);
+      return {
+        assertion,
+        passed: value !== null,
+        actual: value !== null ? `Key "${key}" exists with value "${value}"` : `Key "${key}" not found in localStorage`
+      };
+    }
+    case "local_storage_not_exists": {
+      const key = assertion.expected;
+      const value = await page.evaluate((k) => localStorage.getItem(k), key);
+      return {
+        assertion,
+        passed: value === null,
+        actual: value !== null ? `Key "${key}" exists (unexpected)` : `Key "${key}" does not exist in localStorage`
+      };
+    }
+    case "local_storage_value": {
+      const [lsKey, expectedValue] = assertion.expected.split("=", 2);
+      const value = await page.evaluate((k) => localStorage.getItem(k), lsKey ?? "");
+      return {
+        assertion,
+        passed: value === expectedValue,
+        actual: value !== null ? `${lsKey}=${value}` : `Key "${lsKey}" not found in localStorage`
+      };
+    }
+    case "session_storage_value": {
+      const [ssKey, expectedValue] = assertion.expected.split("=", 2);
+      const value = await page.evaluate((k) => sessionStorage.getItem(k), ssKey ?? "");
+      return {
+        assertion,
+        passed: value === expectedValue,
+        actual: value !== null ? `${ssKey}=${value}` : `Key "${ssKey}" not found in sessionStorage`
+      };
+    }
+    case "session_storage_not_exists": {
+      const key = assertion.expected;
+      const value = await page.evaluate((k) => sessionStorage.getItem(k), key);
+      return {
+        assertion,
+        passed: value === null,
+        actual: value !== null ? `Key "${key}" exists (unexpected)` : `Key "${key}" does not exist in sessionStorage`
+      };
+    }
+    default: {
+      return {
+        assertion,
+        passed: false,
+        actual: "",
+        error: `Unknown assertion type: ${assertion.type}`
+      };
+    }
+  }
+}
+function allAssertionsPassed(results) {
+  return results.every((r) => r.passed);
+}
+function formatAssertionResults(results) {
+  if (results.length === 0)
+    return "No assertions.";
+  const lines = [];
+  for (const r of results) {
+    const icon = r.passed ? "PASS" : "FAIL";
+    const desc = r.assertion.description || `${r.assertion.type}${r.assertion.selector ? ` ${r.assertion.selector}` : ""}`;
+    let line = `  [${icon}] ${desc}`;
+    if (!r.passed) {
+      line += ` (actual: ${r.actual})`;
+      if (r.error)
+        line += ` \u2014 ${r.error}`;
+    }
+    lines.push(line);
+  }
+  const passed = results.filter((r) => r.passed).length;
+  lines.push(`
+  ${passed}/${results.length} assertions passed.`);
+  return lines.join(`
+`);
+}
+var init_assertions = () => {};
+
 // src/db/flows.ts
 var exports_flows = {};
 __export(exports_flows, {
@@ -20789,7 +21178,10 @@ __export(exports_runner, {
   runSingleScenario: () => runSingleScenario,
   runByFilter: () => runByFilter,
   runBatch: () => runBatch,
-  onRunEvent: () => onRunEvent
+  resolveScenariosForRun: () => resolveScenariosForRun,
+  resolveAgentApiKeyForModel: () => resolveAgentApiKeyForModel,
+  onRunEvent: () => onRunEvent,
+  applyStructuredAssertionsToResult: () => applyStructuredAssertionsToResult
 });
 import { mkdirSync as mkdirSync8 } from "fs";
 import { join as join13 } from "path";
@@ -20801,6 +21193,57 @@ function emit(event) {
   if (eventHandler)
     eventHandler(event);
 }
+function resolveAgentApiKeyForModel(model, explicitApiKey, configuredAnthropicApiKey) {
+  return resolveProviderApiKeyForModel(model, explicitApiKey, configuredAnthropicApiKey);
+}
+function assertionDescription(result) {
+  return result.assertion.description || `${result.assertion.type}${result.assertion.selector ? ` ${result.assertion.selector}` : ""}`;
+}
+function summarizeAssertionResult(result) {
+  const description = assertionDescription(result);
+  if (result.passed)
+    return description;
+  const suffix = result.error ? `; ${result.error}` : "";
+  return `${description} (actual: ${result.actual}${suffix})`;
+}
+async function applyStructuredAssertionsToResult(input) {
+  const assertions = input.scenario.assertions ?? [];
+  if (assertions.length === 0) {
+    return {
+      status: input.status,
+      reasoning: input.reasoning,
+      assertionsPassed: [],
+      assertionsFailed: [],
+      assertionResults: []
+    };
+  }
+  const results = await evaluateAssertions(input.page, assertions, {
+    consoleErrors: input.consoleErrors
+  });
+  const assertionsPassed = results.filter((r) => r.passed).map(summarizeAssertionResult);
+  const assertionsFailed = results.filter((r) => !r.passed).map(summarizeAssertionResult);
+  const assertionResults = results.map((result) => ({
+    type: result.assertion.type,
+    description: assertionDescription(result),
+    passed: result.passed,
+    actual: result.actual,
+    ...result.error ? { error: result.error } : {}
+  }));
+  const assertionsOk = allAssertionsPassed(results);
+  const status = assertionsOk || input.status !== "passed" ? input.status : "failed";
+  const assertionHeading = assertionsOk ? "Structured assertions passed:" : "Structured assertions failed:";
+  const reasoningParts = [input.reasoning, `${assertionHeading}
+${formatAssertionResults(results)}`].map((part) => part.trim()).filter(Boolean);
+  return {
+    status,
+    reasoning: reasoningParts.join(`
+
+`),
+    assertionsPassed,
+    assertionsFailed,
+    assertionResults
+  };
+}
 function withTimeout(promise, ms, label) {
   return new Promise((resolve, reject) => {
     const warningAt = Math.floor(ms * 0.8);
@@ -20861,7 +21304,7 @@ async function runSingleScenario(scenario, runId, options) {
       });
     }
   }
-  const client = createClientForModel(model, effectiveOptions.apiKey ?? config.anthropicApiKey);
+  const client = createClientForModel(model, resolveAgentApiKeyForModel(model, effectiveOptions.apiKey, config.anthropicApiKey));
   const screenshotter = new Screenshotter({
     baseDir: effectiveOptions.screenshotDir ?? config.screenshots.dir
   });
@@ -20971,6 +21414,7 @@ async function runSingleScenario(scenario, runId, options) {
       model,
       runId,
       sessionId: result.id,
+      baseUrl: options.url,
       maxTurns: effectiveOptions.minimal ? 10 : 30,
       a11y: effectiveOptions.a11y,
       persona: persona ? {
@@ -21053,27 +21497,46 @@ async function runSingleScenario(scenario, runId, options) {
     closeSession(result.id);
     const lightpandaNote = options.engine === "lightpanda" ? " (Running with Lightpanda \u2014 no screenshots)" : options.engine === "bun" ? " (Running with Bun.WebView \u2014 native, ~11x faster)" : "";
     const networkMeta = networkErrors.length > 0 ? { networkErrors: networkErrors.slice(0, 20) } : {};
-    let updatedResult = updateResult(result.id, {
+    const baseReasoning = agentResult.reasoning ? agentResult.reasoning + lightpandaNote : lightpandaNote || "";
+    const assertionOutcome = await applyStructuredAssertionsToResult({
+      page,
+      scenario,
+      consoleErrors,
       status: agentResult.status,
-      reasoning: agentResult.reasoning ? agentResult.reasoning + lightpandaNote : lightpandaNote || undefined,
+      reasoning: baseReasoning
+    });
+    const structuredAssertionMeta = assertionOutcome.assertionResults.length > 0 ? {
+      structuredAssertions: {
+        passed: assertionOutcome.assertionsPassed,
+        failed: assertionOutcome.assertionsFailed,
+        results: assertionOutcome.assertionResults
+      }
+    } : {};
+    let updatedResult = updateResult(result.id, {
+      status: assertionOutcome.status,
+      reasoning: assertionOutcome.reasoning || undefined,
       stepsCompleted: agentResult.stepsCompleted,
       durationMs: Date.now() - new Date(result.createdAt).getTime(),
       tokensUsed: agentResult.tokensUsed,
       costCents: estimateCost(model, agentResult.tokensUsed),
-      metadata: { consoleLogs, ...networkErrors.length > 0 ? networkMeta : {} }
+      metadata: {
+        consoleLogs,
+        ...networkErrors.length > 0 ? networkMeta : {},
+        ...structuredAssertionMeta
+      }
     });
-    if (agentResult.status === "failed" || agentResult.status === "error") {
-      const failureAnalysis = analyzeFailure(null, agentResult.reasoning ?? null);
+    if (assertionOutcome.status === "failed" || assertionOutcome.status === "error") {
+      const failureAnalysis = analyzeFailure(null, assertionOutcome.reasoning ?? null);
       if (failureAnalysis) {
         updatedResult = updateResult(result.id, { failureAnalysis });
       }
     }
-    if (agentResult.status === "passed") {
+    if (assertionOutcome.status === "passed") {
       try {
         updateScenarioPassedCache(scenario.id, options.url);
       } catch {}
     }
-    const eventType = agentResult.status === "passed" ? "scenario:pass" : "scenario:fail";
+    const eventType = assertionOutcome.status === "passed" ? "scenario:pass" : "scenario:fail";
     emit({ type: eventType, scenarioId: scenario.id, scenarioName: scenario.name, resultId: result.id, runId });
     return updatedResult;
   } catch (error) {
@@ -21098,7 +21561,8 @@ async function runSingleScenario(scenario, runId, options) {
   } finally {
     if (harPath) {
       try {
-        updateResult(result.id, { metadata: { harPath } });
+        const existing = getResult(result.id);
+        updateResult(result.id, { metadata: { ...existing?.metadata ?? {}, harPath } });
       } catch {}
     }
     if (browser) {
@@ -21270,22 +21734,31 @@ async function runBatch(scenarios, options) {
   }
   return { run: finalRun, results };
 }
-async function runByFilter(options) {
-  let scenarios;
+function findScenarioInList(scenarios, id) {
+  return scenarios.find((scenario) => scenario.id === id || scenario.shortId === id || scenario.id.startsWith(id)) ?? null;
+}
+function resolveScenariosForRun(options) {
   if (options.scenarioIds && options.scenarioIds.length > 0) {
-    const all = listScenarios({ projectId: options.projectId });
-    scenarios = all.filter((s) => options.scenarioIds.includes(s.id) || options.scenarioIds.includes(s.shortId));
-    if (scenarios.length === 0 && options.projectId) {
-      const global2 = listScenarios({});
-      scenarios = global2.filter((s) => options.scenarioIds.includes(s.id) || options.scenarioIds.includes(s.shortId));
+    const scoped = listScenarios({ projectId: options.projectId });
+    const resolved = [];
+    const seen = new Set;
+    for (const id of options.scenarioIds) {
+      const scenario = findScenarioInList(scoped, id) ?? getScenario(id);
+      if (scenario && !seen.has(scenario.id)) {
+        resolved.push(scenario);
+        seen.add(scenario.id);
+      }
     }
-  } else {
-    scenarios = listScenarios({
-      projectId: options.projectId,
-      tags: options.tags,
-      priority: options.priority
-    });
+    return resolved;
   }
+  return listScenarios({
+    projectId: options.projectId,
+    tags: options.tags,
+    priority: options.priority
+  });
+}
+async function runByFilter(options) {
+  const scenarios = resolveScenariosForRun(options);
   if (scenarios.length === 0) {
     const config = loadConfig();
     const model = resolveModel2(options.model ?? config.defaultModel);
@@ -21298,17 +21771,7 @@ async function runByFilter(options) {
 function startRunAsync(options) {
   const config = loadConfig();
   const model = resolveModel2(options.model ?? config.defaultModel);
-  let scenarios;
-  if (options.scenarioIds && options.scenarioIds.length > 0) {
-    const all = listScenarios({ projectId: options.projectId });
-    scenarios = all.filter((s) => options.scenarioIds.includes(s.id) || options.scenarioIds.includes(s.shortId));
-  } else {
-    scenarios = listScenarios({
-      projectId: options.projectId,
-      tags: options.tags,
-      priority: options.priority
-    });
-  }
+  const scenarios = resolveScenariosForRun(options);
   if (!options.skipBudgetCheck) {
     const cap = options.maxCostCents ?? config.defaultMaxCostCents;
     if (cap !== undefined && cap > 0 && scenarios.length > 0) {
@@ -21412,6 +21875,7 @@ var init_runner = __esm(() => {
   init_session_tracker();
   init_webhooks();
   init_failure_pipeline();
+  init_assertions();
 });
 
 // src/lib/affected.ts
@@ -22886,18 +23350,7 @@ function normalizeFilter(input) {
   };
 }
 function normalizeExecution(input) {
-  const target = input?.target ?? "local";
-  if (target === "connector:e2b") {
-    return {
-      target,
-      connector: input?.connector ?? "e2b",
-      operation: input?.operation ?? "run",
-      sandboxTemplate: input?.sandboxTemplate,
-      timeoutMs: input?.timeoutMs,
-      env: input?.env
-    };
-  }
-  return { ...DEFAULT_EXECUTION, timeoutMs: input?.timeoutMs };
+  return input ? workflowExecutionFromValue(input) : DEFAULT_EXECUTION;
 }
 function createTestingWorkflow(input) {
   const db2 = getDatabase();
@@ -22948,6 +23401,9 @@ var init_workflows = __esm(() => {
 });
 
 // src/lib/workflow-runner.ts
+import { mkdtempSync, rmSync, writeFileSync as writeFileSync3 } from "fs";
+import { tmpdir } from "os";
+import { join as join14 } from "path";
 function buildWorkflowRunPlan(workflow, options) {
   const runOptions = {
     url: options.url,
@@ -22964,10 +23420,10 @@ function buildWorkflowRunPlan(workflow, options) {
   return {
     workflow,
     runOptions,
-    connectorCommand: workflow.execution.target === "connector:e2b" ? buildConnectorCommand(workflow.execution, runOptions) : null
+    sandbox: workflow.execution.target === "sandbox" ? buildSandboxPlan(workflow, workflow.execution, runOptions) : null
   };
 }
-async function runTestingWorkflow(workflowId, options) {
+async function runTestingWorkflow(workflowId, options, dependencies = {}) {
   const workflow = getTestingWorkflow(workflowId);
   if (!workflow)
     throw new Error(`Testing workflow not found: ${workflowId}`);
@@ -22977,13 +23433,25 @@ async function runTestingWorkflow(workflowId, options) {
   const plan = buildWorkflowRunPlan(workflow, options);
   if (options.dryRun)
     return { run: null, results: [], plan };
-  if (workflow.execution.target === "connector:e2b") {
-    const connectorResult = await runViaConnector(plan);
-    return { run: null, results: [], plan, connectorResult };
+  if (workflow.execution.target === "sandbox") {
+    const sandboxResult = await runViaSandbox(plan, dependencies);
+    return { run: null, results: [], plan, sandboxResult };
   }
-  const { run, results } = await runByFilter(plan.runOptions);
+  const runLocal = dependencies.runByFilter ?? runByFilter;
+  const { run, results } = await runLocal(plan.runOptions);
   return { run, results, plan };
 }
+function createWorkflowDatabaseBundle(workflow, plan) {
+  if (!plan.sandbox)
+    throw new Error(`Workflow is not configured for sandbox execution: ${workflow.name}`);
+  const localDir = mkdtempSync(join14(tmpdir(), `testers-workflow-${workflow.id.slice(0, 8)}-`));
+  writeFileSync3(join14(localDir, "testers.db"), getDatabase().serialize());
+  return {
+    localDir,
+    remoteDir: plan.sandbox.stateRemoteDir,
+    cleanup: () => rmSync(localDir, { recursive: true, force: true })
+  };
+}
 function validatePersonaIds(workflow) {
   for (const personaId of workflow.personaIds) {
     if (!getPersona(personaId)) {
@@ -22991,48 +23459,112 @@ function validatePersonaIds(workflow) {
     }
   }
 }
-function buildConnectorCommand(execution, runOptions) {
-  const connector = execution.connector ?? "e2b";
-  const operation = execution.operation ?? "run";
-  const payload = JSON.stringify({
-    operation,
-    template: execution.sandboxTemplate,
+function buildSandboxPlan(workflow, execution, runOptions) {
+  const remoteDir = execution.sandboxRemoteDir ?? `/tmp/testers-workflow-${workflow.id.slice(0, 8)}`;
+  const stateRemoteDir = `${remoteDir.replace(/\/+$/, "")}/.testers-state`;
+  return {
+    provider: execution.provider,
+    image: execution.sandboxImage,
+    name: `testers-${workflow.id.slice(0, 8)}`,
+    remoteDir,
+    stateRemoteDir,
+    cleanup: execution.sandboxCleanup ?? "delete",
     timeoutMs: execution.timeoutMs,
-    env: execution.env ?? {},
-    command: [
-      "bunx",
-      "@hasna/testers",
-      "run",
-      runOptions.url,
-      ...runOptions.scenarioIds?.length ? ["--scenario", runOptions.scenarioIds.join(",")] : [],
-      ...runOptions.tags?.length ? runOptions.tags.flatMap((tag) => ["--tag", tag]) : [],
-      ...runOptions.priority ? ["--priority", runOptions.priority] : [],
-      ...runOptions.projectId ? ["--project", runOptions.projectId] : [],
-      ...runOptions.model ? ["--model", runOptions.model] : [],
-      "--json"
-    ]
-  });
-  return ["connectors", "run", connector, operation, payload];
+    env: execution.env,
+    command: buildSandboxCommand({
+      runOptions,
+      remoteDir,
+      dbPath: `${stateRemoteDir}/testers.db`,
+      setupCommand: execution.setupCommand,
+      packageSpec: execution.packageSpec ?? "@hasna/testers"
+    })
+  };
 }
-async function runViaConnector(plan) {
-  if (!plan.connectorCommand)
-    throw new Error("Workflow does not have a connector command");
-  const proc = Bun.spawn(plan.connectorCommand, {
-    stdout: "pipe",
-    stderr: "pipe",
-    env: process.env
-  });
-  const [stdout, stderr, exitCode] = await Promise.all([
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text(),
-    proc.exited
-  ]);
-  if (exitCode !== 0) {
-    throw new Error(`Connector execution failed (${exitCode}): ${stderr || stdout}`);
+function buildSandboxCommand(input) {
+  const args = [
+    "bunx",
+    input.packageSpec,
+    "run",
+    input.runOptions.url,
+    ...input.runOptions.scenarioIds?.length ? ["--scenario", input.runOptions.scenarioIds.join(",")] : [],
+    ...input.runOptions.tags?.length ? input.runOptions.tags.flatMap((tag) => ["--tag", tag]) : [],
+    ...input.runOptions.priority ? ["--priority", input.runOptions.priority] : [],
+    ...input.runOptions.projectId ? ["--project", input.runOptions.projectId] : [],
+    ...input.runOptions.model ? ["--model", input.runOptions.model] : [],
+    ...input.runOptions.headed ? ["--headed"] : [],
+    ...input.runOptions.parallel ? ["--parallel", String(input.runOptions.parallel)] : [],
+    ...input.runOptions.timeout ? ["--timeout", String(input.runOptions.timeout)] : [],
+    ...input.runOptions.personaIds?.length ? ["--persona", input.runOptions.personaIds.join(",")] : [],
+    "--no-auto-generate",
+    "--json"
+  ];
+  return [
+    "set -euo pipefail",
+    `mkdir -p ${shellQuote(input.remoteDir)}`,
+    `cd ${shellQuote(input.remoteDir)}`,
+    input.setupCommand,
+    `HASNA_TESTERS_DB_PATH=${shellQuote(input.dbPath)} ${args.map(shellQuote).join(" ")}`
+  ].filter(Boolean).join(`
+`);
+}
+async function runViaSandbox(plan, dependencies) {
+  if (!plan.sandbox)
+    throw new Error("Workflow does not have a sandbox plan");
+  const sandboxes = await resolveSandboxesRuntime(dependencies);
+  const createBundle = dependencies.createDatabaseBundle ?? createWorkflowDatabaseBundle;
+  const bundle = createBundle(plan.workflow, plan);
+  try {
+    const raw = await sandboxes.runCommandInSandbox({
+      command: plan.sandbox.command,
+      provider: plan.sandbox.provider,
+      name: plan.sandbox.name,
+      image: plan.sandbox.image,
+      sandboxTimeout: plan.sandbox.timeoutMs,
+      commandTimeoutMs: plan.sandbox.timeoutMs,
+      projectId: plan.workflow.projectId ?? undefined,
+      config: {
+        source: "testers",
+        workflowId: plan.workflow.id,
+        workflowName: plan.workflow.name
+      },
+      sandboxEnvVars: plan.sandbox.env,
+      cleanup: plan.sandbox.cleanup,
+      upload: {
+        localDir: bundle.localDir,
+        remoteDir: bundle.remoteDir
+      }
+    });
+    const exitCode = raw.result.exit_code ?? raw.result.exitCode ?? 0;
+    const stdout = raw.result.stdout ?? "";
+    const stderr = raw.result.stderr ?? "";
+    if (exitCode !== 0) {
+      throw new Error(`Sandbox workflow execution failed (${exitCode}): ${stderr || stdout}`);
+    }
+    return {
+      sandboxId: raw.sandbox.id,
+      sessionId: raw.session.id,
+      exitCode,
+      stdout,
+      stderr,
+      cleanup: raw.cleanup
+    };
+  } finally {
+    bundle.cleanup?.();
   }
-  return stdout.trim();
+}
+async function resolveSandboxesRuntime(dependencies) {
+  if (dependencies.sandboxes)
+    return dependencies.sandboxes;
+  if (dependencies.createSandboxesSDK)
+    return dependencies.createSandboxesSDK();
+  const mod = await import("@hasna/sandboxes");
+  return mod.createSandboxesSDK();
+}
+function shellQuote(value) {
+  return `'${value.replaceAll("'", `'"'"'`)}'`;
 }
 var init_workflow_runner = __esm(() => {
+  init_database();
   init_workflows();
   init_personas();
   init_runner();
@@ -34705,34 +35237,27 @@ var init_v3 = __esm(() => {
 
 // node_modules/@ai-sdk/provider-utils/node_modules/eventsource-parser/dist/index.js
 function noop(_arg) {}
-function createParser(config2) {
-  if (typeof config2 == "function")
-    throw new TypeError("`config` must be an object, got a function instead. Did you mean `createParser({onEvent: fn})`?");
-  const { onEvent = noop, onError = noop, onRetry = noop, onComment, maxBufferSize } = config2, pendingFragments = [];
-  let pendingFragmentsLength = 0, isFirstChunk = true, id, data = "", dataLines = 0, eventType, terminated = false;
+function createParser(callbacks) {
+  if (typeof callbacks == "function")
+    throw new TypeError("`callbacks` must be an object, got a function instead. Did you mean `{onEvent: fn}`?");
+  const { onEvent = noop, onError = noop, onRetry = noop, onComment } = callbacks, pendingFragments = [];
+  let isFirstChunk = true, id, data = "", dataLines = 0, eventType;
   function feed(chunk) {
-    if (terminated)
-      throw new Error("Cannot feed parser: it was terminated after exceeding the configured max buffer size. Call `reset()` to resume parsing.");
     if (isFirstChunk && (isFirstChunk = false, chunk.charCodeAt(0) === 239 && chunk.charCodeAt(1) === 187 && chunk.charCodeAt(2) === 191 && (chunk = chunk.slice(3))), pendingFragments.length === 0) {
       const trailing2 = processLines(chunk);
-      trailing2 !== "" && (pendingFragments.push(trailing2), pendingFragmentsLength = trailing2.length), checkBufferSize();
+      trailing2 !== "" && pendingFragments.push(trailing2);
       return;
     }
     if (chunk.indexOf(`
 `) === -1 && chunk.indexOf("\r") === -1) {
-      pendingFragments.push(chunk), pendingFragmentsLength += chunk.length, checkBufferSize();
+      pendingFragments.push(chunk);
       return;
     }
     pendingFragments.push(chunk);
     const input = pendingFragments.join("");
-    pendingFragments.length = 0, pendingFragmentsLength = 0;
+    pendingFragments.length = 0;
     const trailing = processLines(input);
-    trailing !== "" && (pendingFragments.push(trailing), pendingFragmentsLength = trailing.length), checkBufferSize();
-  }
-  function checkBufferSize() {
-    maxBufferSize !== undefined && (pendingFragmentsLength + data.length <= maxBufferSize || (terminated = true, pendingFragments.length = 0, pendingFragmentsLength = 0, id = undefined, data = "", dataLines = 0, eventType = undefined, onError(new ParseError(`Buffered data exceeded max buffer size of ${maxBufferSize} characters`, {
-      type: "max-buffer-size-exceeded"
-    }))));
+    trailing !== "" && pendingFragments.push(trailing);
   }
   function processLines(chunk) {
     let searchIndex = 0;
@@ -34844,7 +35369,7 @@ ${value}`, dataLines++;
       const incompleteLine = pendingFragments.join("");
       parseLine(incompleteLine, 0, incompleteLine.length);
     }
-    isFirstChunk = true, id = undefined, data = "", dataLines = 0, eventType = undefined, pendingFragments.length = 0, pendingFragmentsLength = 0, terminated = false;
+    isFirstChunk = true, id = undefined, data = "", dataLines = 0, eventType = undefined, pendingFragments.length = 0;
   }
   return { feed, reset };
 }
@@ -34868,7 +35393,7 @@ var EventSourceParserStream;
 var init_stream = __esm(() => {
   init_dist3();
   EventSourceParserStream = class EventSourceParserStream extends TransformStream {
-    constructor({ onError, onRetry, onComment, maxBufferSize } = {}) {
+    constructor({ onError, onRetry, onComment } = {}) {
       let parser;
       super({
         start(controller) {
@@ -34877,11 +35402,10 @@ var init_stream = __esm(() => {
               controller.enqueue(event);
             },
             onError(error40) {
-              typeof onError == "function" && onError(error40), (onError === "terminate" || error40.type === "max-buffer-size-exceeded") && controller.error(error40);
+              onError === "terminate" ? controller.error(error40) : typeof onError == "function" && onError(error40);
             },
             onRetry,
-            onComment,
-            maxBufferSize
+            onComment
           });
         },
         transform(chunk) {
@@ -36320,7 +36844,7 @@ var DelayedPromise = class {
     });
   }
   return () => `${prefix}${separator}${generator()}`;
-}, generateId, FETCH_FAILED_ERROR_MESSAGES, BUN_ERROR_CODES, VERSION = "4.0.27", getOriginalFetch = () => globalThis.fetch, getFromApi = async ({
+}, generateId, FETCH_FAILED_ERROR_MESSAGES, BUN_ERROR_CODES, VERSION = "4.0.26", getOriginalFetch = () => globalThis.fetch, getFromApi = async ({
   url: url2,
   headers = {},
   successfulResponseHandler,
@@ -38459,7 +38983,7 @@ var import_oidc, import_oidc2, marker17 = "vercel.ai.gateway.error", symbol18, _
       "ai-model-id": this.modelId
     };
   }
-}, gatewayRerankingResponseSchema, parallelSearchInputSchema, parallelSearchOutputSchema, parallelSearchToolFactory, parallelSearch = (config2 = {}) => parallelSearchToolFactory(config2), perplexitySearchInputSchema, perplexitySearchOutputSchema, perplexitySearchToolFactory, perplexitySearch = (config2 = {}) => perplexitySearchToolFactory(config2), gatewayTools, VERSION2 = "3.0.120", AI_GATEWAY_PROTOCOL_VERSION = "0.0.1", gateway;
+}, gatewayRerankingResponseSchema, parallelSearchInputSchema, parallelSearchOutputSchema, parallelSearchToolFactory, parallelSearch = (config2 = {}) => parallelSearchToolFactory(config2), perplexitySearchInputSchema, perplexitySearchOutputSchema, perplexitySearchToolFactory, perplexitySearch = (config2 = {}) => perplexitySearchToolFactory(config2), gatewayTools, VERSION2 = "3.0.110", AI_GATEWAY_PROTOCOL_VERSION = "0.0.1", gateway;
 var init_dist5 = __esm(() => {
   init_dist4();
   init_dist2();
@@ -38498,15 +39022,13 @@ var init_dist5 = __esm(() => {
       message,
       statusCode = 500,
       cause,
-      generationId,
-      isRetryable = statusCode != null && (statusCode === 408 || statusCode === 409 || statusCode === 429 || statusCode >= 500)
+      generationId
     }) {
       super(generationId ? `${message} [${generationId}]` : message);
       this[_a17] = true;
       this.statusCode = statusCode;
       this.cause = cause;
       this.generationId = generationId;
-      this.isRetryable = isRetryable;
     }
     static isInstance(error40) {
       return _GatewayError.hasMarker(error40);
@@ -39029,11 +39551,62 @@ Run 'npx vercel link' to link your project, then 'vc env pull' to fetch the toke
   gateway = createGatewayProvider();
 });
 
+// node_modules/@opentelemetry/api/build/src/platform/node/globalThis.js
+var require_globalThis = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports._globalThis = undefined;
+  exports._globalThis = typeof globalThis === "object" ? globalThis : global;
+});
+
+// node_modules/@opentelemetry/api/build/src/platform/node/index.js
+var require_node = __commonJS((exports) => {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() {
+      return m[k];
+    } });
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+    for (var p in m)
+      if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+        __createBinding(exports2, m, p);
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  __exportStar(require_globalThis(), exports);
+});
+
+// node_modules/@opentelemetry/api/build/src/platform/index.js
+var require_platform = __commonJS((exports) => {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() {
+      return m[k];
+    } });
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+    for (var p in m)
+      if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+        __createBinding(exports2, m, p);
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  __exportStar(require_node(), exports);
+});
+
 // node_modules/@opentelemetry/api/build/src/version.js
 var require_version = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.VERSION = undefined;
-  exports.VERSION = "1.9.1";
+  exports.VERSION = "1.9.0";
 });
 
 // node_modules/@opentelemetry/api/build/src/internal/semver.js
@@ -39111,11 +39684,12 @@ var require_semver = __commonJS((exports) => {
 var require_global_utils = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.unregisterGlobal = exports.getGlobal = exports.registerGlobal = undefined;
+  var platform_1 = require_platform();
   var version_1 = require_version();
   var semver_1 = require_semver();
   var major = version_1.VERSION.split(".")[0];
   var GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for(`opentelemetry.js.api.${major}`);
-  var _global = typeof globalThis === "object" ? globalThis : typeof self === "object" ? self : typeof window === "object" ? window : typeof global === "object" ? global : {};
+  var _global = platform_1._globalThis;
   function registerGlobal(type, instance, diag, allowOverride = false) {
     var _a16;
     const api2 = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a16 = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a16 !== undefined ? _a16 : {
@@ -39187,7 +39761,8 @@ var require_ComponentLogger = __commonJS((exports) => {
     if (!logger) {
       return;
     }
-    return logger[funcName](namespace, ...args);
+    args.unshift(namespace);
+    return logger[funcName](...args);
   }
 });
 
@@ -39248,12 +39823,6 @@ var require_diag = __commonJS((exports) => {
   var API_NAME = "diag";
 
   class DiagAPI {
-    static instance() {
-      if (!this._instance) {
-        this._instance = new DiagAPI;
-      }
-      return this._instance;
-    }
     constructor() {
       function _logProxy(funcName) {
         return function(...args) {
@@ -39298,6 +39867,12 @@ var require_diag = __commonJS((exports) => {
       self2.warn = _logProxy("warn");
       self2.error = _logProxy("error");
     }
+    static instance() {
+      if (!this._instance) {
+        this._instance = new DiagAPI;
+      }
+      return this._instance;
+    }
   }
   exports.DiagAPI = DiagAPI;
 });
@@ -39319,7 +39894,7 @@ var require_baggage_impl = __commonJS((exports) => {
       return Object.assign({}, entry);
     }
     getAllEntries() {
-      return Array.from(this._entries.entries());
+      return Array.from(this._entries.entries()).map(([k, v]) => [k, v]);
     }
     setEntry(key, entry) {
       const newBaggage = new BaggageImpl(this._entries);
@@ -39411,7 +39986,7 @@ var require_context = __commonJS((exports) => {
 // node_modules/@opentelemetry/api/build/src/diag/consoleLogger.js
 var require_consoleLogger = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
-  exports.DiagConsoleLogger = exports._originalConsoleMethods = undefined;
+  exports.DiagConsoleLogger = undefined;
   var consoleMap = [
     { n: "error", c: "error" },
     { n: "warn", c: "warn" },
@@ -39419,39 +39994,19 @@ var require_consoleLogger = __commonJS((exports) => {
     { n: "debug", c: "debug" },
     { n: "verbose", c: "trace" }
   ];
-  exports._originalConsoleMethods = {};
-  if (typeof console !== "undefined") {
-    const keys = [
-      "error",
-      "warn",
-      "info",
-      "debug",
-      "trace",
-      "log"
-    ];
-    for (const key of keys) {
-      if (typeof console[key] === "function") {
-        exports._originalConsoleMethods[key] = console[key];
-      }
-    }
-  }
 
   class DiagConsoleLogger {
     constructor() {
       function _consoleFunc(funcName) {
         return function(...args) {
-          let theFunc = exports._originalConsoleMethods[funcName];
-          if (typeof theFunc !== "function") {
-            theFunc = exports._originalConsoleMethods["log"];
-          }
-          if (typeof theFunc !== "function" && console) {
-            theFunc = console[funcName];
+          if (console) {
+            let theFunc = console[funcName];
             if (typeof theFunc !== "function") {
               theFunc = console.log;
             }
-          }
-          if (typeof theFunc === "function") {
-            return theFunc.apply(console, args);
+            if (typeof theFunc === "function") {
+              return theFunc.apply(console, args);
+            }
           }
         };
       }
@@ -39689,8 +40244,8 @@ var require_NonRecordingSpan = __commonJS((exports) => {
   var invalid_span_constants_1 = require_invalid_span_constants();
 
   class NonRecordingSpan {
-    constructor(spanContext = invalid_span_constants_1.INVALID_SPAN_CONTEXT) {
-      this._spanContext = spanContext;
+    constructor(_spanContext = invalid_span_constants_1.INVALID_SPAN_CONTEXT) {
+      this._spanContext = _spanContext;
     }
     spanContext() {
       return this._spanContext;
@@ -39766,126 +40321,14 @@ var require_spancontext_utils = __commonJS((exports) => {
   exports.wrapSpanContext = exports.isSpanContextValid = exports.isValidSpanId = exports.isValidTraceId = undefined;
   var invalid_span_constants_1 = require_invalid_span_constants();
   var NonRecordingSpan_1 = require_NonRecordingSpan();
-  var isHex = new Uint8Array([
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1
-  ]);
-  function isValidHex(id, length) {
-    if (typeof id !== "string" || id.length !== length)
-      return false;
-    let r = 0;
-    for (let i = 0;i < id.length; i += 4) {
-      r += (isHex[id.charCodeAt(i)] | 0) + (isHex[id.charCodeAt(i + 1)] | 0) + (isHex[id.charCodeAt(i + 2)] | 0) + (isHex[id.charCodeAt(i + 3)] | 0);
-    }
-    return r === length;
-  }
+  var VALID_TRACEID_REGEX = /^([0-9a-f]{32})$/i;
+  var VALID_SPANID_REGEX = /^[0-9a-f]{16}$/i;
   function isValidTraceId(traceId) {
-    return isValidHex(traceId, 32) && traceId !== invalid_span_constants_1.INVALID_TRACEID;
+    return VALID_TRACEID_REGEX.test(traceId) && traceId !== invalid_span_constants_1.INVALID_TRACEID;
   }
   exports.isValidTraceId = isValidTraceId;
   function isValidSpanId(spanId) {
-    return isValidHex(spanId, 16) && spanId !== invalid_span_constants_1.INVALID_SPANID;
+    return VALID_SPANID_REGEX.test(spanId) && spanId !== invalid_span_constants_1.INVALID_SPANID;
   }
   exports.isValidSpanId = isValidSpanId;
   function isSpanContextValid(spanContext) {
@@ -39945,7 +40388,7 @@ var require_NoopTracer = __commonJS((exports) => {
   }
   exports.NoopTracer = NoopTracer;
   function isSpanContext(spanContext) {
-    return spanContext !== null && typeof spanContext === "object" && "spanId" in spanContext && typeof spanContext["spanId"] === "string" && "traceId" in spanContext && typeof spanContext["traceId"] === "string" && "traceFlags" in spanContext && typeof spanContext["traceFlags"] === "number";
+    return typeof spanContext === "object" && typeof spanContext["spanId"] === "string" && typeof spanContext["traceId"] === "string" && typeof spanContext["traceFlags"] === "number";
   }
 });
 
@@ -39957,8 +40400,8 @@ var require_ProxyTracer = __commonJS((exports) => {
   var NOOP_TRACER = new NoopTracer_1.NoopTracer;
 
   class ProxyTracer {
-    constructor(provider, name15, version2, options) {
-      this._provider = provider;
+    constructor(_provider, name15, version2, options) {
+      this._provider = _provider;
       this.name = name15;
       this.version = version2;
       this.options = options;
@@ -40118,7 +40561,7 @@ var require_tracestate_impl = __commonJS((exports) => {
       return this._internalState.get(key);
     }
     serialize() {
-      return Array.from(this._internalState.keys()).reduceRight((agg, key) => {
+      return this._keys().reduce((agg, key) => {
         agg.push(key + LIST_MEMBER_KEY_VALUE_SPLITTER + this.get(key));
         return agg;
       }, []).join(LIST_MEMBERS_SEPARATOR);
@@ -40126,7 +40569,7 @@ var require_tracestate_impl = __commonJS((exports) => {
     _parse(rawTraceState) {
       if (rawTraceState.length > MAX_TRACE_STATE_LEN)
         return;
-      this._internalState = rawTraceState.split(LIST_MEMBERS_SEPARATOR).reduceRight((agg, part) => {
+      this._internalState = rawTraceState.split(LIST_MEMBERS_SEPARATOR).reverse().reduce((agg, part) => {
         const listMember = part.trim();
         const i = listMember.indexOf(LIST_MEMBER_KEY_VALUE_SPLITTER);
         if (i !== -1) {
@@ -41226,10 +41669,7 @@ function convertToLanguageModelMessage({
                 type: "tool-result",
                 toolCallId: part.toolCallId,
                 toolName: part.toolName,
-                output: mapToolResultOutput({
-                  output: part.output,
-                  downloadedAssets
-                }),
+                output: mapToolResultOutput(part.output),
                 providerOptions
               };
             }
@@ -41248,10 +41688,7 @@ function convertToLanguageModelMessage({
                 type: "tool-result",
                 toolCallId: part.toolCallId,
                 toolName: part.toolName,
-                output: mapToolResultOutput({
-                  output: part.output,
-                  downloadedAssets
-                }),
+                output: mapToolResultOutput(part.output),
                 providerOptions: part.providerOptions
               };
             }
@@ -41275,44 +41712,15 @@ function convertToLanguageModelMessage({
   }
 }
 async function downloadAssets(messages, download2, supportedUrls) {
-  var _a21;
-  const downloadableFiles = [];
-  for (const message of messages) {
-    if (message.role === "user" && Array.isArray(message.content)) {
-      for (const part of message.content) {
-        if (part.type === "image" || part.type === "file") {
-          downloadableFiles.push({
-            data: part.type === "image" ? part.image : part.data,
-            mediaType: (_a21 = part.mediaType) != null ? _a21 : part.type === "image" ? "image/*" : undefined
-          });
-        }
-      }
-    }
-    if (message.role === "tool" || message.role === "assistant") {
-      if (!Array.isArray(message.content)) {
-        continue;
-      }
-      for (const part of message.content) {
-        if (part.type !== "tool-result") {
-          continue;
-        }
-        if (part.output.type !== "content") {
-          continue;
-        }
-        for (const contentPart of part.output.value) {
-          if (contentPart.type === "image-url" || contentPart.type === "file-url") {
-            downloadableFiles.push({
-              data: new URL(contentPart.url),
-              mediaType: contentPart.type === "image-url" ? "image/*" : undefined
-            });
-          }
-        }
-      }
+  const plannedDownloads = messages.filter((message) => message.role === "user").map((message) => message.content).filter((content) => Array.isArray(content)).flat().filter((part) => part.type === "image" || part.type === "file").map((part) => {
+    var _a21;
+    const mediaType = (_a21 = part.mediaType) != null ? _a21 : part.type === "image" ? "image/*" : undefined;
+    let data = part.type === "image" ? part.image : part.data;
+    if (typeof data === "string") {
+      try {
+        data = new URL(data);
+      } catch (ignored) {}
     }
-  }
-  const plannedDownloads = downloadableFiles.map((part) => {
-    const mediaType = part.mediaType;
-    const { data } = convertToLanguageModelV3DataContent(part.data);
     return { mediaType, data };
   }).filter((part) => part.data instanceof URL).map((part) => ({
     url: part.data,
@@ -41386,41 +41794,13 @@ function convertPartToLanguageModelPart(part, downloadedAssets) {
     }
   }
 }
-function mapToolResultOutput({
-  output,
-  downloadedAssets
-}) {
+function mapToolResultOutput(output) {
   if (output.type !== "content") {
     return output;
   }
   return {
     type: "content",
     value: output.value.map((item) => {
-      var _a21, _b16;
-      if (item.type === "image-url") {
-        const downloadedFile = downloadedAssets[new URL(item.url).toString()];
-        if (downloadedFile) {
-          return {
-            type: "image-data",
-            data: convertDataContentToBase64String(downloadedFile.data),
-            mediaType: (_a21 = downloadedFile.mediaType) != null ? _a21 : "image/*",
-            providerOptions: item.providerOptions
-          };
-        }
-        return item;
-      }
-      if (item.type === "file-url") {
-        const downloadedFile = downloadedAssets[new URL(item.url).toString()];
-        if (downloadedFile) {
-          return {
-            type: "file-data",
-            data: convertDataContentToBase64String(downloadedFile.data),
-            mediaType: (_b16 = downloadedFile.mediaType) != null ? _b16 : "application/octet-stream",
-            providerOptions: item.providerOptions
-          };
-        }
-        return item;
-      }
       if (item.type !== "media") {
         return item;
       }
@@ -41973,7 +42353,7 @@ function getRetryDelayInMs({
   error: error40,
   exponentialBackoffDelay
 }) {
-  const headers = APICallError.isInstance(error40) ? error40.responseHeaders : APICallError.isInstance(error40.cause) ? error40.cause.responseHeaders : undefined;
+  const headers = error40.responseHeaders;
   if (!headers)
     return exponentialBackoffDelay;
   let ms;
@@ -42023,7 +42403,7 @@ async function _retryWithExponentialBackoff(f, {
         errors: newErrors
       });
     }
-    if (error40 instanceof Error && (APICallError.isInstance(error40) && error40.isRetryable === true || GatewayError.isInstance(error40) && error40.isRetryable === true) && tryNumber <= maxRetries) {
+    if (error40 instanceof Error && APICallError.isInstance(error40) && error40.isRetryable === true && tryNumber <= maxRetries) {
       await delay(getRetryDelayInMs({
         error: error40,
         exponentialBackoffDelay: delayInMs
@@ -42241,8 +42621,7 @@ async function executeToolCall({
           input,
           error: error40,
           dynamic: tool2.type === "dynamic",
-          ...toolCall.providerMetadata != null ? { providerMetadata: toolCall.providerMetadata } : {},
-          ...toolCall.toolMetadata != null ? { toolMetadata: toolCall.toolMetadata } : {}
+          ...toolCall.providerMetadata != null ? { providerMetadata: toolCall.providerMetadata } : {}
         };
       }
       const durationMs = now2() - startTime;
@@ -42272,8 +42651,7 @@ async function executeToolCall({
         input,
         output,
         dynamic: tool2.type === "dynamic",
-        ...toolCall.providerMetadata != null ? { providerMetadata: toolCall.providerMetadata } : {},
-        ...toolCall.toolMetadata != null ? { toolMetadata: toolCall.toolMetadata } : {}
+        ...toolCall.providerMetadata != null ? { providerMetadata: toolCall.providerMetadata } : {}
       };
     }
   });
@@ -42638,6 +43016,15 @@ async function parsePartialJson(jsonText) {
   }
   return { value: undefined, state: "failed-parse" };
 }
+function mergeToolProviderMetadata(toolMetadata, callMetadata) {
+  if (toolMetadata == null) {
+    return callMetadata;
+  }
+  if (callMetadata == null) {
+    return toolMetadata;
+  }
+  return { ...toolMetadata, ...callMetadata };
+}
 async function parseToolCall({
   toolCall,
   tools,
@@ -42645,6 +43032,7 @@ async function parseToolCall({
   system,
   messages
 }) {
+  var _a21, _b16;
   try {
     if (tools == null) {
       if (toolCall.providerExecuted && toolCall.dynamic) {
@@ -42685,7 +43073,6 @@ async function parseToolCall({
   } catch (error40) {
     const parsedInput = await safeParseJSON({ text: toolCall.input });
     const input = parsedInput.success ? parsedInput.value : toolCall.input;
-    const tool2 = tools == null ? undefined : tools[toolCall.toolName];
     return {
       type: "tool-call",
       toolCallId: toolCall.toolCallId,
@@ -42694,10 +43081,9 @@ async function parseToolCall({
       dynamic: true,
       invalid: true,
       error: error40,
-      title: tool2 == null ? undefined : tool2.title,
+      title: (_a21 = tools == null ? undefined : tools[toolCall.toolName]) == null ? undefined : _a21.title,
       providerExecuted: toolCall.providerExecuted,
-      providerMetadata: toolCall.providerMetadata,
-      ...(tool2 == null ? undefined : tool2.metadata) != null ? { toolMetadata: tool2.metadata } : {}
+      providerMetadata: mergeToolProviderMetadata((_b16 = tools == null ? undefined : tools[toolCall.toolName]) == null ? undefined : _b16.providerMetadata, toolCall.providerMetadata)
     };
   }
 }
@@ -42744,14 +43130,14 @@ async function doParseToolCall({
       cause: parseResult.error
     });
   }
+  const mergedProviderMetadata = mergeToolProviderMetadata(tool2.providerMetadata, toolCall.providerMetadata);
   return tool2.type === "dynamic" ? {
     type: "tool-call",
     toolCallId: toolCall.toolCallId,
     toolName: toolCall.toolName,
     input: parseResult.value,
     providerExecuted: toolCall.providerExecuted,
-    providerMetadata: toolCall.providerMetadata,
-    ...tool2.metadata != null ? { toolMetadata: tool2.metadata } : {},
+    providerMetadata: mergedProviderMetadata,
     dynamic: true,
     title: tool2.title
   } : {
@@ -42760,8 +43146,7 @@ async function doParseToolCall({
     toolName,
     input: parseResult.value,
     providerExecuted: toolCall.providerExecuted,
-    providerMetadata: toolCall.providerMetadata,
-    ...tool2.metadata != null ? { toolMetadata: tool2.metadata } : {},
+    providerMetadata: mergedProviderMetadata,
     title: tool2.title
   };
 }
@@ -43593,8 +43978,7 @@ function asContent({
               error: part.result,
               providerExecuted: true,
               dynamic: part.dynamic,
-              ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {},
-              ...(tool2 == null ? undefined : tool2.metadata) != null ? { toolMetadata: tool2.metadata } : {}
+              ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
             });
           } else {
             contentParts.push({
@@ -43605,8 +43989,7 @@ function asContent({
               output: part.result,
               providerExecuted: true,
               dynamic: part.dynamic,
-              ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {},
-              ...(tool2 == null ? undefined : tool2.metadata) != null ? { toolMetadata: tool2.metadata } : {}
+              ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
             });
           }
           break;
@@ -43620,8 +44003,7 @@ function asContent({
             error: part.result,
             providerExecuted: true,
             dynamic: toolCall.dynamic,
-            ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {},
-            ...toolCall.toolMetadata != null ? { toolMetadata: toolCall.toolMetadata } : {}
+            ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
           });
         } else {
           contentParts.push({
@@ -43632,8 +44014,7 @@ function asContent({
             output: part.result,
             providerExecuted: true,
             dynamic: toolCall.dynamic,
-            ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {},
-            ...toolCall.toolMetadata != null ? { toolMetadata: toolCall.toolMetadata } : {}
+            ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
           });
         }
         break;
@@ -43847,9 +44228,6 @@ function processUIMessageStream({
             if (options.title !== undefined) {
               anyPart.title = options.title;
             }
-            if (options.toolMetadata !== undefined) {
-              anyPart.toolMetadata = options.toolMetadata;
-            }
             anyPart.providerExecuted = (_a222 = anyOptions.providerExecuted) != null ? _a222 : part.providerExecuted;
             const providerMetadata = anyOptions.providerMetadata;
             if (providerMetadata != null) {
@@ -43866,7 +44244,6 @@ function processUIMessageStream({
               toolCallId: options.toolCallId,
               state: options.state,
               title: options.title,
-              ...options.toolMetadata !== undefined ? { toolMetadata: options.toolMetadata } : {},
               input: anyOptions.input,
               output: anyOptions.output,
               rawInput: anyOptions.rawInput,
@@ -43894,9 +44271,6 @@ function processUIMessageStream({
             if (options.title !== undefined) {
               anyPart.title = options.title;
             }
-            if (options.toolMetadata !== undefined) {
-              anyPart.toolMetadata = options.toolMetadata;
-            }
             anyPart.providerExecuted = (_b23 = anyOptions.providerExecuted) != null ? _b23 : part.providerExecuted;
             const providerMetadata = anyOptions.providerMetadata;
             if (providerMetadata != null) {
@@ -43919,7 +44293,6 @@ function processUIMessageStream({
               preliminary: anyOptions.preliminary,
               providerExecuted: anyOptions.providerExecuted,
               title: options.title,
-              ...options.toolMetadata !== undefined ? { toolMetadata: options.toolMetadata } : {},
               ...anyOptions.providerMetadata != null && (options.state === "output-available" || options.state === "output-error") ? { resultProviderMetadata: anyOptions.providerMetadata } : {},
               ...anyOptions.providerMetadata != null && !(options.state === "output-available" || options.state === "output-error") ? { callProviderMetadata: anyOptions.providerMetadata } : {}
             });
@@ -44064,8 +44437,7 @@ function processUIMessageStream({
               toolName: chunk.toolName,
               index: toolInvocations.length,
               dynamic: chunk.dynamic,
-              title: chunk.title,
-              toolMetadata: chunk.toolMetadata
+              title: chunk.title
             };
             if (chunk.dynamic) {
               updateDynamicToolPart({
@@ -44075,7 +44447,6 @@ function processUIMessageStream({
                 input: undefined,
                 providerExecuted: chunk.providerExecuted,
                 title: chunk.title,
-                toolMetadata: chunk.toolMetadata,
                 providerMetadata: chunk.providerMetadata
               });
             } else {
@@ -44086,7 +44457,6 @@ function processUIMessageStream({
                 input: undefined,
                 providerExecuted: chunk.providerExecuted,
                 title: chunk.title,
-                toolMetadata: chunk.toolMetadata,
                 providerMetadata: chunk.providerMetadata
               });
             }
@@ -44110,8 +44480,7 @@ function processUIMessageStream({
                 toolName: partialToolCall.toolName,
                 state: "input-streaming",
                 input: partialArgs,
-                title: partialToolCall.title,
-                toolMetadata: partialToolCall.toolMetadata
+                title: partialToolCall.title
               });
             } else {
               updateToolPart({
@@ -44119,8 +44488,7 @@ function processUIMessageStream({
                 toolName: partialToolCall.toolName,
                 state: "input-streaming",
                 input: partialArgs,
-                title: partialToolCall.title,
-                toolMetadata: partialToolCall.toolMetadata
+                title: partialToolCall.title
               });
             }
             write();
@@ -44135,8 +44503,7 @@ function processUIMessageStream({
                 input: chunk.input,
                 providerExecuted: chunk.providerExecuted,
                 providerMetadata: chunk.providerMetadata,
-                title: chunk.title,
-                toolMetadata: chunk.toolMetadata
+                title: chunk.title
               });
             } else {
               updateToolPart({
@@ -44146,8 +44513,7 @@ function processUIMessageStream({
                 input: chunk.input,
                 providerExecuted: chunk.providerExecuted,
                 providerMetadata: chunk.providerMetadata,
-                title: chunk.title,
-                toolMetadata: chunk.toolMetadata
+                title: chunk.title
               });
             }
             write();
@@ -44169,8 +44535,7 @@ function processUIMessageStream({
                 input: chunk.input,
                 errorText: chunk.errorText,
                 providerExecuted: chunk.providerExecuted,
-                providerMetadata: chunk.providerMetadata,
-                toolMetadata: chunk.toolMetadata
+                providerMetadata: chunk.providerMetadata
               });
             } else {
               updateToolPart({
@@ -44181,8 +44546,7 @@ function processUIMessageStream({
                 rawInput: chunk.input,
                 errorText: chunk.errorText,
                 providerExecuted: chunk.providerExecuted,
-                providerMetadata: chunk.providerMetadata,
-                toolMetadata: chunk.toolMetadata
+                providerMetadata: chunk.providerMetadata
               });
             }
             write();
@@ -44213,8 +44577,7 @@ function processUIMessageStream({
                 preliminary: chunk.preliminary,
                 providerExecuted: chunk.providerExecuted,
                 providerMetadata: chunk.providerMetadata,
-                title: toolInvocation.title,
-                toolMetadata: toolInvocation.toolMetadata
+                title: toolInvocation.title
               });
             } else {
               updateToolPart({
@@ -44226,8 +44589,7 @@ function processUIMessageStream({
                 providerExecuted: chunk.providerExecuted,
                 preliminary: chunk.preliminary,
                 providerMetadata: chunk.providerMetadata,
-                title: toolInvocation.title,
-                toolMetadata: toolInvocation.toolMetadata
+                title: toolInvocation.title
               });
             }
             write();
@@ -44244,8 +44606,7 @@ function processUIMessageStream({
                 errorText: chunk.errorText,
                 providerExecuted: chunk.providerExecuted,
                 providerMetadata: chunk.providerMetadata,
-                title: toolInvocation.title,
-                toolMetadata: toolInvocation.toolMetadata
+                title: toolInvocation.title
               });
             } else {
               updateToolPart({
@@ -44257,8 +44618,7 @@ function processUIMessageStream({
                 errorText: chunk.errorText,
                 providerExecuted: chunk.providerExecuted,
                 providerMetadata: chunk.providerMetadata,
-                title: toolInvocation.title,
-                toolMetadata: toolInvocation.toolMetadata
+                title: toolInvocation.title
               });
             }
             write();
@@ -44716,8 +45076,7 @@ function runToolsTransformation({
                 input: toolCall.input,
                 error: getErrorMessage2(toolCall.error),
                 dynamic: true,
-                title: toolCall.title,
-                ...toolCall.toolMetadata != null ? { toolMetadata: toolCall.toolMetadata } : {}
+                title: toolCall.title
               });
               break;
             }
@@ -44785,7 +45144,6 @@ function runToolsTransformation({
         }
         case "tool-result": {
           const toolName = chunk.toolName;
-          const toolCall = toolCallsByToolCallId.get(chunk.toolCallId);
           if (chunk.isError) {
             toolResultsStreamController.enqueue({
               type: "tool-error",
@@ -44795,8 +45153,7 @@ function runToolsTransformation({
               providerExecuted: true,
               error: chunk.result,
               dynamic: chunk.dynamic,
-              ...chunk.providerMetadata != null ? { providerMetadata: chunk.providerMetadata } : {},
-              ...(toolCall == null ? undefined : toolCall.toolMetadata) != null ? { toolMetadata: toolCall.toolMetadata } : {}
+              ...chunk.providerMetadata != null ? { providerMetadata: chunk.providerMetadata } : {}
             });
           } else {
             controller.enqueue({
@@ -44807,8 +45164,7 @@ function runToolsTransformation({
               output: chunk.result,
               providerExecuted: true,
               dynamic: chunk.dynamic,
-              ...chunk.providerMetadata != null ? { providerMetadata: chunk.providerMetadata } : {},
-              ...(toolCall == null ? undefined : toolCall.toolMetadata) != null ? { toolMetadata: toolCall.toolMetadata } : {}
+              ...chunk.providerMetadata != null ? { providerMetadata: chunk.providerMetadata } : {}
             });
           }
           break;
@@ -45591,7 +45947,7 @@ async function embed({
         }),
         tracer,
         fn: async (doEmbedSpan) => {
-          var _a21, _b16;
+          var _a21;
           const modelResponse = await model.doEmbed({
             values: [value],
             abortSignal,
@@ -45612,7 +45968,7 @@ async function embed({
           return {
             embedding: embedding2,
             usage: usage2,
-            warnings: (_b16 = modelResponse.warnings) != null ? _b16 : [],
+            warnings: modelResponse.warnings,
             providerMetadata: modelResponse.providerMetadata,
             response: modelResponse.response
           };
@@ -45708,7 +46064,7 @@ async function embedMany({
             }),
             tracer,
             fn: async (doEmbedSpan) => {
-              var _a222, _b16;
+              var _a222;
               const modelResponse = await model.doEmbed({
                 values,
                 abortSignal,
@@ -45729,7 +46085,7 @@ async function embedMany({
               return {
                 embeddings: embeddings3,
                 usage: usage2,
-                warnings: (_b16 = modelResponse.warnings) != null ? _b16 : [],
+                warnings: modelResponse.warnings,
                 providerMetadata: modelResponse.providerMetadata,
                 response: modelResponse.response
               };
@@ -45786,7 +46142,7 @@ async function embedMany({
               }),
               tracer,
               fn: async (doEmbedSpan) => {
-                var _a222, _b16;
+                var _a222;
                 const modelResponse = await model.doEmbed({
                   values: chunk,
                   abortSignal,
@@ -45807,7 +46163,7 @@ async function embedMany({
                 return {
                   embeddings: embeddings2,
                   usage,
-                  warnings: (_b16 = modelResponse.warnings) != null ? _b16 : [],
+                  warnings: modelResponse.warnings,
                   providerMetadata: modelResponse.providerMetadata,
                   response: modelResponse.response
                 };
@@ -47921,7 +48277,7 @@ var import_api2, import_api3, __defProp3, __export3 = (target, all) => {
   const bytes = typeof data === "string" ? convertBase64ToUint8Array(data) : data;
   const id3Size = (bytes[6] & 127) << 21 | (bytes[7] & 127) << 14 | (bytes[8] & 127) << 7 | bytes[9] & 127;
   return bytes.slice(id3Size + 10);
-}, VERSION3 = "6.0.191", download = async ({
+}, VERSION3 = "6.0.175", download = async ({
   url: url2,
   maxBytes,
   abortSignal
@@ -48429,7 +48785,7 @@ var import_api2, import_api3, __defProp3, __export3 = (target, all) => {
     }
     return this._output;
   }
-}, JsonToSseTransformStream, UI_MESSAGE_STREAM_HEADERS, toolMetadataSchema, uiMessageChunkSchema, isToolOrDynamicToolUIPart, getToolOrDynamicToolName, originalGenerateId2, DefaultStreamTextResult = class {
+}, JsonToSseTransformStream, UI_MESSAGE_STREAM_HEADERS, uiMessageChunkSchema, isToolOrDynamicToolUIPart, getToolOrDynamicToolName, originalGenerateId2, DefaultStreamTextResult = class {
   constructor({
     model,
     telemetry,
@@ -49677,7 +50033,6 @@ var import_api2, import_api3, __defProp3, __export3 = (target, all) => {
               toolName: part.toolName,
               ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
               ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {},
-              ...part.toolMetadata != null ? { toolMetadata: part.toolMetadata } : {},
               ...dynamic != null ? { dynamic } : {},
               ...part.title != null ? { title: part.title } : {}
             });
@@ -49701,7 +50056,6 @@ var import_api2, import_api3, __defProp3, __export3 = (target, all) => {
                 input: part.input,
                 ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
                 ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {},
-                ...part.toolMetadata != null ? { toolMetadata: part.toolMetadata } : {},
                 ...dynamic != null ? { dynamic } : {},
                 errorText: onError(part.error),
                 ...part.title != null ? { title: part.title } : {}
@@ -49714,7 +50068,6 @@ var import_api2, import_api3, __defProp3, __export3 = (target, all) => {
                 input: part.input,
                 ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
                 ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {},
-                ...part.toolMetadata != null ? { toolMetadata: part.toolMetadata } : {},
                 ...dynamic != null ? { dynamic } : {},
                 ...part.title != null ? { title: part.title } : {}
               });
@@ -49737,7 +50090,6 @@ var import_api2, import_api3, __defProp3, __export3 = (target, all) => {
               output: part.output,
               ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
               ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {},
-              ...part.toolMetadata != null ? { toolMetadata: part.toolMetadata } : {},
               ...part.preliminary != null ? { preliminary: part.preliminary } : {},
               ...dynamic != null ? { dynamic } : {}
             });
@@ -49751,7 +50103,6 @@ var import_api2, import_api3, __defProp3, __export3 = (target, all) => {
               errorText: part.providerExecuted ? typeof part.error === "string" ? part.error : JSON.stringify(part.error) : onError(part.error),
               ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
               ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {},
-              ...part.toolMetadata != null ? { toolMetadata: part.toolMetadata } : {},
               ...dynamic != null ? { dynamic } : {}
             });
             break;
@@ -49925,21 +50276,10 @@ var import_api2, import_api3, __defProp3, __export3 = (target, all) => {
       ...options
     };
     const preparedCallArgs = (_d = await ((_c = (_b16 = this.settings).prepareCall) == null ? undefined : _c.call(_b16, baseCallArgs))) != null ? _d : baseCallArgs;
-    const {
-      instructions,
-      allowSystemInMessages,
-      messages,
-      prompt,
-      ...callArgs
-    } = preparedCallArgs;
+    const { instructions, messages, prompt, ...callArgs } = preparedCallArgs;
     return {
       ...callArgs,
-      ...{
-        system: instructions,
-        allowSystemInMessages,
-        messages,
-        prompt
-      }
+      ...{ system: instructions, messages, prompt }
     };
   }
   mergeOnStepFinishCallbacks(methodCallback) {
@@ -49980,7 +50320,7 @@ var import_api2, import_api3, __defProp3, __export3 = (target, all) => {
       onStepFinish: this.mergeOnStepFinishCallbacks(onStepFinish)
     });
   }
-}, toolMetadataSchema2, uiMessagesSchema, DefaultEmbedResult = class {
+}, uiMessagesSchema, DefaultEmbedResult = class {
   constructor(options) {
     this.value = options.value;
     this.embedding = options.embedding;
@@ -51488,7 +51828,6 @@ var init_dist6 = __esm(() => {
   init_dist5();
   init_dist2();
   init_dist2();
-  init_dist5();
   init_dist4();
   init_dist4();
   init_dist4();
@@ -52348,7 +52687,6 @@ var init_dist6 = __esm(() => {
     "x-vercel-ai-ui-message-stream": "v1",
     "x-accel-buffering": "no"
   };
-  toolMetadataSchema = exports_external3.record(exports_external3.string(), jsonValueSchema.optional());
   uiMessageChunkSchema = lazySchema(() => zodSchema(exports_external3.union([
     exports_external3.strictObject({
       type: exports_external3.literal("text-start"),
@@ -52376,7 +52714,6 @@ var init_dist6 = __esm(() => {
       toolName: exports_external3.string(),
       providerExecuted: exports_external3.boolean().optional(),
       providerMetadata: providerMetadataSchema.optional(),
-      toolMetadata: toolMetadataSchema.optional(),
       dynamic: exports_external3.boolean().optional(),
       title: exports_external3.string().optional()
     }),
@@ -52392,7 +52729,6 @@ var init_dist6 = __esm(() => {
       input: exports_external3.unknown(),
       providerExecuted: exports_external3.boolean().optional(),
       providerMetadata: providerMetadataSchema.optional(),
-      toolMetadata: toolMetadataSchema.optional(),
       dynamic: exports_external3.boolean().optional(),
       title: exports_external3.string().optional()
     }),
@@ -52403,7 +52739,6 @@ var init_dist6 = __esm(() => {
       input: exports_external3.unknown(),
       providerExecuted: exports_external3.boolean().optional(),
       providerMetadata: providerMetadataSchema.optional(),
-      toolMetadata: toolMetadataSchema.optional(),
       dynamic: exports_external3.boolean().optional(),
       errorText: exports_external3.string(),
       title: exports_external3.string().optional()
@@ -52419,7 +52754,6 @@ var init_dist6 = __esm(() => {
       output: exports_external3.unknown(),
       providerExecuted: exports_external3.boolean().optional(),
       providerMetadata: providerMetadataSchema.optional(),
-      toolMetadata: toolMetadataSchema.optional(),
       dynamic: exports_external3.boolean().optional(),
       preliminary: exports_external3.boolean().optional()
     }),
@@ -52429,7 +52763,6 @@ var init_dist6 = __esm(() => {
       errorText: exports_external3.string(),
       providerExecuted: exports_external3.boolean().optional(),
       providerMetadata: providerMetadataSchema.optional(),
-      toolMetadata: toolMetadataSchema.optional(),
       dynamic: exports_external3.boolean().optional()
     }),
     exports_external3.strictObject({
@@ -52517,7 +52850,6 @@ var init_dist6 = __esm(() => {
     prefix: "aitxt",
     size: 24
   });
-  toolMetadataSchema2 = exports_external3.record(exports_external3.string(), jsonValueSchema.optional());
   uiMessagesSchema = lazySchema(() => zodSchema(exports_external3.array(exports_external3.object({
     id: exports_external3.string(),
     role: exports_external3.enum(["system", "user", "assistant"]),
@@ -52569,7 +52901,6 @@ var init_dist6 = __esm(() => {
         type: exports_external3.literal("dynamic-tool"),
         toolName: exports_external3.string(),
         toolCallId: exports_external3.string(),
-        toolMetadata: toolMetadataSchema2.optional(),
         state: exports_external3.literal("input-streaming"),
         input: exports_external3.unknown().optional(),
         providerExecuted: exports_external3.boolean().optional(),
@@ -52582,7 +52913,6 @@ var init_dist6 = __esm(() => {
         type: exports_external3.literal("dynamic-tool"),
         toolName: exports_external3.string(),
         toolCallId: exports_external3.string(),
-        toolMetadata: toolMetadataSchema2.optional(),
         state: exports_external3.literal("input-available"),
         input: exports_external3.unknown(),
         providerExecuted: exports_external3.boolean().optional(),
@@ -52595,7 +52925,6 @@ var init_dist6 = __esm(() => {
         type: exports_external3.literal("dynamic-tool"),
         toolName: exports_external3.string(),
         toolCallId: exports_external3.string(),
-        toolMetadata: toolMetadataSchema2.optional(),
         state: exports_external3.literal("approval-requested"),
         input: exports_external3.unknown(),
         providerExecuted: exports_external3.boolean().optional(),
@@ -52612,7 +52941,6 @@ var init_dist6 = __esm(() => {
         type: exports_external3.literal("dynamic-tool"),
         toolName: exports_external3.string(),
         toolCallId: exports_external3.string(),
-        toolMetadata: toolMetadataSchema2.optional(),
         state: exports_external3.literal("approval-responded"),
         input: exports_external3.unknown(),
         providerExecuted: exports_external3.boolean().optional(),
@@ -52629,7 +52957,6 @@ var init_dist6 = __esm(() => {
         type: exports_external3.literal("dynamic-tool"),
         toolName: exports_external3.string(),
         toolCallId: exports_external3.string(),
-        toolMetadata: toolMetadataSchema2.optional(),
         state: exports_external3.literal("output-available"),
         input: exports_external3.unknown(),
         providerExecuted: exports_external3.boolean().optional(),
@@ -52648,9 +52975,8 @@ var init_dist6 = __esm(() => {
         type: exports_external3.literal("dynamic-tool"),
         toolName: exports_external3.string(),
         toolCallId: exports_external3.string(),
-        toolMetadata: toolMetadataSchema2.optional(),
         state: exports_external3.literal("output-error"),
-        input: exports_external3.unknown().optional(),
+        input: exports_external3.unknown(),
         rawInput: exports_external3.unknown().optional(),
         providerExecuted: exports_external3.boolean().optional(),
         output: exports_external3.never().optional(),
@@ -52667,7 +52993,6 @@ var init_dist6 = __esm(() => {
         type: exports_external3.literal("dynamic-tool"),
         toolName: exports_external3.string(),
         toolCallId: exports_external3.string(),
-        toolMetadata: toolMetadataSchema2.optional(),
         state: exports_external3.literal("output-denied"),
         input: exports_external3.unknown(),
         providerExecuted: exports_external3.boolean().optional(),
@@ -52683,7 +53008,6 @@ var init_dist6 = __esm(() => {
       exports_external3.object({
         type: exports_external3.string().startsWith("tool-"),
         toolCallId: exports_external3.string(),
-        toolMetadata: toolMetadataSchema2.optional(),
         state: exports_external3.literal("input-streaming"),
         providerExecuted: exports_external3.boolean().optional(),
         callProviderMetadata: providerMetadataSchema.optional(),
@@ -52695,7 +53019,6 @@ var init_dist6 = __esm(() => {
       exports_external3.object({
         type: exports_external3.string().startsWith("tool-"),
         toolCallId: exports_external3.string(),
-        toolMetadata: toolMetadataSchema2.optional(),
         state: exports_external3.literal("input-available"),
         providerExecuted: exports_external3.boolean().optional(),
         input: exports_external3.unknown(),
@@ -52707,7 +53030,6 @@ var init_dist6 = __esm(() => {
       exports_external3.object({
         type: exports_external3.string().startsWith("tool-"),
         toolCallId: exports_external3.string(),
-        toolMetadata: toolMetadataSchema2.optional(),
         state: exports_external3.literal("approval-requested"),
         input: exports_external3.unknown(),
         providerExecuted: exports_external3.boolean().optional(),
@@ -52723,7 +53045,6 @@ var init_dist6 = __esm(() => {
       exports_external3.object({
         type: exports_external3.string().startsWith("tool-"),
         toolCallId: exports_external3.string(),
-        toolMetadata: toolMetadataSchema2.optional(),
         state: exports_external3.literal("approval-responded"),
         input: exports_external3.unknown(),
         providerExecuted: exports_external3.boolean().optional(),
@@ -52739,7 +53060,6 @@ var init_dist6 = __esm(() => {
       exports_external3.object({
         type: exports_external3.string().startsWith("tool-"),
         toolCallId: exports_external3.string(),
-        toolMetadata: toolMetadataSchema2.optional(),
         state: exports_external3.literal("output-available"),
         providerExecuted: exports_external3.boolean().optional(),
         input: exports_external3.unknown(),
@@ -52757,10 +53077,9 @@ var init_dist6 = __esm(() => {
       exports_external3.object({
         type: exports_external3.string().startsWith("tool-"),
         toolCallId: exports_external3.string(),
-        toolMetadata: toolMetadataSchema2.optional(),
         state: exports_external3.literal("output-error"),
         providerExecuted: exports_external3.boolean().optional(),
-        input: exports_external3.unknown().optional(),
+        input: exports_external3.unknown(),
         rawInput: exports_external3.unknown().optional(),
         output: exports_external3.never().optional(),
         errorText: exports_external3.string(),
@@ -52775,7 +53094,6 @@ var init_dist6 = __esm(() => {
       exports_external3.object({
         type: exports_external3.string().startsWith("tool-"),
         toolCallId: exports_external3.string(),
-        toolMetadata: toolMetadataSchema2.optional(),
         state: exports_external3.literal("output-denied"),
         providerExecuted: exports_external3.boolean().optional(),
         input: exports_external3.unknown(),
@@ -53265,54 +53583,52 @@ import { promises as fsPromises } from "fs";
 import { createHash, createPrivateKey, createPublicKey, sign } from "crypto";
 import { promises as fs2 } from "fs";
 import { homedir as homedir22 } from "os";
-import { dirname as dirname3, join as join62 } from "path";
+import { dirname as dirname3, join as join52 } from "path";
 import { exec } from "child_process";
 import { promisify } from "util";
-import { readFileSync as readFileSync4 } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 import { webcrypto as crypto2 } from "crypto";
-import { existsSync as existsSync5, writeFileSync as writeFileSync4, readFileSync as readFileSync3, mkdirSync as mkdirSync32 } from "fs";
-import { join as join52 } from "path";
+import { existsSync as existsSync42, writeFileSync as writeFileSync32, readFileSync as readFileSync22, mkdirSync as mkdirSync32 } from "fs";
+import { join as join42 } from "path";
 import { Database as Database4 } from "bun:sqlite";
 import { existsSync as existsSync11, mkdirSync as mkdirSync9 } from "fs";
-import { dirname as dirname4, join as join14, resolve as resolve2 } from "path";
-import { existsSync as existsSync22, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname4, join as join15, resolve as resolve2 } from "path";
+import { existsSync as existsSync22, writeFileSync as writeFileSync4 } from "fs";
 import { join as join22 } from "path";
-import { execFileSync } from "child_process";
-import { writeFileSync as writeFileSync22, existsSync as existsSync32, readFileSync as readFileSync5 } from "fs";
-import { join as join32 } from "path";
-import { hostname as hostname3 } from "os";
-import { existsSync as existsSync42, readFileSync as readFileSync22, writeFileSync as writeFileSync32, mkdirSync as mkdirSync22 } from "fs";
+import { execSync as execSync2, execFileSync } from "child_process";
+import { existsSync as existsSync32, readFileSync as readFileSync4, writeFileSync as writeFileSync22, mkdirSync as mkdirSync22 } from "fs";
 import { homedir as homedir11 } from "os";
-import { join as join42, dirname as dirname22 } from "path";
+import { join as join32, dirname as dirname22 } from "path";
+import { hostname as hostname3 } from "os";
 import { Buffer as Buffer2 } from "buffer";
 import * as zlib from "zlib";
 import { Readable } from "stream";
 import { Writable } from "stream";
 import { createHash as createHash2 } from "crypto";
-import { mkdirSync as mkdirSync4, statSync, writeFileSync as writeFileSync5 } from "fs";
-import { dirname as dirname42, join as join72, relative as relative2 } from "path";
+import { mkdirSync as mkdirSync4, statSync, writeFileSync as writeFileSync42 } from "fs";
+import { dirname as dirname42, join as join62, relative as relative2 } from "path";
 import { readdir, readFile as readFile2 } from "fs/promises";
-import { existsSync as existsSync72, readdirSync as readdirSync3, readFileSync as readFileSync52, statSync as statSync2 } from "fs";
-import { basename, join as join82, resolve as resolve22 } from "path";
+import { existsSync as existsSync62, readdirSync as readdirSync3, readFileSync as readFileSync42, statSync as statSync2 } from "fs";
+import { basename, join as join72, resolve as resolve22 } from "path";
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync82, readFileSync as readFileSync6, writeFileSync as writeFileSync6, mkdirSync as mkdirSync52 } from "fs";
-import { dirname as dirname5, join as join92 } from "path";
+import { existsSync as existsSync72, readFileSync as readFileSync5, writeFileSync as writeFileSync5, mkdirSync as mkdirSync52 } from "fs";
+import { dirname as dirname5, join as join82 } from "path";
 import { execFileSync as execFileSync4 } from "child_process";
-import { existsSync as existsSync112 } from "fs";
-import { join as join122 } from "path";
-import { execFileSync as execFileSync3 } from "child_process";
-import { existsSync as existsSync92 } from "fs";
-import { homedir as homedir32, hostname as hostname22, platform as platform2, type } from "os";
-import { join as join102 } from "path";
 import { existsSync as existsSync102 } from "fs";
-import { execSync as execSync2 } from "child_process";
 import { join as join112 } from "path";
+import { execFileSync as execFileSync3 } from "child_process";
+import { existsSync as existsSync82 } from "fs";
+import { homedir as homedir32, hostname as hostname22, platform as platform2, type } from "os";
+import { join as join92 } from "path";
+import { existsSync as existsSync92 } from "fs";
 import { execSync as execSync22 } from "child_process";
-import { readFileSync as readFileSync7 } from "fs";
+import { join as join102 } from "path";
+import { execSync as execSync3 } from "child_process";
+import { readFileSync as readFileSync6 } from "fs";
 import { mkdirSync as mkdirSync62 } from "fs";
-import { dirname as dirname6, join as join132 } from "path";
+import { dirname as dirname6, join as join122 } from "path";
 import { fileURLToPath } from "url";
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync112 } from "fs";
 function __accessProp3(key) {
   return this[key];
 }
@@ -53451,7 +53767,7 @@ function getDbPath2() {
     return process.env["PROJECTS_DB_PATH"];
   }
   const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
-  return join14(home, ".hasna", "projects", "projects.db");
+  return join15(home, ".hasna", "projects", "projects.db");
 }
 function ensureDir2(filePath) {
   if (filePath === ":memory:")
@@ -53489,25 +53805,14 @@ function uuid5() {
 function isGitRepo(path) {
   return existsSync22(join22(path, ".git"));
 }
-function getCurrentBranch(path) {
-  return execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
-    cwd: path,
-    stdio: "pipe",
-    encoding: "utf-8",
-    env: process.env
-  }).trim();
-}
-function bootstrapPathsToStage(path) {
-  return BOOTSTRAP_PATHS.filter((entry) => existsSync22(join22(path, entry)));
-}
 function gitInit(project) {
   const { path, name: name21, id, slug } = project;
   if (isGitRepo(path))
     return;
-  execFileSync("git", ["init", "-b", "main"], { cwd: path, stdio: "pipe", env: process.env });
+  execSync2("git init", { cwd: path, stdio: "pipe" });
   const gitignorePath = join22(path, ".gitignore");
   if (!existsSync22(gitignorePath)) {
-    writeFileSync3(gitignorePath, GITIGNORE_TEMPLATE, "utf-8");
+    writeFileSync4(gitignorePath, GITIGNORE_TEMPLATE, "utf-8");
   }
   const projectJson = {
     id,
@@ -53516,18 +53821,26 @@ function gitInit(project) {
     created_at: project.created_at,
     integrations: project.integrations ?? {}
   };
-  writeFileSync3(join22(path, ".project.json"), JSON.stringify(projectJson, null, 2) + `
+  writeFileSync4(join22(path, ".project.json"), JSON.stringify(projectJson, null, 2) + `
 `, "utf-8");
-  const staged = bootstrapPathsToStage(path);
-  if (staged.length === 0)
-    return;
-  execFileSync("git", ["add", ...staged], { cwd: path, stdio: "pipe", env: process.env });
-  execFileSync("git", ["commit", "-m", `chore: init project ${name21}`], {
+  execSync2("git add .gitignore .project.json", { cwd: path, stdio: "pipe" });
+  execSync2(`git commit -m "chore: init project ${name21}"`, {
     cwd: path,
     stdio: "pipe",
     env: { ...process.env, GIT_AUTHOR_NAME: "open-projects", GIT_COMMITTER_NAME: "open-projects" }
   });
 }
+function getConfig() {
+  if (existsSync32(CONFIG_PATH3)) {
+    try {
+      const user = JSON.parse(readFileSync4(CONFIG_PATH3, "utf-8"));
+      return { ...DEFAULTS, ...user };
+    } catch {
+      return { ...DEFAULTS };
+    }
+  }
+  return { ...DEFAULTS };
+}
 function rowToWorkdir(row) {
   return {
     ...row,
@@ -53571,176 +53884,6 @@ function removeWorkdir(projectId, path, db2) {
   const d = db2 || getDatabase2();
   d.run("DELETE FROM project_workdirs WHERE project_id = ? AND path = ?", [projectId, path]);
 }
-function markWorkdirGenerated(projectId, path, db2) {
-  const d = db2 || getDatabase2();
-  d.run("UPDATE project_workdirs SET claude_md_generated = 1, agents_md_generated = 1 WHERE project_id = ? AND path = ?", [projectId, path]);
-}
-function buildWorkdirList(workdirs, currentPath) {
-  return workdirs.map((w) => {
-    const isCurrent = w.path === currentPath;
-    const primary = w.is_primary ? " (primary)" : "";
-    const current = isCurrent ? " \u2190 you are here" : "";
-    return `- \`${w.path}\` [${w.label}]${primary}${current}  *(machine: ${w.machine_id})*`;
-  }).join(`
-`);
-}
-function claudeMdContent(project, workdir, allWorkdirs) {
-  const otherDirs = allWorkdirs.filter((w) => w.path !== workdir.path);
-  const otherSection = otherDirs.length ? `
-## Other Working Directories
-${buildWorkdirList(otherDirs, workdir.path)}
-` : "";
-  const integrations = Object.keys(project.integrations).length ? `
-## Integrations
-${Object.entries(project.integrations).filter(([, v]) => v).map(([k, v]) => `- **${k}:** \`${v}\``).join(`
-`)}
-` : "";
-  const tags = project.tags.length ? `
-**Tags:** ${project.tags.join(", ")}` : "";
-  return `# Project: ${project.name}
-
-> ${project.description ?? `Working directory for project **${project.name}**`}
-${tags}
-
-## Working Directory
-
-You are working in the **${workdir.label}** directory for this project:
-
-\`\`\`
-${workdir.path}
-\`\`\`
-
-**Write all code to this directory.** Do not write to other project directories unless explicitly instructed.
-
-## Project Metadata
-
-| Field | Value |
-|-------|-------|
-| ID | \`${project.id}\` |
-| Slug | \`${project.slug}\` |
-| Label | \`${workdir.label}\` |
-| Machine | \`${workdir.machine_id}\` |
-| Status | ${project.status} |
-${project.git_remote ? `| Git Remote | ${project.git_remote} |` : ""}
-${project.s3_bucket ? `| S3 Bucket | \`${project.s3_bucket}\` |` : ""}
-${integrations}${otherSection}
-## All Working Directories
-
-${buildWorkdirList(allWorkdirs, workdir.path)}
-
-## Instructions for AI Agents
-
-1. **Write code in \`${workdir.path}\`** \u2014 this is your working directory for this session.
-2. Use \`projects sync ${project.slug}\` to push changes to S3.
-3. Use \`projects git ${project.slug} <args>\` to run git commands.
-4. If you need to switch to a different workdir, call \`projects_open\` with the project ID.
-
----
-*Generated by open-projects. Regenerate: \`projects workdir generate ${project.slug}\`*
-`.trimStart();
-}
-function agentsMdContent(project, workdir, allWorkdirs) {
-  const otherDirs = allWorkdirs.filter((w) => w.path !== workdir.path);
-  return `---
-project_id: ${project.id}
-project_slug: ${project.slug}
-project_name: ${project.name}
-working_directory: ${workdir.path}
-label: ${workdir.label}
-machine_id: ${workdir.machine_id}
-is_primary: ${workdir.is_primary}
----
-
-# ${project.name} \u2014 Agent Instructions
-
-## Scope
-
-This agent session is scoped to the **${workdir.label}** working directory:
-
-\`\`\`
-${workdir.path}
-\`\`\`
-
-**Only write files inside this directory** unless the user explicitly asks you to work elsewhere.
-${otherDirs.length ? `
-## Other workdirs for this project
-
-${otherDirs.map((w) => `- \`${w.path}\` [${w.label}] on ${w.machine_id}`).join(`
-`)}
-` : ""}
-## Quick Reference
-
-\`\`\`bash
-# Open this project
-cd ${workdir.path}
-
-# Sync to S3
-projects sync ${project.slug}
-
-# Git operations
-projects git ${project.slug} status
-projects git ${project.slug} log --oneline -10
-\`\`\`
-${Object.keys(project.integrations).length ? `
-## Service IDs
-
-${Object.entries(project.integrations).filter(([, v]) => v).map(([k, v]) => `- **${k}:** \`${v}\``).join(`
-`)}
-` : ""}
----
-*Generated by open-projects ${new Date().toISOString().slice(0, 10)}*
-`.trimStart();
-}
-function generateForWorkdir(project, workdir, allWorkdirs, options = {}) {
-  const claudeMd = claudeMdContent(project, workdir, allWorkdirs);
-  const agentsMd = agentsMdContent(project, workdir, allWorkdirs);
-  const claudePath = join32(workdir.path, "CLAUDE.md");
-  const agentsPath = join32(workdir.path, "AGENTS.md");
-  let written = false;
-  if (!options.dryRun && existsSync32(workdir.path)) {
-    if (existsSync32(claudePath) && !options.force) {
-      const existing = readFileSync5(claudePath, "utf-8");
-      if (existing.includes("Generated by open-projects")) {
-        writeFileSync22(claudePath, claudeMd, "utf-8");
-      } else {
-        const separator = `
-
----
-
-<!-- open-projects -->
-`;
-        const marker21 = "<!-- open-projects -->";
-        if (existing.includes(marker21)) {
-          const before = existing.slice(0, existing.indexOf(marker21) - separator.length + 1);
-          writeFileSync22(claudePath, before + separator + claudeMd, "utf-8");
-        } else {
-          writeFileSync22(claudePath, existing.trimEnd() + separator + claudeMd, "utf-8");
-        }
-      }
-    } else {
-      writeFileSync22(claudePath, claudeMd, "utf-8");
-    }
-    writeFileSync22(agentsPath, agentsMd, "utf-8");
-    markWorkdirGenerated(project.id, workdir.path, options.db);
-    written = true;
-  }
-  return { path: workdir.path, claude_md: claudeMd, agents_md: agentsMd, written };
-}
-function generateAllWorkdirs(project, options = {}) {
-  const workdirs = listWorkdirs(project.id, options.db);
-  return workdirs.map((w) => generateForWorkdir(project, w, workdirs, options));
-}
-function getConfig() {
-  if (existsSync42(CONFIG_PATH3)) {
-    try {
-      const user = JSON.parse(readFileSync22(CONFIG_PATH3, "utf-8"));
-      return { ...DEFAULTS, ...user };
-    } catch {
-      return { ...DEFAULTS };
-    }
-  }
-  return { ...DEFAULTS };
-}
 function generateProjectId() {
   return `prj_${nanoid3()}`;
 }
@@ -53748,10 +53891,12 @@ function slugify2(name21) {
   return name21.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
 function scaffoldProject(path) {
+  if (existsSync42(path))
+    return;
   mkdirSync32(path, { recursive: true });
   const config2 = getConfig();
   for (const dir of config2.scaffold_dirs || ["data", "scripts", "assets", "docs"]) {
-    mkdirSync32(join52(path, dir), { recursive: true });
+    mkdirSync32(join42(path, dir), { recursive: true });
   }
 }
 function ensureUniqueSlug(base, db2, excludeId) {
@@ -53802,9 +53947,6 @@ function createProject2(input, db2) {
   try {
     addWorkdir({ project_id: id, path: input.path, label: "main", is_primary: true }, d);
   } catch {}
-  try {
-    generateAllWorkdirs(project, { db: d });
-  } catch {}
   const shouldGitInit = input.git_init !== false;
   if (shouldGitInit) {
     try {
@@ -53910,10 +54052,10 @@ function setIntegrations(id, integrations, db2) {
     id
   ]);
   try {
-    const jsonPath = join52(project.path, ".project.json");
-    if (existsSync5(jsonPath)) {
-      const existing = JSON.parse(readFileSync3(jsonPath, "utf-8"));
-      writeFileSync4(jsonPath, JSON.stringify({ ...existing, integrations: merged }, null, 2) + `
+    const jsonPath = join42(project.path, ".project.json");
+    if (existsSync42(jsonPath)) {
+      const existing = JSON.parse(readFileSync22(jsonPath, "utf-8"));
+      writeFileSync32(jsonPath, JSON.stringify({ ...existing, integrations: merged }, null, 2) + `
 `, "utf-8");
     }
   } catch {}
@@ -54987,7 +55129,7 @@ async function collectLocalFiles(rootPath) {
   async function walk(dir) {
     const entries = await readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join72(dir, entry.name);
+      const fullPath = join62(dir, entry.name);
       if (entry.isDirectory()) {
         await walk(fullPath);
       } else if (entry.isFile()) {
@@ -55059,7 +55201,7 @@ async function syncProject(project, options = {}) {
           continue;
         }
         try {
-          const data = await readFile2(join72(project.path, relPath));
+          const data = await readFile2(join62(project.path, relPath));
           await client.send(new PutObjectCommand({
             Bucket: bucket,
             Key: s3Key,
@@ -55097,9 +55239,9 @@ async function syncProject(project, options = {}) {
             chunks.push(chunk);
           }
           const data = Buffer.concat(chunks);
-          const localPath = join72(project.path, relPath);
+          const localPath = join62(project.path, relPath);
           mkdirSync4(dirname42(localPath), { recursive: true });
-          writeFileSync5(localPath, data);
+          writeFileSync42(localPath, data);
           log(`pull: ${relPath} (${data.length}B)`);
           result.pulled++;
           result.bytes += data.length;
@@ -55120,18 +55262,18 @@ async function syncProject(project, options = {}) {
   return result;
 }
 function inferProjectName(projectPath) {
-  const pkgPath = join82(projectPath, "package.json");
-  if (existsSync72(pkgPath)) {
+  const pkgPath = join72(projectPath, "package.json");
+  if (existsSync62(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync52(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync42(pkgPath, "utf-8"));
       if (pkg.name)
         return pkg.name.replace(/^@[^/]+\//, "");
     } catch {}
   }
-  const projPath = join82(projectPath, ".project.json");
-  if (existsSync72(projPath)) {
+  const projPath = join72(projectPath, ".project.json");
+  if (existsSync62(projPath)) {
     try {
-      const p2 = JSON.parse(readFileSync52(projPath, "utf-8"));
+      const p2 = JSON.parse(readFileSync42(projPath, "utf-8"));
       if (p2.name)
         return p2.name;
     } catch {}
@@ -55139,11 +55281,11 @@ function inferProjectName(projectPath) {
   return basename(projectPath);
 }
 function inferGitRemote(projectPath) {
-  const gitConfigPath = join82(projectPath, ".git", "config");
-  if (!existsSync72(gitConfigPath))
+  const gitConfigPath = join72(projectPath, ".git", "config");
+  if (!existsSync62(gitConfigPath))
     return;
   try {
-    const config2 = readFileSync52(gitConfigPath, "utf-8");
+    const config2 = readFileSync42(gitConfigPath, "utf-8");
     const match = config2.match(/\[remote "origin"\][\s\S]*?url\s*=\s*(.+)/);
     return match?.[1]?.trim();
   } catch {
@@ -55153,7 +55295,7 @@ function inferGitRemote(projectPath) {
 async function importProject(projectPath, options = {}) {
   const absPath = resolve22(projectPath);
   const log = options.onProgress ?? (() => {});
-  if (!existsSync72(absPath)) {
+  if (!existsSync62(absPath)) {
     return { error: `Path does not exist: ${absPath}` };
   }
   const stat = statSync2(absPath);
@@ -55188,7 +55330,7 @@ async function importBulk(dirPath, options = {}) {
   const absDir = resolve22(dirPath);
   const result = { imported: [], skipped: [], errors: [] };
   const log = options.onProgress ?? (() => {});
-  if (!existsSync72(absDir)) {
+  if (!existsSync62(absDir)) {
     result.errors.push({ path: absDir, error: "Directory does not exist" });
     return result;
   }
@@ -55196,7 +55338,7 @@ async function importBulk(dirPath, options = {}) {
   const dirs = entries.filter((e2) => e2.isDirectory() && !e2.name.startsWith("."));
   log(`Found ${dirs.length} subdirectories in ${absDir}`);
   for (const entry of dirs) {
-    const subPath = join82(absDir, entry.name);
+    const subPath = join72(absDir, entry.name);
     const res = await importProject(subPath, options);
     if (res.project) {
       result.imported.push(res.project);
@@ -55231,8 +55373,7 @@ function publishProject(name21, path, options = {}) {
       } else {
         execFileSync2("git", ["remote", "add", "origin", remote], { cwd: path, stdio: "pipe", env: process.env });
       }
-      const branch = getCurrentBranch(path);
-      execFileSync2("git", ["push", "-u", "origin", branch, "--quiet"], { cwd: path, stdio: "pipe", env: process.env });
+      execFileSync2("git", ["push", "-u", "origin", "main", "--quiet"], { cwd: path, stdio: "pipe", env: process.env });
       pushed = true;
     } catch {}
   }
@@ -55258,14 +55399,14 @@ function getGitHubUrl(path) {
   }
 }
 function getScheduleConfig() {
-  if (!existsSync82(CONFIG_PATH22)) {
+  if (!existsSync72(CONFIG_PATH22)) {
     return { enabled: false, interval: "daily", direction: "both" };
   }
-  return JSON.parse(readFileSync6(CONFIG_PATH22, "utf-8"));
+  return JSON.parse(readFileSync5(CONFIG_PATH22, "utf-8"));
 }
 function saveScheduleConfig(config2) {
   mkdirSync52(dirname5(CONFIG_PATH22), { recursive: true });
-  writeFileSync6(CONFIG_PATH22, JSON.stringify(config2, null, 2) + `
+  writeFileSync5(CONFIG_PATH22, JSON.stringify(config2, null, 2) + `
 `, "utf-8");
 }
 async function syncAll(direction = "both", onProgress) {
@@ -55295,7 +55436,7 @@ async function syncAll(direction = "both", onProgress) {
 function getMachineProfile() {
   const host = (process.env["HOSTNAME"] || hostname22()).split(".")[0] || hostname22();
   const currentPlatform = platform2();
-  const workspaceRoot = currentPlatform === "darwin" ? join102(homedir32(), "Workspace") : join102(homedir32(), "workspace");
+  const workspaceRoot = currentPlatform === "darwin" ? join92(homedir32(), "Workspace") : join92(homedir32(), "workspace");
   return {
     hostname: host,
     platform: currentPlatform,
@@ -55322,7 +55463,7 @@ function commandAvailability(command, versionArgs = ["--version"]) {
   return { command, available: true, path: commandPath, version: version2 };
 }
 function pathExists(path) {
-  return existsSync92(path);
+  return existsSync82(path);
 }
 function classifyMachine(host, currentPlatform) {
   if (host === "apple01")
@@ -55336,10 +55477,10 @@ function classifyMachine(host, currentPlatform) {
   return "unknown";
 }
 function gitStatus(path) {
-  if (!existsSync102(join112(path, ".git")))
+  if (!existsSync92(join102(path, ".git")))
     return "not a repo";
   try {
-    const out = execSync2("git status --porcelain", { cwd: path, stdio: "pipe", encoding: "utf-8" }).trim();
+    const out = execSync22("git status --porcelain", { cwd: path, stdio: "pipe", encoding: "utf-8" }).trim();
     if (!out)
       return "clean";
     const n2 = out.split(`
@@ -55350,17 +55491,17 @@ function gitStatus(path) {
   }
 }
 function dirSize(path) {
-  if (!existsSync102(path))
+  if (!existsSync92(path))
     return 0;
   try {
-    const out = execSync2(`du -sb -- "${path}" 2>/dev/null || du -sk -- "${path}" 2>/dev/null`, { stdio: "pipe", encoding: "utf-8" }).trim();
+    const out = execSync22(`du -sb -- "${path}" 2>/dev/null || du -sk -- "${path}" 2>/dev/null`, { stdio: "pipe", encoding: "utf-8" }).trim();
     return parseInt(out.split("\t")[0] ?? "0", 10);
   } catch {
     return 0;
   }
 }
 function getProjectStatus(project) {
-  const pathExists2 = existsSync102(project.path);
+  const pathExists2 = existsSync92(project.path);
   const workdirs = listWorkdirs(project.id);
   const lastSync = getDatabase2().query("SELECT completed_at FROM sync_log WHERE project_id = ? AND status = 'completed' ORDER BY completed_at DESC LIMIT 1").get(project.id)?.completed_at ?? null;
   return {
@@ -55373,21 +55514,18 @@ function getProjectStatus(project) {
   };
 }
 function run(cmd) {
-  return execSync22(cmd, { encoding: "utf-8", stdio: "pipe" }).trim();
+  return execSync3(cmd, { encoding: "utf-8", stdio: "pipe" }).trim();
 }
 function getTmuxSessionName(project) {
-  return project.slug || project.name;
+  const raw = project.slug || project.name;
+  if (project.path?.includes("opensourcedev")) {
+    const normalized = raw.replace(/^proj-/, "");
+    return normalized.startsWith("open-") ? normalized : `open-${normalized}`;
+  }
+  return raw;
 }
 function listSessions() {
-  let output = "";
-  try {
-    output = run("tmux list-sessions -F '#{session_name}:#{session_group}:#{session_windows}:#{session_attached}'");
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    if (message.includes("no server running"))
-      return [];
-    throw err;
-  }
+  const output = run("tmux list-sessions -F '#{session_name}:#{session_group}:#{session_windows}:#{session_attached}'");
   return output.split(`
 `).filter(Boolean).map((line) => {
     const [name21, group, windows, attached] = line.split(":");
@@ -55495,7 +55633,7 @@ function getProjectLocations(project) {
   const currentMachine = getMachineId();
   return listWorkdirs(project.id).map((workdir) => ({
     ...workdir,
-    exists: existsSync112(workdir.path),
+    exists: existsSync102(workdir.path),
     currentMachine: workdir.machine_id === currentMachine,
     recommended: workdir.is_primary || workdir.path === project.path
   }));
@@ -55532,7 +55670,7 @@ function buildProjectContext(project) {
   };
 }
 function getGitContext(path) {
-  if (!existsSync112(join122(path, ".git"))) {
+  if (!existsSync102(join112(path, ".git"))) {
     return { isRepo: false, branch: null, dirtyCount: null, remote: null };
   }
   return {
@@ -55575,7 +55713,7 @@ function setupMachineReport(options = {}) {
   const dryRun = options.dryRun !== false;
   const checks3 = [];
   const dbDir = dirname6(getDbPath2());
-  const cloudConfig = join132(process.env["HOME"] || "~", ".hasna", "cloud", "config.json");
+  const cloudConfig = join122(process.env["HOME"] || "~", ".hasna", "cloud", "config.json");
   checks3.push(pathCheck("PROJECTS_DATA_DIR", "projects data dir", dbDir, options));
   checks3.push(pathCheck("WORKSPACE_ROOT", "workspace root", machine.workspaceRoot, options));
   checks3.push(commandCheck("bun", ["--version"], "Bun runtime"));
@@ -55636,8 +55774,8 @@ function commandCheck(command, versionArgs, label, missingStatus = "error") {
 }
 function packageVersion() {
   try {
-    const pkgPath = join132(dirname6(fileURLToPath(import.meta.url)), "..", "..", "package.json");
-    return JSON.parse(readFileSync7(pkgPath, "utf-8")).version || "0.0.0";
+    const pkgPath = join122(dirname6(fileURLToPath(import.meta.url)), "..", "..", "package.json");
+    return JSON.parse(readFileSync6(pkgPath, "utf-8")).version || "0.0.0";
   } catch {
     return "0.0.0";
   }
@@ -55651,7 +55789,7 @@ function findStaleIssues(project) {
   const issues = [];
   const currentMachine = getMachineId();
   for (const p2 of projects) {
-    if (p2.status === "active" && !existsSync12(p2.path)) {
+    if (p2.status === "active" && !existsSync112(p2.path)) {
       issues.push({
         code: "PROJECT_PATH_MISSING",
         severity: "error",
@@ -55662,7 +55800,7 @@ function findStaleIssues(project) {
       });
     }
     for (const workdir of listWorkdirs(p2.id)) {
-      if (workdir.machine_id === currentMachine && !existsSync12(workdir.path)) {
+      if (workdir.machine_id === currentMachine && !existsSync112(workdir.path)) {
         issues.push({
           code: "WORKDIR_PATH_MISSING",
           severity: "warn",
@@ -56604,7 +56742,7 @@ Reference: https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sso.ht
   }
   const credentials = await fromWebToken({
     ...init,
-    webIdentityToken: import_shared_ini_file_loader10.externalDataInterceptor?.getTokenRecord?.()[webIdentityTokenFile] ?? readFileSync4(webIdentityTokenFile, { encoding: "ascii" }),
+    webIdentityToken: import_shared_ini_file_loader10.externalDataInterceptor?.getTokenRecord?.()[webIdentityTokenFile] ?? readFileSync3(webIdentityTokenFile, { encoding: "ascii" }),
     roleArn,
     roleSessionName
   })(awsIdentityProperties);
@@ -56691,7 +56829,7 @@ coverage/
 # Cache
 .cache/
 .turbo/
-`, BOOTSTRAP_PATHS, CONFIG_PATH3, DEFAULTS, nanoid3, import_protocol_http, addExpectContinueMiddlewareOptions, getAddExpectContinuePlugin = (options) => ({
+`, CONFIG_PATH3, DEFAULTS, nanoid3, import_protocol_http, addExpectContinueMiddlewareOptions, getAddExpectContinuePlugin = (options) => ({
   applyToStack: (clientStack) => {
     clientStack.add(addExpectContinueMiddleware(options), addExpectContinueMiddlewareOptions);
   }
@@ -69770,11 +69908,11 @@ More information can be found at: https://a.co/c895JFp`);
     var numberSelector = (obj, key, type2) => {
       if (!(key in obj))
         return;
-      const numberValue = parseInt(obj[key], 10);
-      if (Number.isNaN(numberValue)) {
+      const numberValue2 = parseInt(obj[key], 10);
+      if (Number.isNaN(numberValue2)) {
         throw new TypeError(`Cannot load ${type2} '${key}'. Expected number, got '${obj[key]}'.`);
       }
-      return numberValue;
+      return numberValue2;
     };
     exports.SelectorType = undefined;
     (function(SelectorType2) {
@@ -74502,7 +74640,7 @@ More information can be found at: https://a.co/c895JFp`);
     };
   });
   require_dist_cjs41 = __commonJS3((exports) => {
-    var __dirname2 = "/Users/hasna/Workspace/hasna/opensource/open-projects/node_modules/@aws-sdk/util-user-agent-node/dist-cjs";
+    var __dirname2 = "/home/hasna/workspace/hasna/opensource/open-projects/node_modules/@aws-sdk/util-user-agent-node/dist-cjs";
     var node_os = __require3("os");
     var node_process = __require3("process");
     var utilConfigProvider = require_dist_cjs28();
@@ -78172,10 +78310,10 @@ More information can be found at: https://a.co/c895JFp`);
         await fs2.writeFile(tokenFilePath, JSON.stringify(token, null, 2), "utf8");
       }
       getTokenFilePath() {
-        const directory = process.env.AWS_LOGIN_CACHE_DIRECTORY ?? join62(homedir22(), ".aws", "login", "cache");
+        const directory = process.env.AWS_LOGIN_CACHE_DIRECTORY ?? join52(homedir22(), ".aws", "login", "cache");
         const loginSessionBytes = Buffer.from(this.loginSession, "utf8");
         const loginSessionSha256 = createHash("sha256").update(loginSessionBytes).digest("hex");
-        return join62(directory, `${loginSessionSha256}.json`);
+        return join52(directory, `${loginSessionSha256}.json`);
       }
       derToRawSignature(derSignature) {
         let offset = 2;
@@ -78476,18 +78614,7 @@ More information can be found at: https://a.co/c895JFp`);
   INSERT OR IGNORE INTO _migrations (id) VALUES (4);
   `
   ];
-  BOOTSTRAP_PATHS = [
-    ".gitignore",
-    ".project.json",
-    "CLAUDE.md",
-    "AGENTS.md",
-    "README.md",
-    "docs",
-    "data",
-    "scripts",
-    "assets"
-  ];
-  CONFIG_PATH3 = join42(homedir11(), ".hasna", "projects", "config.json");
+  CONFIG_PATH3 = join32(homedir11(), ".hasna", "projects", "config.json");
   DEFAULTS = {
     default_path: process.cwd(),
     default_github_org: "hasnaxyz",
@@ -84273,7 +84400,7 @@ More information can be found at: https://a.co/c895JFp`);
   }).s("AmazonS3", "PutObject", {}).n("S3Client", "PutObjectCommand").sc(PutObject$).build() {
   };
   MAX_FILE_SIZE = 100 * 1024 * 1024;
-  CONFIG_PATH22 = join92(process.env["HOME"] || "~", ".hasna", "projects", "scheduler.json");
+  CONFIG_PATH22 = join82(process.env["HOME"] || "~", ".hasna", "projects", "scheduler.json");
   SPARK_MACHINES = new Set(["spark01", "spark02"]);
 });
 
@@ -85264,12 +85391,12 @@ __export(exports_contacts_connector, {
 });
 function getContactsDb() {
   const { Database: Database5 } = __require("bun:sqlite");
-  const { existsSync: existsSync13 } = __require("fs");
-  const { join: join15 } = __require("path");
+  const { existsSync: existsSync5 } = __require("fs");
+  const { join: join16 } = __require("path");
   const { homedir: homedir7 } = __require("os");
   const envPath = process.env["HASNA_CONTACTS_DB_PATH"] ?? process.env["OPEN_CONTACTS_DB"];
-  const dbPath = envPath ?? join15(homedir7(), ".hasna", "contacts", "contacts.db");
-  if (!existsSync13(dbPath))
+  const dbPath = envPath ?? join16(homedir7(), ".hasna", "contacts", "contacts.db");
+  if (!existsSync5(dbPath))
     return null;
   const db2 = new Database5(dbPath, { readonly: true });
   return db2;
@@ -85389,7 +85516,7 @@ __export(exports_army_runner, {
   waitForArmyRun: () => waitForArmyRun,
   runWithArmy: () => runWithArmy
 });
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 function chunkArray(arr, n2) {
   const chunks = [];
   const size = Math.ceil(arr.length / n2);
@@ -85399,7 +85526,7 @@ function chunkArray(arr, n2) {
   return chunks;
 }
 function getCliPath() {
-  const srcPath = join15(import.meta.dir, "../cli/index.tsx");
+  const srcPath = join16(import.meta.dir, "../cli/index.tsx");
   return srcPath;
 }
 async function runWithArmy(options) {
@@ -85602,12 +85729,28 @@ Rules:
   ];
   const messages = [{ role: "user", content: contentParts }];
   try {
-    const response = await anthropicClient.messages.create({
-      model,
-      max_tokens: 2048,
-      messages
-    });
-    const text2 = response.content.filter((b2) => b2.type === "text").map((b2) => b2.text).join("");
+    let text2;
+    const provider = detectProvider(model);
+    if (provider !== "anthropic") {
+      const compat2 = client;
+      const response = await callOpenAICompatible({
+        baseUrl: compat2.baseUrl,
+        apiKey: compat2.apiKey,
+        model,
+        system: "You are a QA engineer.",
+        messages: [{ role: "user", content: prompt }],
+        tools: [],
+        maxTokens: 2048
+      });
+      text2 = response.content.filter((b2) => b2.type === "text").map((b2) => b2.text).join("");
+    } else {
+      const response = await anthropicClient.messages.create({
+        model,
+        max_tokens: 2048,
+        messages
+      });
+      text2 = response.content.filter((b2) => b2.type === "text").map((b2) => b2.text).join("");
+    }
     const match = text2.match(/\[[\s\S]*\]/);
     if (!match)
       return [];
@@ -85635,7 +85778,7 @@ async function crawlAndGenerate(options) {
   } = options;
   const config2 = loadConfig();
   const model = resolveModel2(options.model ?? config2.defaultModel ?? "thorough");
-  const client = createClient(options.apiKey ?? config2.anthropicApiKey);
+  const client = createClientForModel(model, resolveProviderApiKeyForModel(model, options.apiKey, config2.anthropicApiKey));
   const rootOrigin = new URL(url2).origin;
   const visited = new Set;
   const queue = [url2];
@@ -85715,7 +85858,6 @@ var init_crawl_and_generate = __esm(() => {
   init_scenarios();
   init_ai_client();
   init_config2();
-  init_ai_client();
   DEFAULT_SKIP_PATTERNS = [
     "/logout",
     "/sign-out",
@@ -86171,9 +86313,30 @@ function buildServer() {
     goalPrompt: exports_external.string().optional().describe("Goal prompt for the AI SDK workflow agent"),
     successCriteria: exports_external.array(exports_external.string()).optional().describe("Goal success criteria"),
     maxIterations: exports_external.number().int().min(1).max(20).optional().describe("Max goal loop iterations"),
-    executionTarget: exports_external.enum(["local", "connector:e2b"]).optional().describe("Run locally or through the open-connectors E2B connector"),
-    e2bTemplate: exports_external.string().optional().describe("E2B sandbox template for connector:e2b")
-  }, async ({ name: name21, description, projectId, scenarioIds, tags, priority, personaIds, goalPrompt, successCriteria, maxIterations, executionTarget, e2bTemplate }) => {
+    executionTarget: exports_external.enum(["local", "sandbox", "connector:e2b"]).optional().describe("Run locally or through the sandboxes SDK"),
+    sandboxProvider: exports_external.string().optional().describe("Sandbox provider: e2b, daytona, or modal"),
+    sandboxImage: exports_external.string().optional().describe("Sandbox image/template"),
+    sandboxRemoteDir: exports_external.string().optional().describe("Remote working directory for sandbox runs"),
+    sandboxCleanup: exports_external.enum(["delete", "stop", "keep"]).optional().describe("Sandbox cleanup mode"),
+    e2bTemplate: exports_external.string().optional().describe("Legacy alias for sandboxImage")
+  }, async ({
+    name: name21,
+    description,
+    projectId,
+    scenarioIds,
+    tags,
+    priority,
+    personaIds,
+    goalPrompt,
+    successCriteria,
+    maxIterations,
+    executionTarget,
+    sandboxProvider,
+    sandboxImage,
+    sandboxRemoteDir,
+    sandboxCleanup,
+    e2bTemplate
+  }) => {
     try {
       return json3(createTestingWorkflow({
         name: name21,
@@ -86184,8 +86347,10 @@ function buildServer() {
         goal: goalPrompt ? { prompt: goalPrompt, successCriteria, maxIterations } : null,
         execution: {
           target: executionTarget ?? "local",
-          connector: executionTarget === "connector:e2b" ? "e2b" : undefined,
-          sandboxTemplate: e2bTemplate
+          provider: sandboxProvider ?? (executionTarget === "connector:e2b" ? "e2b" : undefined),
+          sandboxImage: sandboxImage ?? e2bTemplate,
+          sandboxRemoteDir,
+          sandboxCleanup
         }
       }));
     } catch (error40) {
@@ -86949,12 +87114,12 @@ function buildServer() {
       }
       if (!resolvedUrl)
         return errorResponse(new Error("No URL provided and no default environment set. Pass url or env."));
-      const { execSync: execSync3 } = await import("child_process");
+      const { execSync: execSync4 } = await import("child_process");
       let diffOutput = "";
       try {
         const ref = baseRef ?? "HEAD";
-        const stagedOut = execSync3(`git diff --cached --name-only`, { cwd: process.cwd(), encoding: "utf-8" }).trim();
-        const unstagedOut = execSync3(`git diff --name-only ${ref}`, { cwd: process.cwd(), encoding: "utf-8" }).trim();
+        const stagedOut = execSync4(`git diff --cached --name-only`, { cwd: process.cwd(), encoding: "utf-8" }).trim();
+        const unstagedOut = execSync4(`git diff --name-only ${ref}`, { cwd: process.cwd(), encoding: "utf-8" }).trim();
         diffOutput = [stagedOut, unstagedOut].filter(Boolean).join(`
 `);
       } catch {
@@ -87091,8 +87256,8 @@ function buildServer() {
       let allFiles = [...filePaths];
       if (includeAutoDetect) {
         try {
-          const { execSync: execSync3 } = await import("child_process");
-          const diffOutput = execSync3("git diff --name-only HEAD", { encoding: "utf-8", cwd: process.cwd() }).trim();
+          const { execSync: execSync4 } = await import("child_process");
+          const diffOutput = execSync4("git diff --name-only HEAD", { encoding: "utf-8", cwd: process.cwd() }).trim();
           const gitFiles = diffOutput.split(`
 `).filter(Boolean);
           allFiles = [...new Set([...allFiles, ...gitFiles])];
@@ -87637,7 +87802,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 // src/mcp/http.ts
 import { createServer } from "http";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-var DEFAULT_MCP_HTTP_PORT = 8880;
+var DEFAULT_MCP_HTTP_PORT = 8840;
 var DEFAULT_HOST = "127.0.0.1";
 function resolveMcpHttpPort(explicitPort) {
   if (explicitPort !== undefined && !Number.isNaN(explicitPort))
@@ -87659,8 +87824,8 @@ function parseCliPort(args) {
   }
   return;
 }
-function isStdioMode(args) {
-  return args.includes("--stdio") || process.env.MCP_STDIO === "1";
+function isHttpMode(args) {
+  return args.includes("--http") || process.env.MCP_HTTP === "1";
 }
 async function readJsonBody(req) {
   const chunks = [];
@@ -87748,14 +87913,14 @@ process.on("uncaughtException", (err) => {
 });
 async function main() {
   const args = process.argv.slice(2);
-  if (isStdioMode(args)) {
-    const { buildServer: buildServer2 } = await Promise.resolve().then(() => (init_server(), exports_server));
-    const server = buildServer2();
-    const transport = new StdioServerTransport;
-    await server.connect(transport);
+  if (isHttpMode(args)) {
+    await startMcpHttpServer({ name: "testers", port: parseCliPort(args) });
     return;
   }
-  await startMcpHttpServer({ name: "testers", port: parseCliPort(args) });
+  const { buildServer: buildServer2 } = await Promise.resolve().then(() => (init_server(), exports_server));
+  const server = buildServer2();
+  const transport = new StdioServerTransport;
+  await server.connect(transport);
 }
 main().catch((error40) => {
   console.error("Failed to start testers:", error40);