@sidecar-ai/cli 0.1.0-alpha.10 → 0.1.0-alpha.4

package/dist/index.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 
 // packages/cli/src/index.ts
-import { existsSync as existsSync7, realpathSync } from "fs";
+import { existsSync as existsSync6, realpathSync } from "fs";
 import { mkdir as mkdir10, readFile as readFile8, writeFile as writeFile10 } from "fs/promises";
 import { createServer as createServer2 } from "http";
-import path20 from "path";
+import path19 from "path";
 import { createInterface as createInterface2 } from "readline/promises";
-import { fileURLToPath, pathToFileURL as pathToFileURL3 } from "url";
+import { fileURLToPath, pathToFileURL } from "url";
 import { cwd, exit, stdin as stdin2, stdout as stdout2 } from "process";
-import { tsImport as tsImport2 } from "tsx/esm/api";
+import { tsImport } from "tsx/esm/api";
 
 // packages/auth/src/core.ts
 var authBrand = /* @__PURE__ */ Symbol.for("sidecar.auth");
@@ -66,9 +66,9 @@ var resourceResult = Object.assign(
 );
 function createToolResult(input) {
   const resultEnvelope = stripUndefined({
-    structuredContent: stripJsonUndefined(input.structuredContent),
+    structuredContent: input.structuredContent,
     content: normalizeRequiredContent(input.content),
-    _meta: stripJsonUndefined(input.meta),
+    _meta: input.meta,
     isError: input.isError
   });
   Object.defineProperty(resultEnvelope, toolResultBrand, {
@@ -112,9 +112,9 @@ function normalizeToolResult(value) {
     );
   }
   return stripUndefined({
-    structuredContent: stripJsonUndefined(value.structuredContent),
+    structuredContent: value.structuredContent,
     content: value.content ?? [],
-    _meta: stripJsonUndefined(value._meta),
+    _meta: value._meta,
     isError: value.isError
   });
 }
@@ -453,24 +453,10 @@ function normalizePromptResult(value, defaultDescription) {
 function stripUndefined(value) {
   return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
 }
-function stripJsonUndefined(value) {
-  if (value === void 0) {
-    return void 0;
-  }
-  if (Array.isArray(value)) {
-    return value.map((entry) => stripJsonUndefined(entry)).filter((entry) => entry !== void 0);
-  }
-  if (!value || typeof value !== "object") {
-    return value;
-  }
-  return Object.fromEntries(
-    Object.entries(value).map(([key, entry]) => [key, stripJsonUndefined(entry)]).filter(([, entry]) => entry !== void 0)
-  );
-}
 
 // packages/compiler/src/analyze.ts
 import { readdir } from "fs/promises";
-import path5 from "path";
+import path4 from "path";
 import {
   Node as Node4,
   SyntaxKind as SyntaxKind2
@@ -637,7 +623,14 @@ function devSidecarTypePaths() {
 import {
   Node as Node2
 } from "ts-morph";
-function getParamsSchema(_definition, execute) {
+function getParamsSchema(definition, execute) {
+  const explicitParams = definition.getProperty("params");
+  if (explicitParams && Node2.isPropertyAssignment(explicitParams)) {
+    const inferred = getSchemaFromZodProperty(explicitParams);
+    if (inferred) {
+      return inferred;
+    }
+  }
   const [params] = execute.getParameters();
   if (!params) {
     return emptyObjectSchema();
@@ -658,6 +651,74 @@ function getOutputSchema(definition, execute) {
   }
   return typeToJsonSchema(returnType);
 }
+function getSchemaFromZodProperty(property) {
+  const initializer = property.getInitializer();
+  if (!initializer) {
+    return void 0;
+  }
+  if (Node2.isCallExpression(initializer) && initializer.getExpression().getText().endsWith(".object")) {
+    const [shape] = initializer.getArguments();
+    if (shape && Node2.isObjectLiteralExpression(shape)) {
+      return zodObjectLiteralToSchema(shape);
+    }
+  }
+  return void 0;
+}
+function zodObjectLiteralToSchema(shape) {
+  const properties = {};
+  const required = [];
+  for (const property of shape.getProperties()) {
+    if (!Node2.isPropertyAssignment(property)) {
+      continue;
+    }
+    const name = property.getName().replace(/^["']|["']$/g, "");
+    const initializer = property.getInitializer();
+    if (!initializer) {
+      continue;
+    }
+    const propertySchema = zodExpressionToSchema(initializer);
+    properties[name] = propertySchema.schema;
+    if (!propertySchema.optional) {
+      required.push(name);
+    }
+  }
+  return {
+    type: "object",
+    properties,
+    required,
+    additionalProperties: false
+  };
+}
+function zodExpressionToSchema(expression) {
+  const text = expression.getText();
+  const optional = /\.optional\(\)/.test(text) || /\.default\(/.test(text);
+  const schema = {};
+  if (/z\.string\(\)/.test(text)) {
+    schema.type = "string";
+  } else if (/z\.number\(\)/.test(text)) {
+    schema.type = "number";
+  } else if (/z\.boolean\(\)/.test(text)) {
+    schema.type = "boolean";
+  } else if (/z\.array\(/.test(text)) {
+    schema.type = "array";
+    schema.items = {};
+  } else {
+    schema.type = "object";
+  }
+  const min = text.match(/\.min\((\d+)/);
+  const max = text.match(/\.max\((\d+)/);
+  if (schema.type === "string") {
+    if (min) schema.minLength = Number(min[1]);
+    if (max) schema.maxLength = Number(max[1]);
+  } else {
+    if (min) schema.minimum = Number(min[1]);
+    if (max) schema.maximum = Number(max[1]);
+  }
+  if (/\.int\(\)/.test(text)) {
+    schema.type = "integer";
+  }
+  return { schema, optional };
+}
 function typeToJsonSchema(type, description) {
   const withoutUndefined = removeUndefined(type);
   const schema = typeToJsonSchemaInner(withoutUndefined);
@@ -803,103 +864,11 @@ function schemaDescription(symbol) {
   }).find((comment) => comment.trim().length > 0);
 }
 
-// packages/compiler/src/runtime-schema.ts
-import { existsSync as existsSync2 } from "fs";
-import path3 from "path";
-import { pathToFileURL } from "url";
-import { tsImport } from "tsx/esm/api";
-async function readRuntimeToolInputSchema(rootDir, sourcePath) {
-  let sidecarTool;
-  try {
-    sidecarTool = await importRuntimeTool(rootDir, sourcePath);
-  } catch (error) {
-    warnRuntimeSchemaFallback(sourcePath, error);
-    return void 0;
-  }
-  if (!sidecarTool.params) {
-    return void 0;
-  }
-  try {
-    return await paramsToJsonSchema(sidecarTool.params);
-  } catch (error) {
-    warnRuntimeSchemaFallback(sourcePath, error);
-    return void 0;
-  }
-}
-async function importRuntimeTool(rootDir, sourcePath) {
-  const module = await tsImport(pathToFileURL(sourcePath).href, {
-    parentURL: runtimeParentUrl(rootDir),
-    tsconfig: runtimeTsconfig(rootDir)
-  });
-  const defaultExport = unwrapRuntimeDefault(module.default);
-  if (!isSidecarTool(defaultExport)) {
-    throw new Error(`${path3.relative(rootDir, sourcePath)} must default-export tool({ ... }).`);
-  }
-  return defaultExport;
-}
-async function paramsToJsonSchema(params) {
-  const instanceConverter = readInstanceConverter(params);
-  if (instanceConverter) {
-    return ensureJsonSchema(instanceConverter({ io: "input" }));
-  }
-  if (isZodMiniSchema(params)) {
-    const zod = await import("zod/v4-mini");
-    if (typeof zod.toJSONSchema === "function") {
-      return ensureJsonSchema(zod.toJSONSchema(params, { io: "input" }));
-    }
-  }
-  return void 0;
-}
-function readInstanceConverter(params) {
-  if (!params || typeof params !== "object") {
-    return void 0;
-  }
-  const record = params;
-  const converter = record.toJSONSchema ?? record.toJsonSchema;
-  return typeof converter === "function" ? converter.bind(params) : void 0;
-}
-function isZodMiniSchema(params) {
-  return Boolean(params && typeof params === "object" && "_zod" in params);
-}
-function ensureJsonSchema(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return void 0;
-  }
-  return value;
-}
-function runtimeParentUrl(rootDir) {
-  const configPath = path3.join(rootDir, "sidecar.config.ts");
-  return pathToFileURL(existsSync2(configPath) ? configPath : rootDir).href;
-}
-function runtimeTsconfig(rootDir) {
-  const projectTsconfig = path3.join(rootDir, "tsconfig.json");
-  if (existsSync2(projectTsconfig)) {
-    return projectTsconfig;
-  }
-  const repoTsconfig = path3.join(process.cwd(), "tsconfig.json");
-  const repoCore = path3.join(process.cwd(), "packages", "core", "src", "index.ts");
-  return existsSyncSafe(repoTsconfig) && existsSyncSafe(repoCore) ? repoTsconfig : false;
-}
-function unwrapRuntimeDefault(value) {
-  if (value && typeof value === "object" && "default" in value && Object.keys(value).every((key) => key === "default" || key === "__esModule")) {
-    return unwrapRuntimeDefault(value.default);
-  }
-  return value;
-}
-function warnRuntimeSchemaFallback(sourcePath, error) {
-  const message = error instanceof Error ? error.message : String(error);
-  console.warn(
-    `[sidecar] Could not convert runtime params schema for ${sourcePath}; falling back to TypeScript parameter inference. ${message}`
-  );
-}
-
 // packages/compiler/src/widgets.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync2 } from "fs";
 import { mkdir, readFile, writeFile } from "fs/promises";
-import { createRequire } from "module";
-import path4 from "path";
-import { pathToFileURL as pathToFileURL2 } from "url";
+import path3 from "path";
 import { build as esbuild } from "esbuild";
 import postcss from "postcss";
 import {
@@ -907,30 +876,28 @@ import {
   SyntaxKind
 } from "ts-morph";
 var CLAUDE_FONT_RESOURCE_DOMAIN = "https://assets.claude.ai";
-var requireFromCompiler = createRequire(import.meta.url);
-async function buildWidgets(rootDir, outDir, tools, config = void 0) {
+async function buildWidgets(rootDir, outDir, tools) {
   const widgets = tools.filter(
     (entry) => Boolean(entry.widget)
   );
   if (!widgets.length) {
     return;
   }
-  const cacheDir = path4.join(rootDir, ".sidecar", "cache", "widgets");
+  const cacheDir = path3.join(rootDir, ".sidecar", "cache", "widgets");
   await mkdir(cacheDir, { recursive: true });
   const appStyle = await prepareAppStyle(rootDir, cacheDir);
-  const configure = await loadWidgetBundlerHook(rootDir, cacheDir, config?.configure);
   for (const entry of widgets) {
-    const sourceFile = path4.join(rootDir, entry.widget.sourceFile);
+    const sourceFile = path3.join(rootDir, entry.widget.sourceFile);
     const safeId = safePathSegment(entry.id);
-    const entryFile = path4.join(cacheDir, `${safeId}.entry.tsx`);
-    const importPath = toImportSpecifier(path4.dirname(entryFile), sourceFile);
+    const entryFile = path3.join(cacheDir, `${safeId}.entry.tsx`);
+    const importPath = toImportSpecifier(path3.dirname(entryFile), sourceFile);
     await writeFile(
       entryFile,
       `import React from "react";
 import { createRoot } from "react-dom/client";
 import { SidecarWidgetRoot } from "@sidecar-ai/react";
 import "@sidecar-ai/native/styles.css";
-${appStyle ? `import ${JSON.stringify(toImportSpecifier(path4.dirname(entryFile), appStyle))};` : ""}
+${appStyle ? `import ${JSON.stringify(toImportSpecifier(path3.dirname(entryFile), appStyle))};` : ""}
 import Component from ${JSON.stringify(importPath)};
 
 createRoot(document.getElementById("root")!).render(
@@ -938,219 +905,64 @@ createRoot(document.getElementById("root")!).render(
 );
 `
     );
-    const baseOptions = enforceWidgetBuildInvariants({
+    const bundled = await esbuild({
       absWorkingDir: rootDir,
-      alias: sidecarWidgetAliases(rootDir),
+      alias: devSidecarBundleAliases(rootDir),
       bundle: true,
-      define: {
-        "process.env.NODE_ENV": JSON.stringify("production")
-      },
       entryPoints: [entryFile],
       format: "iife",
       jsx: "automatic",
-      minify: true,
+      minify: false,
       nodePaths: [
-        path4.join(rootDir, "node_modules"),
-        path4.join(process.cwd(), "node_modules")
+        path3.join(rootDir, "node_modules"),
+        path3.join(process.cwd(), "node_modules")
       ],
       outfile: "widget.js",
       platform: "browser",
       sourcemap: false,
       write: false
     });
-    const staticOptions = widgetBuildOptionsFromConfig(rootDir, config);
-    const configuredOptions = configure ? await configureWidgetBuild(configure, {
-      rootDir,
-      outDir,
-      entryFile,
-      widget: {
-        toolId: entry.id,
-        toolName: entry.name,
-        target: entry.target,
-        sourceFile: entry.widget.sourceFile
-      },
-      esbuildOptions: mergeWidgetBuildOptions(baseOptions, staticOptions)
-    }) : void 0;
-    const bundled = await esbuild(enforceWidgetBuildInvariants(
-      mergeWidgetBuildOptions(baseOptions, staticOptions, configuredOptions),
-      { rootDir, entryFile }
-    ));
-    const outputFiles = bundled.outputFiles ?? [];
-    const javascript = outputFiles.find((file) => file.path.endsWith(".js"))?.text ?? "";
-    const css = outputFiles.filter((file) => file.path.endsWith(".css")).map((file) => file.text).join("\n");
+    const javascript = bundled.outputFiles.find((file) => file.path.endsWith(".js"))?.text ?? "";
+    const css = bundled.outputFiles.filter((file) => file.path.endsWith(".css")).map((file) => file.text).join("\n");
     const html = renderWidgetHtml(entry.name, javascript, css);
     const hash = createHash("sha256").update(html).digest("hex").slice(0, 12);
-    const outputDir = path4.join(outDir, "public", "widgets", safeId);
-    const outputFile = path4.join(outputDir, `widget.${hash}.html`);
+    const outputDir = path3.join(outDir, "public", "widgets", safeId);
+    const outputFile = path3.join(outputDir, `widget.${hash}.html`);
     const resourceUri = `ui://${safeId}/widget.${hash}.html`;
     await mkdir(outputDir, { recursive: true });
     await writeFile(outputFile, html);
     entry.widget.resourceUri = resourceUri;
     entry.widget.resourceMeta = widgetResourceMeta(entry.widget.options, entry.target);
-    entry.widget.outputFile = path4.relative(outDir, outputFile);
+    entry.widget.outputFile = path3.relative(outDir, outputFile);
     entry.descriptor._meta = mergeWidgetMeta(entry.descriptor._meta, widgetMeta(resourceUri, entry.widget.options, entry.target));
   }
 }
-function widgetBuildOptionsFromConfig(rootDir, config) {
-  const esbuildConfig = config?.esbuild;
-  if (!esbuildConfig) {
-    return void 0;
-  }
-  return {
-    alias: normalizeAliases(rootDir, esbuildConfig.alias),
-    conditions: esbuildConfig.conditions,
-    define: esbuildConfig.define,
-    external: esbuildConfig.external,
-    jsx: esbuildConfig.jsx,
-    jsxImportSource: esbuildConfig.jsxImportSource,
-    loader: esbuildConfig.loader,
-    mainFields: esbuildConfig.mainFields
-  };
-}
-async function loadWidgetBundlerHook(rootDir, cacheDir, hookPath) {
-  if (!hookPath) {
-    return void 0;
-  }
-  const sourcePath = path4.resolve(rootDir, hookPath);
-  const relative = path4.relative(rootDir, sourcePath);
-  if (relative.startsWith("..") || path4.isAbsolute(relative)) {
-    throw new Error(`Widget bundler hook must stay inside the project root: ${hookPath}`);
-  }
-  if (!existsSync3(sourcePath)) {
-    throw new Error(`Widget bundler hook not found: ${hookPath}`);
-  }
-  const outputFile = path4.join(cacheDir, `widget-bundler.${contentHash(hookPath)}.mjs`);
-  await esbuild({
-    absWorkingDir: rootDir,
-    alias: devSidecarBundleAliases(rootDir),
-    bundle: true,
-    entryPoints: [sourcePath],
-    format: "esm",
-    nodePaths: [
-      path4.join(rootDir, "node_modules"),
-      path4.join(process.cwd(), "node_modules")
-    ],
-    outfile: outputFile,
-    packages: "external",
-    platform: "node",
-    target: "node20"
-  });
-  const module = await import(`${pathToFileURL2(outputFile).href}?t=${Date.now()}`);
-  if (typeof module.default !== "function") {
-    throw new Error(`Widget bundler hook must default-export a function: ${hookPath}`);
-  }
-  return module.default;
-}
-async function configureWidgetBuild(hook, input) {
-  const result = await hook(input);
-  if (!result) {
-    return void 0;
-  }
-  if (typeof result === "object" && "esbuildOptions" in result) {
-    return result.esbuildOptions;
-  }
-  return result;
-}
-function mergeWidgetBuildOptions(...options) {
-  const merged = {};
-  for (const option of options) {
-    if (!option) {
-      continue;
-    }
-    const previousAlias = merged.alias;
-    const previousDefine = merged.define;
-    const previousLoader = merged.loader;
-    const previousExternal = merged.external;
-    const previousNodePaths = merged.nodePaths;
-    const previousPlugins = merged.plugins;
-    Object.assign(merged, option);
-    merged.alias = { ...previousAlias ?? {}, ...option.alias ?? {} };
-    merged.define = { ...previousDefine ?? {}, ...option.define ?? {} };
-    merged.loader = { ...previousLoader ?? {}, ...option.loader ?? {} };
-    merged.external = uniqueStrings([...previousExternal ?? [], ...option.external ?? []]);
-    merged.nodePaths = uniqueStrings([...previousNodePaths ?? [], ...option.nodePaths ?? []]);
-    merged.plugins = [...previousPlugins ?? [], ...option.plugins ?? []];
-  }
-  return merged;
-}
-function enforceWidgetBuildInvariants(options, required) {
-  const aliases = required ? { ...options.alias ?? {}, ...reactSingletonAliases(required.rootDir) } : options.alias;
-  return {
-    ...options,
-    absWorkingDir: required?.rootDir ?? options.absWorkingDir,
-    alias: aliases,
-    bundle: true,
-    entryPoints: required ? [required.entryFile] : options.entryPoints,
-    format: "iife",
-    outfile: "widget.js",
-    platform: "browser",
-    write: false
-  };
-}
-function sidecarWidgetAliases(rootDir) {
-  return {
-    ...devSidecarBundleAliases(rootDir) ?? {},
-    ...reactSingletonAliases(rootDir)
-  };
-}
-function reactSingletonAliases(rootDir) {
-  return {
-    react: resolveProjectModule(rootDir, "react"),
-    "react/jsx-runtime": resolveProjectModule(rootDir, "react/jsx-runtime"),
-    "react/jsx-dev-runtime": resolveProjectModule(rootDir, "react/jsx-dev-runtime"),
-    "react-dom": resolveProjectModule(rootDir, "react-dom"),
-    "react-dom/client": resolveProjectModule(rootDir, "react-dom/client"),
-    "react-dom/server": resolveProjectModule(rootDir, "react-dom/server")
-  };
-}
-function resolveProjectModule(rootDir, specifier) {
-  return requireFromCompiler.resolve(specifier, {
-    paths: [rootDir, process.cwd()]
-  });
-}
-function normalizeAliases(rootDir, aliases) {
-  if (!aliases) {
-    return void 0;
-  }
-  return Object.fromEntries(
-    Object.entries(aliases).map(([key, value]) => [
-      key,
-      value.startsWith(".") ? path4.resolve(rootDir, value) : value
-    ])
-  );
-}
-function uniqueStrings(values) {
-  return [...new Set(values)];
-}
-function contentHash(value) {
-  return createHash("sha256").update(value).digest("hex").slice(0, 12);
-}
 function devSidecarBundleAliases(rootDir) {
   const repoRoot = findSidecarRepoRoot(rootDir) ?? findSidecarRepoRoot(process.cwd());
   if (!repoRoot) {
     return void 0;
   }
-  const reactEntry = path4.join(repoRoot, "packages", "react", "src", "index.ts");
-  if (!existsSync3(reactEntry)) {
+  const reactEntry = path3.join(repoRoot, "packages", "react", "src", "index.ts");
+  if (!existsSync2(reactEntry)) {
     return void 0;
   }
   return {
-    "sidecar-ai": path4.join(repoRoot, "packages", "sidecar-ai", "src", "index.ts"),
-    "@sidecar-ai/client": path4.join(repoRoot, "packages", "client", "src", "index.ts"),
-    "@sidecar-ai/core": path4.join(repoRoot, "packages", "core", "src", "index.ts"),
+    "sidecar-ai": path3.join(repoRoot, "packages", "sidecar-ai", "src", "index.ts"),
+    "@sidecar-ai/client": path3.join(repoRoot, "packages", "client", "src", "index.ts"),
+    "@sidecar-ai/core": path3.join(repoRoot, "packages", "core", "src", "index.ts"),
     "@sidecar-ai/react": reactEntry,
-    "@sidecar-ai/native": path4.join(repoRoot, "packages", "native", "src", "index.ts"),
-    "@sidecar-ai/native/components": path4.join(repoRoot, "packages", "native", "src", "components", "index.tsx"),
-    "@sidecar-ai/native/styles.css": path4.join(repoRoot, "packages", "native", "src", "styles.css")
+    "@sidecar-ai/native": path3.join(repoRoot, "packages", "native", "src", "index.ts"),
+    "@sidecar-ai/native/components": path3.join(repoRoot, "packages", "native", "src", "components", "index.tsx"),
+    "@sidecar-ai/native/styles.css": path3.join(repoRoot, "packages", "native", "src", "styles.css")
   };
 }
 function findSidecarRepoRoot(startDir) {
-  let current = path4.resolve(startDir);
+  let current = path3.resolve(startDir);
   while (true) {
-    if (existsSync3(path4.join(current, "packages", "core", "src", "index.ts"))) {
+    if (existsSync2(path3.join(current, "packages", "core", "src", "index.ts"))) {
       return current;
     }
-    const parent = path4.dirname(current);
+    const parent = path3.dirname(current);
     if (parent === current) {
       return void 0;
     }
@@ -1158,13 +970,13 @@ function findSidecarRepoRoot(startDir) {
   }
 }
 async function prepareAppStyle(rootDir, cacheDir) {
-  const sourceFile = path4.join(rootDir, "style.css");
-  if (!existsSync3(sourceFile)) {
+  const sourceFile = path3.join(rootDir, "style.css");
+  if (!existsSync2(sourceFile)) {
     return void 0;
   }
   const source = await readFile(sourceFile, "utf8");
   const css = await processAppStyle(source, sourceFile);
-  const outputFile = path4.join(cacheDir, "style.css");
+  const outputFile = path3.join(cacheDir, "style.css");
   await writeFile(outputFile, css);
   return outputFile;
 }
@@ -1176,7 +988,7 @@ async function processAppStyle(source, from) {
   const plugins = [];
   if (cssSource.includes("@tailwind")) {
     const tailwind = await import("@tailwindcss/postcss");
-    plugins.push(tailwind.default({ base: path4.dirname(from) }));
+    plugins.push(tailwind.default({ base: path3.dirname(from) }));
   }
   const autoprefixer = await import("autoprefixer");
   plugins.push(autoprefixer.default());
@@ -1190,13 +1002,13 @@ function needsPostcss(source) {
   return /@import\s+["']tailwindcss["']|@tailwind|@source|@theme|@plugin/.test(source);
 }
 function findWidget(rootDir, toolFile, id, target = "mcp", toolVariant = "shared") {
-  const selected = selectWidgetFile(path4.dirname(toolFile), target, toolVariant);
+  const selected = selectWidgetFile(path3.dirname(toolFile), target, toolVariant);
   if (!selected) {
     return void 0;
   }
   const safeId = safePathSegment(id);
   return {
-    sourceFile: path4.relative(rootDir, selected.filePath),
+    sourceFile: path3.relative(rootDir, selected.filePath),
     variant: selected.variant,
     resourceUri: `ui://${safeId}/widget.html`
   };
@@ -1231,8 +1043,7 @@ function widgetMeta(resourceUri, options = {}, target = "mcp") {
   const standard = {
     ui: {
       resourceUri
-    },
-    "ui/resourceUri": resourceUri
+    }
   };
   if (target !== "chatgpt") {
     return standard;
@@ -1379,17 +1190,17 @@ function readStringArrayProperty(definition, propertyName) {
 }
 function selectWidgetFile(directory, target, toolVariant) {
   if (toolVariant === "openai") {
-    const filePath = path4.join(directory, "widget.openai.tsx");
-    return existsSync3(filePath) ? { filePath, variant: "openai" } : void 0;
+    const filePath = path3.join(directory, "widget.openai.tsx");
+    return existsSync2(filePath) ? { filePath, variant: "openai" } : void 0;
   }
   if (toolVariant === "anthropic") {
-    const filePath = path4.join(directory, "widget.anthropic.tsx");
-    return existsSync3(filePath) ? { filePath, variant: "anthropic" } : void 0;
+    const filePath = path3.join(directory, "widget.anthropic.tsx");
+    return existsSync2(filePath) ? { filePath, variant: "anthropic" } : void 0;
   }
   const candidates = target === "chatgpt" || target === "claude" || target === "mcp" ? [{ name: "widget.tsx", variant: "shared" }] : [];
   for (const candidate of candidates) {
-    const filePath = path4.join(directory, candidate.name);
-    if (existsSync3(filePath)) {
+    const filePath = path3.join(directory, candidate.name);
+    if (existsSync2(filePath)) {
       return { filePath, variant: candidate.variant };
     }
   }
@@ -1440,23 +1251,17 @@ function stripUndefined3(value) {
 // packages/compiler/src/analyze.ts
 async function analyzeProjectTools(rootDir, options = {}) {
   const target = options.target ?? "mcp";
-  const toolFiles = await findToolFiles(path5.join(rootDir, "server"), target);
+  const toolFiles = await findToolFiles(path4.join(rootDir, "server"), target);
   if (toolFiles.length === 0) {
     return [];
   }
   const project = createProject(rootDir);
   const authScopes = readAuthScopeCatalog(project, rootDir);
-  const sources = toolFiles.map((candidate) => ({
-    candidate,
-    sourceFile: project.addSourceFileAtPath(candidate.filePath)
-  }));
-  const runtimeInputSchemas = await readRuntimeInputSchemas(rootDir, sources);
-  return sources.map(
-    ({ candidate, sourceFile }) => analyzeToolFile(sourceFile, rootDir, {
+  return toolFiles.map(
+    (candidate) => analyzeToolFile(project.addSourceFileAtPath(candidate.filePath), rootDir, {
       target,
       variant: candidate.variant,
-      authScopes,
-      inputSchema: runtimeInputSchemas.get(candidate.filePath)
+      authScopes
     })
   );
 }
@@ -1465,7 +1270,7 @@ function analyzeToolFile(sourceFile, rootDir, options = {}) {
   const variant = options.variant ?? "shared";
   const definition = findToolDefinition(sourceFile);
   const absoluteFile = sourceFile.getFilePath();
-  const directory = path5.basename(path5.dirname(absoluteFile));
+  const directory = path4.basename(path4.dirname(absoluteFile));
   const name = getRequiredStringProperty(definition, "name", sourceFile);
   const id = getOptionalStringProperty(definition, "id") ?? toMachineName(directory);
   const description = getRequiredStringProperty(
@@ -1478,7 +1283,7 @@ function analyzeToolFile(sourceFile, rootDir, options = {}) {
   const hosts = readHosts(definition);
   const auth = readAuthPolicy(definition, options.authScopes ?? {});
   const execute = getExecuteFunction(definition, sourceFile);
-  const inputSchema = options.inputSchema ?? getParamsSchema(definition, execute);
+  const inputSchema = getParamsSchema(definition, execute);
   const outputSchema = getOutputSchema(definition, execute);
   const descriptor = createToolDescriptor({
     name,
@@ -1496,7 +1301,7 @@ function analyzeToolFile(sourceFile, rootDir, options = {}) {
   validateWidgetHierarchy(sourceFile, absoluteFile, target, variant);
   const widget = findWidget(rootDir, absoluteFile, id, target, variant);
   if (widget) {
-    const widgetFile = path5.join(rootDir, widget.sourceFile);
+    const widgetFile = path4.join(rootDir, widget.sourceFile);
     const project = sourceFile.getProject();
     const widgetSourceFile = project.getSourceFile(widgetFile) ?? project.addSourceFileAtPath(widgetFile);
     widget.options = {
@@ -1507,7 +1312,7 @@ function analyzeToolFile(sourceFile, rootDir, options = {}) {
     descriptor._meta = mergeWidgetMeta(descriptor._meta, widgetMeta(widget.resourceUri, widget.options, target));
   }
   return {
-    sourceFile: path5.relative(rootDir, absoluteFile),
+    sourceFile: path4.relative(rootDir, absoluteFile),
     variant,
     target,
     directory,
@@ -1522,26 +1327,6 @@ function analyzeToolFile(sourceFile, rootDir, options = {}) {
     descriptor
   };
 }
-async function readRuntimeInputSchemas(rootDir, sources) {
-  const schemas = /* @__PURE__ */ new Map();
-  await Promise.all(sources.map(async ({ candidate, sourceFile }) => {
-    const definition = findToolDefinition(sourceFile);
-    if (!definitionHasRuntimeParams(definition)) {
-      return;
-    }
-    const schema = await readRuntimeToolInputSchema(rootDir, candidate.filePath);
-    if (schema) {
-      schemas.set(candidate.filePath, schema);
-    }
-  }));
-  return schemas;
-}
-function definitionHasRuntimeParams(definition) {
-  if (definition.getProperty("params")) {
-    return true;
-  }
-  return Boolean(getWithParamsCall(definition));
-}
 function readAuthPolicy(definition, authScopes) {
   const initializer = readObjectProperty2(definition, "auth");
   if (!initializer) {
@@ -1558,7 +1343,7 @@ function readAuthPolicy(definition, authScopes) {
   return { authenticated: true };
 }
 function readAuthScopeCatalog(project, rootDir) {
-  const authPath = path5.join(rootDir, "auth.ts");
+  const authPath = path4.join(rootDir, "auth.ts");
   if (!existsSyncSafe(authPath)) {
     return {};
   }
@@ -1640,12 +1425,12 @@ function isNamedCall(call, name) {
   return callee === name || callee.endsWith(`.${name}`);
 }
 function validateWidgetHierarchy(sourceFile, toolFile, target, variant) {
-  const directory = path5.dirname(toolFile);
+  const directory = path4.dirname(toolFile);
   const platformWidget = target === "chatgpt" ? "widget.openai.tsx" : target === "claude" ? "widget.anthropic.tsx" : void 0;
   if (!platformWidget || variant !== "shared") {
     return;
   }
-  if (existsSyncSafe(path5.join(directory, platformWidget))) {
+  if (existsSyncSafe(path4.join(directory, platformWidget))) {
     const expectedTool = target === "chatgpt" ? "tool.openai.ts" : "tool.anthropic.ts";
     throw new CompilerError(
       sourceFile,
@@ -1660,7 +1445,7 @@ async function findToolFiles(serverDir, target) {
   const entries = await readdir(serverDir, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const entryPath = path5.join(serverDir, entry.name);
+    const entryPath = path4.join(serverDir, entry.name);
     if (entry.isDirectory()) {
       const candidate = selectToolFile(entryPath, target);
       if (candidate) {
@@ -1679,7 +1464,7 @@ function selectToolFile(directory, target) {
     { name: "tool.ts", variant: "shared" }
   ] : [{ name: "tool.ts", variant: "shared" }];
   for (const candidate of candidates) {
-    const filePath = path5.join(directory, candidate.name);
+    const filePath = path4.join(directory, candidate.name);
     if (existsSyncSafe(filePath)) {
       return { filePath, variant: candidate.variant };
     }
@@ -1715,32 +1500,16 @@ function getExecuteFunction(definition, sourceFile) {
     return property;
   }
   if (Node4.isPropertyAssignment(property)) {
-    const initializer = unwrapExpression(property.getInitializer());
+    const initializer = property.getInitializer();
     if (initializer && (Node4.isArrowFunction(initializer) || Node4.isFunctionExpression(initializer))) {
       return initializer;
     }
-    const withParamsCall = getWithParamsCall(definition);
-    const wrappedExecute = unwrapExpression(withParamsCall?.getArguments()[1]);
-    if (wrappedExecute && (Node4.isArrowFunction(wrappedExecute) || Node4.isFunctionExpression(wrappedExecute))) {
-      return wrappedExecute;
-    }
   }
   throw new CompilerError(
     sourceFile,
     "execute must be a method, function expression, or arrow function."
   );
 }
-function getWithParamsCall(definition) {
-  const property = definition.getProperty("execute");
-  if (!property || !Node4.isPropertyAssignment(property)) {
-    return void 0;
-  }
-  const initializer = unwrapExpression(property.getInitializer());
-  if (!initializer || !Node4.isCallExpression(initializer)) {
-    return void 0;
-  }
-  return isNamedCall(initializer, "withParams") ? initializer : void 0;
-}
 function getRequiredStringProperty(definition, propertyName, sourceFile) {
   const value = getOptionalStringProperty(definition, propertyName);
   if (value === void 0 || !value.trim()) {
@@ -1896,16 +1665,16 @@ function readStringArrayProperty2(definition, propertyName) {
 
 // packages/compiler/src/build.ts
 import { mkdir as mkdir9, writeFile as writeFile9 } from "fs/promises";
-import path19 from "path";
+import path18 from "path";
 
 // packages/compiler/src/config.ts
-import path6 from "path";
+import path5 from "path";
 import {
   Node as Node5,
   SyntaxKind as SyntaxKind3
 } from "ts-morph";
 function analyzeProjectConfig(rootDir) {
-  const configPath = path6.join(rootDir, "sidecar.config.ts");
+  const configPath = path5.join(rootDir, "sidecar.config.ts");
   if (!existsSyncSafe(configPath)) {
     return defaultCompilerConfig();
   }
@@ -1917,13 +1686,6 @@ function analyzeProjectConfig(rootDir) {
     return defaultCompilerConfig();
   }
   return {
-    build: {
-      target: readTargetNested(definition, "build", "target"),
-      host: readHostNested(definition, "build", "host"),
-      outDir: readStringNested(definition, "build", "outDir"),
-      plugins: readBooleanNested(definition, "build", "plugins"),
-      widgets: readWidgetBuildConfig(definition)
-    },
     resources: {
       subscribe: readBooleanNested(definition, "resources", "subscribe") ?? false,
       listChanged: readBooleanNested(definition, "resources", "listChanged") ?? false
@@ -1935,52 +1697,13 @@ function analyzeProjectConfig(rootDir) {
       listChanged: readBooleanNested(definition, "tools", "listChanged") ?? false
     },
     pagination: {
-      pageSize: readNumberNested(definition, "pagination", "pageSize") ?? 50,
+      pageSize: readNumberNested(definition, "pagination", "pageSize") ?? 10,
       hasOverride: hasProperty(readObjectProperty3(definition, "pagination"), "override")
     }
   };
 }
-function readWidgetBuildConfig(definition) {
-  const widgets = readObjectProperty3(readObjectProperty3(definition, "build"), "widgets");
-  if (!widgets) {
-    return void 0;
-  }
-  const config = {};
-  const configure = readStringProperty3(widgets, "configure");
-  const esbuild3 = readWidgetEsbuildConfig(widgets);
-  if (configure) config.configure = configure;
-  if (esbuild3) config.esbuild = esbuild3;
-  return Object.keys(config).length ? config : void 0;
-}
-function readWidgetEsbuildConfig(widgets) {
-  const esbuild3 = readObjectProperty3(widgets, "esbuild");
-  if (!esbuild3) {
-    return void 0;
-  }
-  const config = {};
-  const alias = readStringRecordProperty(esbuild3, "alias");
-  const define = readStringRecordProperty(esbuild3, "define");
-  const external = readStringArrayProperty3(esbuild3, "external");
-  const loader = readStringRecordProperty(esbuild3, "loader");
-  const conditions = readStringArrayProperty3(esbuild3, "conditions");
-  const mainFields = readStringArrayProperty3(esbuild3, "mainFields");
-  const jsx = readStringProperty3(esbuild3, "jsx");
-  const jsxImportSource = readStringProperty3(esbuild3, "jsxImportSource");
-  if (alias) config.alias = alias;
-  if (define) config.define = define;
-  if (external) config.external = external;
-  if (loader) config.loader = loader;
-  if (conditions) config.conditions = conditions;
-  if (mainFields) config.mainFields = mainFields;
-  if (jsx === "automatic" || jsx === "transform" || jsx === "preserve") {
-    config.jsx = jsx;
-  }
-  if (jsxImportSource) config.jsxImportSource = jsxImportSource;
-  return Object.keys(config).length ? config : void 0;
-}
 function defaultCompilerConfig() {
   return {
-    build: {},
     resources: {
       subscribe: false,
       listChanged: false
@@ -1992,26 +1715,11 @@ function defaultCompilerConfig() {
       listChanged: false
     },
     pagination: {
-      pageSize: 50,
+      pageSize: 10,
       hasOverride: false
     }
   };
 }
-function readTargetNested(definition, section, propertyName) {
-  const value = readStringNested(definition, section, propertyName);
-  return value === "mcp" || value === "chatgpt" || value === "claude" ? value : void 0;
-}
-function readHostNested(definition, section, propertyName) {
-  const value = readStringNested(definition, section, propertyName);
-  return value === "node" || value === "vercel" ? value : void 0;
-}
-function readStringNested(definition, section, propertyName) {
-  const object = readObjectProperty3(definition, section);
-  if (!object) {
-    return void 0;
-  }
-  return readStringProperty3(object, propertyName);
-}
 function readBooleanNested(definition, section, propertyName) {
   const object = readObjectProperty3(definition, section);
   if (!object) {
@@ -2042,9 +1750,6 @@ function readNumberNested(definition, section, propertyName) {
   return initializer && Node5.isNumericLiteral(initializer) ? Number(initializer.getLiteralText()) : void 0;
 }
 function readObjectProperty3(definition, propertyName) {
-  if (!definition) {
-    return void 0;
-  }
   const property = definition.getProperty(propertyName);
   if (!property || !Node5.isPropertyAssignment(property)) {
     return void 0;
@@ -2052,79 +1757,38 @@ function readObjectProperty3(definition, propertyName) {
   const initializer = unwrapExpression(property.getInitializer());
   return initializer && Node5.isObjectLiteralExpression(initializer) ? initializer : void 0;
 }
-function readStringProperty3(definition, propertyName) {
-  const property = definition.getProperty(propertyName);
-  if (!property || !Node5.isPropertyAssignment(property)) {
-    return void 0;
-  }
-  const initializer = unwrapExpression(property.getInitializer());
-  return initializer && Node5.isStringLiteral(initializer) ? initializer.getLiteralText() : void 0;
-}
-function readStringArrayProperty3(definition, propertyName) {
-  const property = definition.getProperty(propertyName);
-  if (!property || !Node5.isPropertyAssignment(property)) {
-    return void 0;
-  }
-  const initializer = unwrapExpression(property.getInitializer());
-  if (!initializer || !Node5.isArrayLiteralExpression(initializer)) {
-    return void 0;
-  }
-  const values = initializer.getElements().map((element) => {
-    const unwrapped = unwrapExpression(element);
-    return unwrapped && Node5.isStringLiteral(unwrapped) ? unwrapped.getLiteralText() : void 0;
-  });
-  return values.every((value) => value !== void 0) ? values : void 0;
-}
-function readStringRecordProperty(definition, propertyName) {
-  const object = readObjectProperty3(definition, propertyName);
-  if (!object) {
-    return void 0;
-  }
-  const record = {};
-  for (const property of object.getProperties()) {
-    if (!Node5.isPropertyAssignment(property)) {
-      return void 0;
-    }
-    const initializer = unwrapExpression(property.getInitializer());
-    if (!initializer || !Node5.isStringLiteral(initializer)) {
-      return void 0;
-    }
-    record[property.getName().replace(/^["']|["']$/g, "")] = initializer.getLiteralText();
-  }
-  return record;
-}
 function hasProperty(definition, propertyName) {
   return Boolean(definition?.getProperty(propertyName));
 }
 
 // packages/compiler/src/diagnostics.ts
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 import { readFile as readFile2 } from "fs/promises";
-import path7 from "path";
+import path6 from "path";
 async function collectProjectDiagnostics(rootDir, input) {
   const diagnostics = [];
   const tools = Array.isArray(input) ? input : input.tools;
   const resources = Array.isArray(input) ? [] : input.resources ?? [];
   const prompts = Array.isArray(input) ? [] : input.prompts ?? [];
   const config = Array.isArray(input) ? void 0 : input.config;
-  const hasAuthConfig = existsSync4(path7.join(rootDir, "auth.ts"));
+  const hasAuthConfig = existsSync3(path6.join(rootDir, "auth.ts"));
   for (const entry of tools) {
-    const toolPath = path7.join(rootDir, entry.sourceFile);
+    const toolPath = path6.join(rootDir, entry.sourceFile);
     const toolSource = await readFile2(toolPath, "utf8");
-    diagnostics.push(...diagnoseToolSource(entry, toolSource, hasAuthConfig));
+    diagnostics.push(...diagnoseToolSource(rootDir, entry, toolSource, hasAuthConfig));
     if (entry.widget) {
-      const widgetPath = path7.join(rootDir, entry.widget.sourceFile);
+      const widgetPath = path6.join(rootDir, entry.widget.sourceFile);
       const widgetSource = await readFile2(widgetPath, "utf8");
       diagnostics.push(...diagnoseWidgetSource(rootDir, entry, widgetSource));
     }
   }
   for (const entry of resources) {
-    const resourcePath = path7.join(rootDir, entry.sourceFile);
+    const resourcePath = path6.join(rootDir, entry.sourceFile);
     const resourceSource = await readFile2(resourcePath, "utf8");
     diagnostics.push(...diagnoseResourceSource(entry, resourceSource));
   }
   for (const entry of prompts) {
-    const promptPath = path7.join(rootDir, entry.sourceFile);
+    const promptPath = path6.join(rootDir, entry.sourceFile);
     const promptSource = await readFile2(promptPath, "utf8");
     diagnostics.push(...diagnosePromptSource(entry, promptSource));
   }
@@ -2139,7 +1803,7 @@ function formatDiagnostic(diagnostic) {
   hint: ${diagnostic.hint}` : "";
   return `${location} - ${diagnostic.severity} ${diagnostic.code}: ${diagnostic.message}${hint}`;
 }
-function diagnoseToolSource(entry, source, hasAuthConfig) {
+function diagnoseToolSource(rootDir, entry, source, hasAuthConfig) {
   const diagnostics = [];
   const toolLocation = locate(source, "tool({");
   if (!entry.description.trim().startsWith("Use this when")) {
@@ -2356,21 +2020,21 @@ function isIgnored(source, code) {
 
 // packages/compiler/src/generated.ts
 import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
-import path8 from "path";
+import path7 from "path";
 async function writeGeneratedTypes(rootDir, tools) {
-  const generatedDir = path8.join(rootDir, ".sidecar", "generated");
+  const generatedDir = path7.join(rootDir, ".sidecar", "generated");
   await mkdir2(generatedDir, { recursive: true });
   const appCallableTools = tools.filter(isAppCallable);
   const methodNames = uniqueMethodNames(appCallableTools.map((entry) => toIdentifier(entry.id)));
   const imports = appCallableTools.map(
-    (entry, index) => `import type tool${index} from ${JSON.stringify(toImportSpecifier(generatedDir, path8.join(rootDir, entry.sourceFile), { extension: "js" }))};`
+    (entry, index) => `import type tool${index} from ${JSON.stringify(toImportSpecifier(generatedDir, path7.join(rootDir, entry.sourceFile), { extension: "js" }))};`
   ).join("\n");
   const ids = appCallableTools.map((entry, index) => `  ${methodNames[index]}: ${JSON.stringify(entry.id)}`).join(",\n");
   const toolTypes = appCallableTools.map(
-    (_entry, index) => `  ${methodNames[index]}(params: ToolParams<typeof tool${index}>): Promise<ToolOutput<typeof tool${index}>>;`
+    (entry, index) => `  ${methodNames[index]}(params: ToolParams<typeof tool${index}>): Promise<ToolOutput<typeof tool${index}>>;`
   ).join("\n");
   await writeFile2(
-    path8.join(generatedDir, "tools.ts"),
+    path7.join(generatedDir, "tools.ts"),
     `/**
  * Generated Sidecar widget tool client.
  *
@@ -2420,13 +2084,13 @@ function uniqueMethodNames(names) {
 
 // packages/compiler/src/identity.ts
 import { readFile as readFile3 } from "fs/promises";
-import path9 from "path";
+import path8 from "path";
 async function loadProjectIdentity(rootDir) {
-  const packageJson = await readOptionalJson(path9.join(rootDir, "package.json"));
+  const packageJson = await readOptionalJson(path8.join(rootDir, "package.json"));
   const configText = await readOptionalText(
-    path9.join(rootDir, "sidecar.config.ts")
+    path8.join(rootDir, "sidecar.config.ts")
   );
-  const name = readConfigString(configText, "name") ?? packageJson?.name ?? path9.basename(rootDir);
+  const name = readConfigString(configText, "name") ?? packageJson?.name ?? path8.basename(rootDir);
   const version = readConfigString(configText, "version") ?? packageJson?.version ?? "0.0.0-dev";
   const description = readConfigString(configText, "description") ?? packageJson?.description ?? `${name} Sidecar app.`;
   return {
@@ -2460,32 +2124,32 @@ function readConfigString(configText, key) {
 
 // packages/compiler/src/plugins.ts
 import { mkdir as mkdir7, writeFile as writeFile7 } from "fs/promises";
-import path15 from "path";
+import path14 from "path";
 
 // packages/compiler/src/plugin-components/agents.ts
 import { mkdir as mkdir3, readdir as readdir2, readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
-import path10 from "path";
+import path9 from "path";
 async function emitClaudeAgents(rootDir, destination) {
-  const source = path10.join(rootDir, "agents");
+  const source = path9.join(rootDir, "agents");
   if (!existsSyncSafe(source)) {
     return;
   }
   const entries = await readdir2(source, { withFileTypes: true });
   const agentDirs = entries.filter(
-    (entry) => entry.isDirectory() && existsSyncSafe(path10.join(source, entry.name, "agent.ts"))
+    (entry) => entry.isDirectory() && existsSyncSafe(path9.join(source, entry.name, "agent.ts"))
   );
   if (!agentDirs.length) {
     return;
   }
   await mkdir3(destination, { recursive: true });
   for (const entry of agentDirs) {
-    const sourceText = await readFile4(path10.join(source, entry.name, "agent.ts"), "utf8");
+    const sourceText = await readFile4(path9.join(source, entry.name, "agent.ts"), "utf8");
     const markdown = parseClaudeAgent(
       sourceText,
       entry.name
     );
     const agentName = readObjectString(sourceText, "name") ?? entry.name;
-    await writeFile3(path10.join(destination, `${safeFileStem(agentName)}.md`), markdown);
+    await writeFile3(path9.join(destination, `${safeFileStem(agentName)}.md`), markdown);
   }
 }
 function parseClaudeAgent(source, fallbackName) {
@@ -2514,41 +2178,41 @@ ${prompt.trim()}
 
 // packages/compiler/src/plugin-components/commands.ts
 import { cp, lstat, mkdir as mkdir4, readdir as readdir3, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
-import path11 from "path";
+import path10 from "path";
 async function copyCommands(rootDir, destination) {
-  const source = path11.join(rootDir, "commands");
+  const source = path10.join(rootDir, "commands");
   if (!existsSyncSafe(source)) {
     return;
   }
   await mkdir4(destination, { recursive: true });
   const entries = await readdir3(source, { withFileTypes: true });
   for (const entry of entries) {
-    const sourcePath = path11.join(source, entry.name);
+    const sourcePath = path10.join(source, entry.name);
     if (entry.isFile() && entry.name.endsWith(".md")) {
       if (await safeCommandCopyFilter(sourcePath)) {
-        await cp(sourcePath, path11.join(destination, safeFileStem(entry.name.replace(/\.md$/, "")) + ".md"));
+        await cp(sourcePath, path10.join(destination, safeFileStem(entry.name.replace(/\.md$/, "")) + ".md"));
       }
       continue;
     }
     if (!entry.isDirectory()) {
       continue;
     }
-    const dynamicCommand = path11.join(sourcePath, "command.ts");
+    const dynamicCommand = path10.join(sourcePath, "command.ts");
     if (existsSyncSafe(dynamicCommand)) {
       const sourceText = await readFile5(dynamicCommand, "utf8");
       const markdown = parseDynamicCommand(sourceText, entry.name);
       const commandName = readObjectString(sourceText, "name") ?? entry.name;
-      await writeFile4(path11.join(destination, `${safeFileStem(commandName)}.md`), markdown);
+      await writeFile4(path10.join(destination, `${safeFileStem(commandName)}.md`), markdown);
       continue;
     }
-    await cp(sourcePath, path11.join(destination, entry.name), {
+    await cp(sourcePath, path10.join(destination, entry.name), {
       recursive: true,
       filter: safeCommandCopyFilter
     });
   }
 }
 async function safeCommandCopyFilter(sourcePath) {
-  const basename = path11.basename(sourcePath);
+  const basename = path10.basename(sourcePath);
   if (basename === ".env" || basename.startsWith(".env.") || basename === "node_modules" || basename === ".git") {
     return false;
   }
@@ -2577,32 +2241,32 @@ ${Object.entries(frontmatter).map(([key, value]) => `${key}: ${yamlScalar(value)
 
 // packages/compiler/src/plugin-components/hooks.ts
 import { mkdir as mkdir5, readdir as readdir4, readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
-import path12 from "path";
+import path11 from "path";
 import {
   Node as Node6,
   Project as Project2,
   SyntaxKind as SyntaxKind4
 } from "ts-morph";
 async function copyHooks(rootDir, destination) {
-  const source = path12.join(rootDir, "hooks");
+  const source = path11.join(rootDir, "hooks");
   if (!existsSyncSafe(source)) {
     return;
   }
   const entries = await readdir4(source, { withFileTypes: true });
   const hookDirs = entries.filter(
-    (entry) => entry.isDirectory() && existsSyncSafe(path12.join(source, entry.name, "hook.ts"))
+    (entry) => entry.isDirectory() && existsSyncSafe(path11.join(source, entry.name, "hook.ts"))
   );
   if (!hookDirs.length) {
     return;
   }
   const config = {};
   for (const entry of hookDirs) {
-    const filePath = path12.join(source, entry.name, "hook.ts");
+    const filePath = path11.join(source, entry.name, "hook.ts");
     mergeHooks(config, parseHookFile(await readFile6(filePath, "utf8"), entry.name));
   }
   await mkdir5(destination, { recursive: true });
   await writeFile5(
-    path12.join(destination, "hooks.json"),
+    path11.join(destination, "hooks.json"),
     `${JSON.stringify(config, null, 2)}
 `
   );
@@ -2629,7 +2293,7 @@ function parseHookFile(source, fallbackName) {
   throw new Error(`hooks/${fallbackName}/hook.ts must default-export hook({ ... }) or hooks({ ... }).`);
 }
 function parseHookDefinition(definition, fallbackName) {
-  const event = readStringProperty4(definition, "event");
+  const event = readStringProperty3(definition, "event");
   if (!event) {
     throw new Error(`hooks/${fallbackName}/hook.ts must declare an event string.`);
   }
@@ -2639,7 +2303,7 @@ function parseHookDefinition(definition, fallbackName) {
   }
   return {
     event,
-    matcher: readStringProperty4(definition, "matcher"),
+    matcher: readStringProperty3(definition, "matcher"),
     run: hooks
   };
 }
@@ -2659,7 +2323,7 @@ function parseHooksDefinition(definition, fallbackName) {
         throw new Error(`hooks/${fallbackName}/hook.ts event "${event}" entries must be objects.`);
       }
       return stripUndefined2({
-        matcher: readStringProperty4(entry, "matcher"),
+        matcher: readStringProperty3(entry, "matcher"),
         hooks: readHookArray(entry, "run", fallbackName)
       });
     });
@@ -2682,7 +2346,7 @@ function parseHookHandlers(handlers, fallbackName) {
 }
 function parseHookHandler(handler, fallbackName) {
   if (Node6.isObjectLiteralExpression(handler)) {
-    const type = readStringProperty4(handler, "type");
+    const type = readStringProperty3(handler, "type");
     if (type !== "command" && type !== "http") {
       throw new Error(`hooks/${fallbackName}/hook.ts hook handlers need type "command" or "http".`);
     }
@@ -2732,7 +2396,7 @@ function objectLiteralToRecord(object) {
   }
   return stripUndefined2(record);
 }
-function readStringProperty4(object, propertyName) {
+function readStringProperty3(object, propertyName) {
   const property = object.getProperty(propertyName);
   if (!property || !Node6.isPropertyAssignment(property)) {
     return void 0;
@@ -2776,7 +2440,7 @@ function mergeHooks(target, source) {
 
 // packages/compiler/src/plugin-components/passthrough.ts
 import { cp as cp2, lstat as lstat2 } from "fs/promises";
-import path13 from "path";
+import path12 from "path";
 async function copyClaudePassthroughDirectories(rootDir, pluginDir) {
   for (const directory of [
     "assets",
@@ -2785,18 +2449,18 @@ async function copyClaudePassthroughDirectories(rootDir, pluginDir) {
     "output-styles",
     "themes"
   ]) {
-    const source = path13.join(rootDir, directory);
+    const source = path12.join(rootDir, directory);
     if (!existsSyncSafe(source)) {
       continue;
     }
-    await cp2(source, path13.join(pluginDir, directory), {
+    await cp2(source, path12.join(pluginDir, directory), {
       recursive: true,
       filter: safePluginCopyFilter
     });
   }
 }
 async function safePluginCopyFilter(sourcePath) {
-  const basename = path13.basename(sourcePath);
+  const basename = path12.basename(sourcePath);
   if (basename === "node_modules" || basename === ".git" || basename === ".env" || basename.startsWith(".env.")) {
     return false;
   }
@@ -2805,11 +2469,11 @@ async function safePluginCopyFilter(sourcePath) {
 }
 
 // packages/compiler/src/plugin-components/skills.ts
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import { cp as cp3, lstat as lstat3, mkdir as mkdir6, readdir as readdir5, readFile as readFile7, writeFile as writeFile6 } from "fs/promises";
-import path14 from "path";
+import path13 from "path";
 async function copySkills(rootDir, destination) {
-  const source = path14.join(rootDir, "skills");
+  const source = path13.join(rootDir, "skills");
   if (!existsSyncSafe(source)) {
     return;
   }
@@ -2819,27 +2483,27 @@ async function copySkills(rootDir, destination) {
     if (!entry.isDirectory()) {
       continue;
     }
-    const sourceDir = path14.join(source, entry.name);
-    const destinationDir = path14.join(destination, entry.name);
-    const staticSkill = path14.join(sourceDir, "SKILL.md");
-    const dynamicSkill = path14.join(sourceDir, "skill.ts");
+    const sourceDir = path13.join(source, entry.name);
+    const destinationDir = path13.join(destination, entry.name);
+    const staticSkill = path13.join(sourceDir, "SKILL.md");
+    const dynamicSkill = path13.join(sourceDir, "skill.ts");
     await mkdir6(destinationDir, { recursive: true });
-    if (existsSync5(staticSkill)) {
+    if (existsSync4(staticSkill)) {
       await cp3(sourceDir, destinationDir, {
         recursive: true,
-        filter: async (sourcePath) => !sourcePath.endsWith(`${path14.sep}skill.ts`) && await safeSkillCopyFilter(sourcePath)
+        filter: async (sourcePath) => !sourcePath.endsWith(`${path13.sep}skill.ts`) && await safeSkillCopyFilter(sourcePath)
       });
-    } else if (existsSync5(dynamicSkill)) {
+    } else if (existsSync4(dynamicSkill)) {
       const generated = parseDynamicSkill(
         await readFile7(dynamicSkill, "utf8"),
         entry.name
       );
-      await writeFile6(path14.join(destinationDir, "SKILL.md"), generated);
+      await writeFile6(path13.join(destinationDir, "SKILL.md"), generated);
     }
   }
 }
 async function safeSkillCopyFilter(sourcePath) {
-  const basename = path14.basename(sourcePath);
+  const basename = path13.basename(sourcePath);
   if (basename === ".env" || basename.startsWith(".env.") || basename === "node_modules" || basename === ".git") {
     return false;
   }
@@ -2865,25 +2529,25 @@ async function buildPluginPackages(rootDir, outRoot, manifest) {
   await buildClaudePlugin(rootDir, outRoot, identity, manifest);
 }
 async function buildClaudePlugin(rootDir, outRoot, identity, manifest) {
-  const pluginDir = path15.join(outRoot, "claude-plugin");
-  await mkdir7(path15.join(pluginDir, ".claude-plugin"), { recursive: true });
-  await copySkills(rootDir, path15.join(pluginDir, "skills"));
-  await copyCommands(rootDir, path15.join(pluginDir, "commands"));
-  await copyHooks(rootDir, path15.join(pluginDir, "hooks"));
-  await emitClaudeAgents(rootDir, path15.join(pluginDir, "agents"));
+  const pluginDir = path14.join(outRoot, "claude-plugin");
+  await mkdir7(path14.join(pluginDir, ".claude-plugin"), { recursive: true });
+  await copySkills(rootDir, path14.join(pluginDir, "skills"));
+  await copyCommands(rootDir, path14.join(pluginDir, "commands"));
+  await copyHooks(rootDir, path14.join(pluginDir, "hooks"));
+  await emitClaudeAgents(rootDir, path14.join(pluginDir, "agents"));
   await copyClaudePassthroughDirectories(rootDir, pluginDir);
-  await writeJson(path15.join(pluginDir, ".claude-plugin", "plugin.json"), {
+  await writeJson(path14.join(pluginDir, ".claude-plugin", "plugin.json"), {
     name: identity.slug,
     version: identity.version,
     description: identity.description,
     displayName: identity.name,
     installationPreference: "available"
   });
-  await writeJson(path15.join(pluginDir, "version.json"), {
+  await writeJson(path14.join(pluginDir, "version.json"), {
     version: identity.version,
     generatedBy: "sidecar"
   });
-  await writeJson(path15.join(pluginDir, ".mcp.json"), {
+  await writeJson(path14.join(pluginDir, ".mcp.json"), {
     mcpServers: {
       [identity.slug]: {
         type: "http",
@@ -2891,7 +2555,7 @@ async function buildClaudePlugin(rootDir, outRoot, identity, manifest) {
       }
     }
   });
-  await writeJson(path15.join(pluginDir, "settings.json"), {
+  await writeJson(path14.join(pluginDir, "settings.json"), {
     sidecar: {
       tools: manifest.tools.map((entry) => entry.id),
       resources: manifest.resources.map((entry) => entry.uri),
@@ -2899,7 +2563,7 @@ async function buildClaudePlugin(rootDir, outRoot, identity, manifest) {
     }
   });
   await writeFile7(
-    path15.join(pluginDir, "README.md"),
+    path14.join(pluginDir, "README.md"),
     `# ${identity.name} Claude Plugin
 
 This package was generated by Sidecar.
@@ -2913,7 +2577,7 @@ Claude/Cowork plugin-specific components such as skills, slash commands, agents,
   );
 }
 async function writeJson(filePath, value) {
-  await mkdir7(path15.dirname(filePath), { recursive: true });
+  await mkdir7(path14.dirname(filePath), { recursive: true });
   await writeFile7(
     filePath,
     `${JSON.stringify(stripUndefined2(value), null, 2)}
@@ -2923,13 +2587,13 @@ async function writeJson(filePath, value) {
 
 // packages/compiler/src/prompts.ts
 import { readdir as readdir6 } from "fs/promises";
-import path16 from "path";
+import path15 from "path";
 import {
   Node as Node7,
   SyntaxKind as SyntaxKind5
 } from "ts-morph";
 async function analyzeProjectPrompts(rootDir) {
-  const promptFiles = await findPromptFiles(path16.join(rootDir, "prompts"));
+  const promptFiles = await findPromptFiles(path15.join(rootDir, "prompts"));
   if (promptFiles.length === 0) {
     return [];
   }
@@ -2941,7 +2605,7 @@ async function analyzeProjectPrompts(rootDir) {
 function analyzePromptFile(sourceFile, rootDir) {
   const definition = findPromptDefinition(sourceFile);
   const absoluteFile = sourceFile.getFilePath();
-  const directory = path16.basename(path16.dirname(absoluteFile));
+  const directory = path15.basename(path15.dirname(absoluteFile));
   const name = getOptionalStringProperty2(definition, "name") ?? safePathSegment(directory);
   const title = getRequiredStringProperty2(definition, "title", sourceFile);
   const description = getOptionalStringProperty2(definition, "description");
@@ -2957,7 +2621,7 @@ function analyzePromptFile(sourceFile, rootDir) {
     throw new CompilerError(sourceFile, "prompt({ ... }) must include a run method.");
   }
   return {
-    sourceFile: path16.relative(rootDir, absoluteFile),
+    sourceFile: path15.relative(rootDir, absoluteFile),
     directory,
     name,
     title,
@@ -2976,7 +2640,7 @@ async function findPromptFiles(promptsDir) {
     if (!entry.isDirectory()) {
       continue;
     }
-    const filePath = path16.join(promptsDir, entry.name, "prompt.ts");
+    const filePath = path15.join(promptsDir, entry.name, "prompt.ts");
     if (existsSyncSafe(filePath)) {
       files.push(filePath);
     }
@@ -3098,7 +2762,7 @@ function readIcons(definition) {
     return [{
       src,
       mimeType: getOptionalStringProperty2(object, "mimeType"),
-      sizes: readStringArrayProperty4(object, "sizes")
+      sizes: readStringArrayProperty3(object, "sizes")
     }];
   });
   return icons.length ? icons : void 0;
@@ -3111,7 +2775,7 @@ function readObjectProperty4(definition, propertyName) {
   const initializer = unwrapExpression(property.getInitializer());
   return initializer && Node7.isObjectLiteralExpression(initializer) ? initializer : void 0;
 }
-function readStringArrayProperty4(definition, propertyName) {
+function readStringArrayProperty3(definition, propertyName) {
   const property = definition.getProperty(propertyName);
   if (!property || !Node7.isPropertyAssignment(property)) {
     return void 0;
@@ -3125,13 +2789,13 @@ function readStringArrayProperty4(definition, propertyName) {
 
 // packages/compiler/src/resources.ts
 import { readdir as readdir7 } from "fs/promises";
-import path17 from "path";
+import path16 from "path";
 import {
   Node as Node8,
   SyntaxKind as SyntaxKind6
 } from "ts-morph";
 async function analyzeProjectResources(rootDir) {
-  const resourceFiles = await findResourceFiles(path17.join(rootDir, "resources"));
+  const resourceFiles = await findResourceFiles(path16.join(rootDir, "resources"));
   if (resourceFiles.length === 0) {
     return [];
   }
@@ -3143,7 +2807,7 @@ async function analyzeProjectResources(rootDir) {
 function analyzeResourceFile(sourceFile, rootDir) {
   const definition = findResourceDefinition(sourceFile);
   const absoluteFile = sourceFile.getFilePath();
-  const directory = path17.basename(path17.dirname(absoluteFile));
+  const directory = path16.basename(path16.dirname(absoluteFile));
   const defaultUri = `sidecar://resources/${safePathSegment(directory)}`;
   const name = getRequiredStringProperty3(definition, "name", sourceFile);
   const uri = getOptionalStringProperty3(definition, "uri") ?? defaultUri;
@@ -3161,7 +2825,7 @@ function analyzeResourceFile(sourceFile, rootDir) {
     throw new CompilerError(sourceFile, "resource({ ... }) must include a read method.");
   }
   return {
-    sourceFile: path17.relative(rootDir, absoluteFile),
+    sourceFile: path16.relative(rootDir, absoluteFile),
     directory,
     uri,
     name,
@@ -3184,7 +2848,7 @@ async function findResourceFiles(resourcesDir) {
     if (!entry.isDirectory()) {
       continue;
     }
-    const filePath = path17.join(resourcesDir, entry.name, "resource.ts");
+    const filePath = path16.join(resourcesDir, entry.name, "resource.ts");
     if (existsSyncSafe(filePath)) {
       files.push(filePath);
     }
@@ -3263,7 +2927,7 @@ function readAnnotations2(definition) {
     return void 0;
   }
   const annotations = {};
-  const audience = readStringArrayProperty5(initializer, "audience")?.filter((value) => value === "user" || value === "assistant");
+  const audience = readStringArrayProperty4(initializer, "audience")?.filter((value) => value === "user" || value === "assistant");
   const priority = getOptionalNumberProperty(initializer, "priority");
   const lastModified = getOptionalStringProperty3(initializer, "lastModified");
   if (audience?.length) annotations.audience = audience;
@@ -3292,7 +2956,7 @@ function readIcons2(definition) {
     return [{
       src,
       mimeType: getOptionalStringProperty3(object, "mimeType"),
-      sizes: readStringArrayProperty5(object, "sizes")
+      sizes: readStringArrayProperty4(object, "sizes")
     }];
   });
   return icons.length ? icons : void 0;
@@ -3305,7 +2969,7 @@ function readObjectProperty5(definition, propertyName) {
   const initializer = unwrapExpression(property.getInitializer());
   return initializer && Node8.isObjectLiteralExpression(initializer) ? initializer : void 0;
 }
-function readStringArrayProperty5(definition, propertyName) {
+function readStringArrayProperty4(definition, propertyName) {
   const property = definition.getProperty(propertyName);
   if (!property || !Node8.isPropertyAssignment(property)) {
     return void 0;
@@ -3318,21 +2982,19 @@ function readStringArrayProperty5(definition, propertyName) {
 }
 
 // packages/compiler/src/server-output.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 import { mkdir as mkdir8, rm, writeFile as writeFile8 } from "fs/promises";
-import path18 from "path";
+import path17 from "path";
 import { build as esbuild2 } from "esbuild";
 var SERVER_ENTRYPOINT = "server/index.js";
-var VERCEL_FUNCTION_DIR = "functions/api/sidecar.func";
-var VERCEL_ENTRYPOINT = `${VERCEL_FUNCTION_DIR}/index.js`;
-var VERCEL_HANDLER_FILE = "index.js";
-async function buildServerOutput(rootDir, outDir, manifest, identity, host = "node", options = {}) {
-  const cacheDir = path18.join(rootDir, ".sidecar", "cache", "server");
+var VERCEL_ENTRYPOINT = "api/sidecar.js";
+async function buildServerOutput(rootDir, outDir, manifest, identity, host = "node") {
+  const cacheDir = path17.join(rootDir, ".sidecar", "cache", "server");
   await mkdir8(cacheDir, { recursive: true });
-  const entryFile = path18.join(cacheDir, "index.ts");
+  const entryFile = path17.join(cacheDir, "index.ts");
   await writeFile8(entryFile, renderServerEntry(rootDir, entryFile, manifest, identity));
-  const serverFile = path18.join(outDir, SERVER_ENTRYPOINT);
-  await mkdir8(path18.dirname(serverFile), { recursive: true });
+  const serverFile = path17.join(outDir, SERVER_ENTRYPOINT);
+  await mkdir8(path17.dirname(serverFile), { recursive: true });
   await esbuild2({
     absWorkingDir: rootDir,
     alias: sidecarBundleAliases(rootDir),
@@ -3346,30 +3008,26 @@ const require = __sidecarCreateRequire(import.meta.url);`
     legalComments: "none",
     minify: false,
     nodePaths: [
-      path18.join(rootDir, "node_modules"),
-      path18.join(process.cwd(), "node_modules")
+      path17.join(rootDir, "node_modules"),
+      path17.join(process.cwd(), "node_modules")
     ],
     outfile: serverFile,
     platform: "node",
     sourcemap: false,
     target: "node20"
   });
-  await writeFile8(path18.join(outDir, "package.json"), renderServerPackage(identity));
+  await writeFile8(path17.join(outDir, "package.json"), renderServerPackage(identity));
   if (host === "vercel") {
-    const vercelOutputDir = options.vercelOutputDir ?? outDir;
-    await rm(path18.join(vercelOutputDir, "api"), { recursive: true, force: true });
-    await rm(path18.join(vercelOutputDir, "vercel.json"), { force: true });
-    await writeFile8(path18.join(outDir, VERCEL_HANDLER_FILE), renderVercelEntrypoint());
-    await writeFile8(path18.join(outDir, ".vc-config.json"), renderVercelFunctionConfig());
-    await mkdir8(vercelOutputDir, { recursive: true });
-    await writeFile8(path18.join(vercelOutputDir, "config.json"), renderVercelOutputConfig());
+    await mkdir8(path17.join(outDir, "api"), { recursive: true });
+    await writeFile8(path17.join(outDir, VERCEL_ENTRYPOINT), renderVercelEntrypoint());
+    await writeFile8(path17.join(outDir, "vercel.json"), renderVercelConfig());
   } else {
-    await rm(path18.join(outDir, "api"), { recursive: true, force: true });
-    await rm(path18.join(outDir, "vercel.json"), { force: true });
+    await rm(path17.join(outDir, "api"), { recursive: true, force: true });
+    await rm(path17.join(outDir, "vercel.json"), { force: true });
   }
 }
 function renderServerEntry(rootDir, entryFile, manifest, identity) {
-  const entryDir = path18.dirname(entryFile);
+  const entryDir = path17.dirname(entryFile);
   const tools = manifest.tools;
   const resources = manifest.resources;
   const prompts = manifest.prompts;
@@ -3382,17 +3040,17 @@ function renderServerEntry(rootDir, entryFile, manifest, identity) {
     `import { isSidecarPrompt, isSidecarResource, isSidecarTool } from "@sidecar-ai/core";`,
     `import { isSidecarProxy } from "@sidecar-ai/server/proxy";`,
     ...tools.map(
-      (entry, index) => `import tool${index} from ${JSON.stringify(toImportSpecifier(entryDir, path18.join(rootDir, entry.sourceFile)))};`
+      (entry, index) => `import tool${index} from ${JSON.stringify(toImportSpecifier(entryDir, path17.join(rootDir, entry.sourceFile)))};`
     ),
     ...resources.map(
-      (entry, index) => `import resource${index} from ${JSON.stringify(toImportSpecifier(entryDir, path18.join(rootDir, entry.sourceFile)))};`
+      (entry, index) => `import resource${index} from ${JSON.stringify(toImportSpecifier(entryDir, path17.join(rootDir, entry.sourceFile)))};`
     ),
     ...prompts.map(
-      (entry, index) => `import prompt${index} from ${JSON.stringify(toImportSpecifier(entryDir, path18.join(rootDir, entry.sourceFile)))};`
+      (entry, index) => `import prompt${index} from ${JSON.stringify(toImportSpecifier(entryDir, path17.join(rootDir, entry.sourceFile)))};`
     ),
-    existsSync6(path18.join(rootDir, "auth.ts")) ? `import authExport from ${JSON.stringify(toImportSpecifier(entryDir, path18.join(rootDir, "auth.ts")))};` : `const authExport = undefined;`,
-    existsSync6(path18.join(rootDir, "proxy.ts")) ? `import proxyExport from ${JSON.stringify(toImportSpecifier(entryDir, path18.join(rootDir, "proxy.ts")))};` : `const proxyExport = undefined;`,
-    existsSync6(path18.join(rootDir, "sidecar.config.ts")) ? `import configExport from ${JSON.stringify(toImportSpecifier(entryDir, path18.join(rootDir, "sidecar.config.ts")))};` : `const configExport = undefined;`
+    existsSync5(path17.join(rootDir, "auth.ts")) ? `import authExport from ${JSON.stringify(toImportSpecifier(entryDir, path17.join(rootDir, "auth.ts")))};` : `const authExport = undefined;`,
+    existsSync5(path17.join(rootDir, "proxy.ts")) ? `import proxyExport from ${JSON.stringify(toImportSpecifier(entryDir, path17.join(rootDir, "proxy.ts")))};` : `const proxyExport = undefined;`,
+    existsSync5(path17.join(rootDir, "sidecar.config.ts")) ? `import configExport from ${JSON.stringify(toImportSpecifier(entryDir, path17.join(rootDir, "sidecar.config.ts")))};` : `const configExport = undefined;`
   ].join("\n");
   return `${imports}
 
@@ -3503,7 +3161,7 @@ function unwrapRuntimeDefault(value) {
     value &&
     typeof value === "object" &&
     "default" in value &&
-    Object.keys(value).every((key) => key === "default" || key === "__esModule")
+    Object.keys(value).length === 1
   ) {
     return unwrapRuntimeDefault(value.default);
   }
@@ -3563,29 +3221,23 @@ function renderServerPackage(identity) {
 `;
 }
 function renderVercelEntrypoint() {
-  return `export { default } from "./server/index.js";
-`;
-}
-function renderVercelFunctionConfig() {
-  return `${JSON.stringify({
-    runtime: "nodejs22.x",
-    handler: VERCEL_HANDLER_FILE,
-    launcherType: "Nodejs",
-    shouldAddHelpers: true,
-    supportsResponseStreaming: true,
-    maxDuration: 300
-  }, null, 2)}
+  return `export { default } from "../server/index.js";
 `;
 }
-function renderVercelOutputConfig() {
+function renderVercelConfig() {
   return `${JSON.stringify({
-    version: 3,
-    routes: [
+    rewrites: [
       {
-        src: "/(.*)",
-        dest: "/api/sidecar"
+        source: "/(.*)",
+        destination: "/api/sidecar"
       }
-    ]
+    ],
+    functions: {
+      "api/sidecar.js": {
+        includeFiles: "public/**",
+        maxDuration: 300
+      }
+    }
   }, null, 2)}
 `;
 }
@@ -3595,35 +3247,35 @@ function sidecarBundleAliases(rootDir) {
     return void 0;
   }
   return {
-    "sidecar-ai": path18.join(repoRoot, "packages", "sidecar-ai", "src", "index.ts"),
-    "@sidecar-ai/auth": path18.join(repoRoot, "packages", "auth", "src", "index.ts"),
-    "@sidecar-ai/core": path18.join(repoRoot, "packages", "core", "src", "index.ts"),
-    "@sidecar-ai/server": path18.join(repoRoot, "packages", "server", "src", "index.ts"),
-    "@sidecar-ai/server/proxy": path18.join(repoRoot, "packages", "server", "src", "proxy.ts"),
-    "@sidecar-ai/client": path18.join(repoRoot, "packages", "client", "src", "index.ts"),
-    "@sidecar-ai/react": path18.join(repoRoot, "packages", "react", "src", "index.ts"),
-    "@sidecar-ai/native": path18.join(repoRoot, "packages", "native", "src", "index.ts"),
-    "@sidecar-ai/native/components": path18.join(repoRoot, "packages", "native", "src", "components", "index.tsx"),
-    "@sidecar-ai/openai": path18.join(repoRoot, "packages", "openai", "src", "index.ts"),
-    "@sidecar-ai/openai/components": path18.join(repoRoot, "packages", "openai", "src", "components.tsx"),
-    "@sidecar-ai/openai/official": path18.join(repoRoot, "packages", "openai", "src", "official.ts"),
-    "@sidecar-ai/anthropic": path18.join(repoRoot, "packages", "anthropic", "src", "index.ts"),
-    "@sidecar-ai/anthropic/agent": path18.join(repoRoot, "packages", "anthropic", "src", "agent.ts"),
-    "@sidecar-ai/anthropic/command": path18.join(repoRoot, "packages", "anthropic", "src", "command.ts"),
-    "@sidecar-ai/anthropic/components": path18.join(repoRoot, "packages", "anthropic", "src", "components.tsx"),
-    "@sidecar-ai/anthropic/hooks": path18.join(repoRoot, "packages", "anthropic", "src", "hooks.ts"),
-    "@sidecar-ai/anthropic/mcp": path18.join(repoRoot, "packages", "anthropic", "src", "mcp.ts"),
-    "@sidecar-ai/anthropic/plugin": path18.join(repoRoot, "packages", "anthropic", "src", "plugin.ts"),
-    "@sidecar-ai/anthropic/skill": path18.join(repoRoot, "packages", "anthropic", "src", "skill.ts")
+    "sidecar-ai": path17.join(repoRoot, "packages", "sidecar-ai", "src", "index.ts"),
+    "@sidecar-ai/auth": path17.join(repoRoot, "packages", "auth", "src", "index.ts"),
+    "@sidecar-ai/core": path17.join(repoRoot, "packages", "core", "src", "index.ts"),
+    "@sidecar-ai/server": path17.join(repoRoot, "packages", "server", "src", "index.ts"),
+    "@sidecar-ai/server/proxy": path17.join(repoRoot, "packages", "server", "src", "proxy.ts"),
+    "@sidecar-ai/client": path17.join(repoRoot, "packages", "client", "src", "index.ts"),
+    "@sidecar-ai/react": path17.join(repoRoot, "packages", "react", "src", "index.ts"),
+    "@sidecar-ai/native": path17.join(repoRoot, "packages", "native", "src", "index.ts"),
+    "@sidecar-ai/native/components": path17.join(repoRoot, "packages", "native", "src", "components", "index.tsx"),
+    "@sidecar-ai/openai": path17.join(repoRoot, "packages", "openai", "src", "index.ts"),
+    "@sidecar-ai/openai/components": path17.join(repoRoot, "packages", "openai", "src", "components.tsx"),
+    "@sidecar-ai/openai/official": path17.join(repoRoot, "packages", "openai", "src", "official.ts"),
+    "@sidecar-ai/anthropic": path17.join(repoRoot, "packages", "anthropic", "src", "index.ts"),
+    "@sidecar-ai/anthropic/agent": path17.join(repoRoot, "packages", "anthropic", "src", "agent.ts"),
+    "@sidecar-ai/anthropic/command": path17.join(repoRoot, "packages", "anthropic", "src", "command.ts"),
+    "@sidecar-ai/anthropic/components": path17.join(repoRoot, "packages", "anthropic", "src", "components.tsx"),
+    "@sidecar-ai/anthropic/hooks": path17.join(repoRoot, "packages", "anthropic", "src", "hooks.ts"),
+    "@sidecar-ai/anthropic/mcp": path17.join(repoRoot, "packages", "anthropic", "src", "mcp.ts"),
+    "@sidecar-ai/anthropic/plugin": path17.join(repoRoot, "packages", "anthropic", "src", "plugin.ts"),
+    "@sidecar-ai/anthropic/skill": path17.join(repoRoot, "packages", "anthropic", "src", "skill.ts")
   };
 }
 function findSidecarRepoRoot2(startDir) {
-  let current = path18.resolve(startDir);
+  let current = path17.resolve(startDir);
   while (true) {
-    if (existsSync6(path18.join(current, "packages", "core", "src", "index.ts"))) {
+    if (existsSync5(path17.join(current, "packages", "core", "src", "index.ts"))) {
       return current;
     }
-    const parent = path18.dirname(current);
+    const parent = path17.dirname(current);
     if (parent === current) {
       return void 0;
     }
@@ -3633,11 +3285,10 @@ function findSidecarRepoRoot2(startDir) {
 
 // packages/compiler/src/build.ts
 async function buildProject(options) {
-  const rootDir = path19.resolve(options.rootDir);
+  const rootDir = path18.resolve(options.rootDir);
+  const target = options.target ?? "mcp";
+  const host = options.host ?? "node";
   const config = analyzeProjectConfig(rootDir);
-  const target = options.target ?? config.build.target ?? "mcp";
-  const host = options.host ?? config.build.host ?? "node";
-  const plugins = options.plugins ?? config.build.plugins ?? false;
   const tools = await analyzeProjectTools(rootDir, { target });
   const resources = await analyzeProjectResources(rootDir);
   const resourceTemplates = [];
@@ -3653,9 +3304,8 @@ async function buildProject(options) {
   if (errors.length) {
     throw new Error(errors.map(formatDiagnostic).join("\n"));
   }
-  const outDir = resolveInsideRoot(rootDir, options.outDir ?? config.build.outDir ?? defaultBuildOutDir(host, target));
-  const runtimeOutDir = resolveRuntimeOutputDir(outDir, host);
-  await buildWidgets(rootDir, runtimeOutDir, tools, config.build.widgets);
+  const outDir = resolveInsideRoot(rootDir, options.outDir ?? "out/mcp");
+  await buildWidgets(rootDir, outDir, tools);
   const manifest = {
     version: 1,
     target,
@@ -3669,47 +3319,24 @@ async function buildProject(options) {
     prompts,
     diagnostics
   };
-  await mkdir9(runtimeOutDir, { recursive: true });
+  await mkdir9(outDir, { recursive: true });
   await writeFile9(
-    path19.join(runtimeOutDir, "manifest.sidecar.json"),
+    path18.join(outDir, "manifest.sidecar.json"),
     `${JSON.stringify(manifest, null, 2)}
 `
   );
-  await writeFile9(path19.join(runtimeOutDir, "README.md"), renderMcpReadme(manifest));
+  await writeFile9(path18.join(outDir, "README.md"), renderMcpReadme(manifest));
   await writeGeneratedTypes(rootDir, tools);
-  await buildServerOutput(rootDir, runtimeOutDir, manifest, identity, host, {
-    vercelOutputDir: outDir
-  });
-  if (plugins) {
-    await buildPluginPackages(rootDir, resolvePluginOutputBase(rootDir, outDir, host), manifest);
+  await buildServerOutput(rootDir, outDir, manifest, identity, host);
+  if (options.plugins) {
+    await buildPluginPackages(rootDir, path18.dirname(outDir), manifest);
   }
   return manifest;
 }
-function defaultBuildOutDir(host, target) {
-  if (host === "vercel") {
-    return ".vercel/output";
-  }
-  return `out/${target}`;
-}
-function resolveRuntimeOutputDir(outDir, host) {
-  if (host === "vercel") {
-    return path19.join(outDir, VERCEL_FUNCTION_DIR);
-  }
-  return outDir;
-}
-function resolvePluginOutputBase(rootDir, outDir, host) {
-  if (host === "vercel" && isVercelBuildOutputDir(outDir)) {
-    return path19.join(rootDir, "out");
-  }
-  return path19.dirname(outDir);
-}
-function isVercelBuildOutputDir(outDir) {
-  return path19.basename(outDir) === "output" && path19.basename(path19.dirname(outDir)) === ".vercel";
-}
 function resolveInsideRoot(rootDir, output) {
-  const resolved = path19.resolve(rootDir, output);
-  const relative = path19.relative(rootDir, resolved);
-  if (relative.startsWith("..") || path19.isAbsolute(relative)) {
+  const resolved = path18.resolve(rootDir, output);
+  const relative = path18.relative(rootDir, resolved);
+  if (relative.startsWith("..") || path18.isAbsolute(relative)) {
     throw new Error(`Build output must stay inside the project root: ${output}`);
   }
   return resolved;
@@ -3762,7 +3389,7 @@ Set \`PORT\` or \`SIDECAR_PORT\` to choose the listen port. Hosted/authenticated
 function renderVercelReadmeSection() {
   return `## Deploy To Vercel
 
-This output uses Vercel's Build Output API. The MCP function is emitted at \`${VERCEL_FUNCTION_DIR}\`, and \`config.json\` routes Streamable HTTP traffic to it. Set \`SIDECAR_MCP_URL\` to the public \`https://.../mcp\` URL in Vercel.
+This output includes a Vercel Function shim at \`api/sidecar.js\` and a \`vercel.json\` rewrite that sends Streamable HTTP traffic to \`/mcp\`. Deploy this output directory with Vercel and set \`SIDECAR_MCP_URL\` to the public \`https://.../mcp\` URL.
 `;
 }
 
@@ -4064,7 +3691,7 @@ var SidecarMcpServer = class {
   /** Returns the server-chosen page size for all built-in list pagination. */
   pageSize() {
     const configured = this.options.pagination?.pageSize;
-    return configured && configured > 0 ? Math.floor(configured) : 50;
+    return configured && configured > 0 ? Math.floor(configured) : 10;
   }
   /** Executes a tool after request-level and tool-level auth checks. */
   async callTool(request, context) {
@@ -4173,7 +3800,6 @@ var SidecarMcpServer = class {
       });
     }
     return {
-      _meta: resource._meta,
       contents: [
         {
           uri,
@@ -4273,11 +3899,6 @@ function createSidecarHttpHandler(options) {
   const streamHub = createSseHub();
   const mcp = createSidecarMcpServer(options);
   return async (request, response) => {
-    const pathname = request.url?.split("?")[0];
-    const requestLog = createHttpRequestLog(request, pathname);
-    response.once("finish", () => {
-      logHttpRequest(requestLog, response.statusCode);
-    });
     if (isRejectedOrigin(request, options.allowedOrigins)) {
       response.writeHead(403, { "content-type": "application/json" });
       response.end(JSON.stringify({ error: "forbidden_origin" }));
@@ -4289,17 +3910,16 @@ function createSidecarHttpHandler(options) {
       response.end(proxyResult.body ?? "");
       return;
     }
+    const pathname = request.url?.split("?")[0];
     if (options.auth && request.method === "GET" && isProtectedResourceMetadataPath(pathname, endpoint)) {
       response.writeHead(200, { "content-type": "application/json" });
       response.end(JSON.stringify(options.auth.metadata()));
       return;
     }
-    if (options.auth && request.method === "GET" && pathname === "/.well-known/oauth-authorization-server") {
-      await proxyAuthorizationServerMetadata(options.auth, response);
-      return;
-    }
     if (request.method === "GET" && pathname === endpoint) {
       try {
+        validateProtocolVersion(request);
+        validateGetHeaders(request);
         const fetchRequest = toFetchRequest(request, options.publicUrl ?? options.auth?.resource);
         if (options.auth) {
           const authSession = await authorizeHttpRequest(options.auth, fetchRequest, response);
@@ -4307,8 +3927,6 @@ function createSidecarHttpHandler(options) {
             return;
           }
         }
-        validateProtocolVersion(request);
-        validateGetHeaders(request);
         streamHub.open(response);
       } catch (error) {
         const status = error instanceof JsonRpcHttpError ? error.status : 400;
@@ -4337,11 +3955,6 @@ function createSidecarHttpHandler(options) {
       return;
     }
     try {
-      const fetchRequest = toFetchRequest(request, options.publicUrl ?? options.auth?.resource);
-      const authSession = options.auth ? await authorizeHttpRequest(options.auth, fetchRequest, response) : void 0;
-      if (options.auth && authSession === AUTH_RESPONSE_SENT) {
-        return;
-      }
       validateProtocolVersion(request);
       validatePostHeaders(request);
       const body = await readJson(request, maxBodyBytes);
@@ -4354,6 +3967,11 @@ function createSidecarHttpHandler(options) {
         return;
       }
       const rpcRequest = assertJsonRpcRequest(body);
+      const fetchRequest = toFetchRequest(request, options.publicUrl ?? options.auth?.resource);
+      const authSession = options.auth ? await authorizeHttpRequest(options.auth, fetchRequest, response) : void 0;
+      if (options.auth && authSession === AUTH_RESPONSE_SENT) {
+        return;
+      }
       if (rpcRequest.id !== void 0 && hasProgressToken(rpcRequest)) {
         const stream = createSseStream(response, { supportsRequestProgress: true });
         const payload2 = await mcp.handle(rpcRequest, {
@@ -4445,73 +4063,6 @@ function escapeRegExp(value) {
 function isProtectedResourceMetadataPath(pathname, endpoint) {
   return pathname === "/.well-known/oauth-protected-resource" || pathname === `/.well-known/oauth-protected-resource${endpoint}`;
 }
-function createHttpRequestLog(request, pathname) {
-  return {
-    method: request.method,
-    path: pathname,
-    host: truncateHeader(singleHeader(request.headers.host)),
-    accept: truncateHeader(singleHeader(request.headers.accept)),
-    contentType: truncateHeader(singleHeader(request.headers["content-type"])),
-    contentLength: truncateHeader(singleHeader(request.headers["content-length"])),
-    mcpProtocolVersion: truncateHeader(singleHeader(request.headers["mcp-protocol-version"])),
-    origin: truncateHeader(singleHeader(request.headers.origin)),
-    userAgent: truncateHeader(singleHeader(request.headers["user-agent"])),
-    authorization: request.headers.authorization ? "present" : "absent",
-    cookie: request.headers.cookie ? "present" : "absent"
-  };
-}
-function logHttpRequest(metadata, status) {
-  const debug = process.env.SIDECAR_DEBUG === "1" || process.env.SIDECAR_LOG_LEVEL === "debug";
-  if (!debug && status < 400) {
-    return;
-  }
-  const message = JSON.stringify({
-    event: "sidecar.mcp.http",
-    status,
-    ...stripUndefined4(metadata)
-  });
-  if (status >= 500) {
-    console.error(message);
-  } else if (status >= 400) {
-    console.warn(message);
-  } else {
-    console.info(message);
-  }
-}
-function singleHeader(value) {
-  return Array.isArray(value) ? value.join(", ") : value;
-}
-function truncateHeader(value) {
-  if (!value) {
-    return void 0;
-  }
-  return value.length > 240 ? `${value.slice(0, 237)}...` : value;
-}
-async function proxyAuthorizationServerMetadata(auth, response) {
-  const [authorizationServer] = auth.authorizationServers;
-  if (!authorizationServer) {
-    response.writeHead(404, { "content-type": "application/json" });
-    response.end(JSON.stringify({ error: "authorization_server_not_configured" }));
-    return;
-  }
-  try {
-    const url = new URL("/.well-known/oauth-authorization-server", authorizationServer);
-    const upstream = await fetch(url, { headers: { accept: "application/json" } });
-    const body = await upstream.text();
-    response.writeHead(upstream.ok ? 200 : 502, {
-      "content-type": upstream.headers.get("content-type") ?? "application/json"
-    });
-    response.end(body);
-  } catch (error) {
-    console.warn(JSON.stringify({
-      event: "sidecar.mcp.authorization_metadata_proxy_failed",
-      authorizationServer,
-      message: error instanceof Error ? error.message : "Unknown error"
-    }));
-    response.writeHead(502, { "content-type": "application/json" });
-    response.end(JSON.stringify({ error: "authorization_metadata_unavailable" }));
-  }
-}
 var JsonRpcError = class extends Error {
   constructor(code, message, data) {
     super(message);
@@ -4861,44 +4412,44 @@ function validateAgainstSchema(schema, value, message, options = {}) {
   }
   return value;
 }
-function schemaFailure(schema, value, path21) {
-  if (schema.anyOf?.length && !schema.anyOf.some((entry) => !schemaFailure(entry, value, path21))) {
-    return `${path21} must match one anyOf schema.`;
+function schemaFailure(schema, value, path20) {
+  if (schema.anyOf?.length && !schema.anyOf.some((entry) => !schemaFailure(entry, value, path20))) {
+    return `${path20} must match one anyOf schema.`;
   }
-  if (schema.oneOf?.length && schema.oneOf.filter((entry) => !schemaFailure(entry, value, path21)).length !== 1) {
-    return `${path21} must match exactly one oneOf schema.`;
+  if (schema.oneOf?.length && schema.oneOf.filter((entry) => !schemaFailure(entry, value, path20)).length !== 1) {
+    return `${path20} must match exactly one oneOf schema.`;
   }
   if (schema.allOf?.length) {
     for (const entry of schema.allOf) {
-      const failure = schemaFailure(entry, value, path21);
+      const failure = schemaFailure(entry, value, path20);
       if (failure) return failure;
     }
   }
   if (schema.const !== void 0 && value !== schema.const) {
-    return `${path21} must equal ${JSON.stringify(schema.const)}.`;
+    return `${path20} must equal ${JSON.stringify(schema.const)}.`;
   }
   if (schema.enum && !schema.enum.some((entry) => JSON.stringify(entry) === JSON.stringify(value))) {
-    return `${path21} must be one of the declared enum values.`;
+    return `${path20} must be one of the declared enum values.`;
   }
   if (schema.type) {
     const types = Array.isArray(schema.type) ? schema.type : [schema.type];
     if (!types.some((type) => matchesJsonSchemaType(type, value))) {
-      return `${path21} must be ${types.join(" or ")}.`;
+      return `${path20} must be ${types.join(" or ")}.`;
     }
   }
   if (schema.type === "object" || schema.properties || schema.required) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
-      return `${path21} must be an object.`;
+      return `${path20} must be an object.`;
     }
     const record = value;
     for (const required of schema.required ?? []) {
       if (!(required in record)) {
-        return `${path21}.${required} is required.`;
+        return `${path20}.${required} is required.`;
       }
     }
     for (const [key, propertySchema] of Object.entries(schema.properties ?? {})) {
       if (key in record) {
-        const failure = schemaFailure(propertySchema, record[key], `${path21}.${key}`);
+        const failure = schemaFailure(propertySchema, record[key], `${path20}.${key}`);
         if (failure) return failure;
       }
     }
@@ -4906,12 +4457,12 @@ function schemaFailure(schema, value, path21) {
     if (schema.additionalProperties === false) {
       const extra = Object.keys(record).find((key) => !allowed.has(key));
       if (extra) {
-        return `${path21}.${extra} is not allowed.`;
+        return `${path20}.${extra} is not allowed.`;
       }
     } else if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
       for (const [key, entry] of Object.entries(record)) {
         if (!allowed.has(key)) {
-          const failure = schemaFailure(schema.additionalProperties, entry, `${path21}.${key}`);
+          const failure = schemaFailure(schema.additionalProperties, entry, `${path20}.${key}`);
           if (failure) return failure;
         }
       }
@@ -4919,38 +4470,29 @@ function schemaFailure(schema, value, path21) {
   }
   if (schema.type === "array" || schema.items) {
     if (!Array.isArray(value)) {
-      return `${path21} must be an array.`;
-    }
-    if (schema.minItems !== void 0 && value.length < schema.minItems) {
-      return `${path21} must contain at least ${schema.minItems} items.`;
-    }
-    if (schema.maxItems !== void 0 && value.length > schema.maxItems) {
-      return `${path21} must contain at most ${schema.maxItems} items.`;
+      return `${path20} must be an array.`;
     }
     if (schema.items) {
       for (const [index, entry] of value.entries()) {
-        const failure = schemaFailure(schema.items, entry, `${path21}[${index}]`);
+        const failure = schemaFailure(schema.items, entry, `${path20}[${index}]`);
         if (failure) return failure;
       }
     }
   }
   if (typeof value === "string") {
     if (schema.minLength !== void 0 && value.length < schema.minLength) {
-      return `${path21} is shorter than ${schema.minLength}.`;
+      return `${path20} is shorter than ${schema.minLength}.`;
     }
     if (schema.maxLength !== void 0 && value.length > schema.maxLength) {
-      return `${path21} is longer than ${schema.maxLength}.`;
-    }
-    if (schema.pattern !== void 0 && !new RegExp(schema.pattern).test(value)) {
-      return `${path21} must match pattern ${schema.pattern}.`;
+      return `${path20} is longer than ${schema.maxLength}.`;
     }
   }
   if (typeof value === "number") {
     if (schema.minimum !== void 0 && value < schema.minimum) {
-      return `${path21} is less than ${schema.minimum}.`;
+      return `${path20} is less than ${schema.minimum}.`;
     }
     if (schema.maximum !== void 0 && value > schema.maximum) {
-      return `${path21} is greater than ${schema.maximum}.`;
+      return `${path20} is greater than ${schema.maximum}.`;
     }
   }
   return void 0;
@@ -5128,11 +4670,11 @@ import { stdin, stdout } from "process";
 async function startTunnel(options) {
   const provider = await resolveProvider(options.provider);
   const localUrl = `http://127.0.0.1:${options.port}`;
-  const path21 = options.path ?? "/mcp";
+  const path20 = options.path ?? "/mcp";
   if (provider === "cloudflared") {
-    return startCloudflared(localUrl, path21, options.timeoutMs);
+    return startCloudflared(localUrl, path20, options.timeoutMs);
   }
-  return startWrangler(localUrl, path21, options.timeoutMs);
+  return startWrangler(localUrl, path20, options.timeoutMs);
 }
 async function validateTunnelEndpoint(options) {
   const timeoutMs = options.timeoutMs ?? 1e4;
@@ -5256,7 +4798,7 @@ function assertNpxAvailable() {
     throw new Error(tunnelInstallMessage("wrangler"));
   }
 }
-async function startCloudflared(localUrl, path21, timeoutMs = 2e4) {
+async function startCloudflared(localUrl, path20, timeoutMs = 2e4) {
   const child = spawn("cloudflared", ["tunnel", "--url", localUrl, "--no-autoupdate"], {
     stdio: ["ignore", "pipe", "pipe"]
   });
@@ -5264,13 +4806,13 @@ async function startCloudflared(localUrl, path21, timeoutMs = 2e4) {
   return {
     provider: "cloudflared",
     publicUrl,
-    mcpUrl: appendPath(publicUrl, path21),
+    mcpUrl: appendPath(publicUrl, path20),
     close() {
       child.kill("SIGTERM");
     }
   };
 }
-async function startWrangler(localUrl, path21, timeoutMs = 2e4) {
+async function startWrangler(localUrl, path20, timeoutMs = 2e4) {
   const child = spawn("npx", ["--yes", "wrangler", "tunnel", "quick-start", localUrl], {
     stdio: ["ignore", "pipe", "pipe"]
   });
@@ -5278,7 +4820,7 @@ async function startWrangler(localUrl, path21, timeoutMs = 2e4) {
   return {
     provider: "wrangler",
     publicUrl,
-    mcpUrl: appendPath(publicUrl, path21),
+    mcpUrl: appendPath(publicUrl, path20),
     close() {
       child.kill("SIGTERM");
     }
@@ -5539,8 +5081,8 @@ function runInherited(command, args) {
     });
   });
 }
-function appendPath(origin, path21) {
-  return `${origin.replace(/\/+$/, "")}/${path21.replace(/^\/+/, "")}`;
+function appendPath(origin, path20) {
+  return `${origin.replace(/\/+$/, "")}/${path20.replace(/^\/+/, "")}`;
 }
 function isRecord3(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -5552,27 +5094,26 @@ async function main(argv) {
   const rootDir = readOption(argv, "--cwd") ?? cwd();
   switch (command) {
     case "build": {
-      const target = readOptionalTarget(argv);
-      const host = readOptionalHost(argv) ?? detectHostFromEnvironment();
-      const outDir = readOption(argv, "--out");
-      const plugins = readOptionalPlugins(argv);
+      const target = readTarget(argv);
+      const host = readHost(argv);
+      const outDir = readOption(argv, "--out") ?? `out/${target}`;
+      const plugins = argv.includes("--plugins");
       const strict = argv.includes("--strict");
       const manifest = await buildProject({ rootDir, host, outDir, plugins, strict, target });
-      const resolvedOutDir = outDir ?? manifest.config.build.outDir ?? defaultBuildOutDir2(manifest.host, manifest.target);
       printDiagnostics(manifest.diagnostics ?? []);
       if (strict && manifest.diagnostics?.length) {
         exit(1);
       }
       console.log(
-        `Built ${manifest.tools.length} ${manifest.target} tool${manifest.tools.length === 1 ? "" : "s"}, ${manifest.resources.length} resource${manifest.resources.length === 1 ? "" : "s"}, and ${manifest.prompts.length} prompt${manifest.prompts.length === 1 ? "" : "s"} to ${resolvedOutDir}.`
+        `Built ${manifest.tools.length} ${target} tool${manifest.tools.length === 1 ? "" : "s"}, ${manifest.resources.length} resource${manifest.resources.length === 1 ? "" : "s"}, and ${manifest.prompts.length} prompt${manifest.prompts.length === 1 ? "" : "s"} to ${outDir}.`
       );
-      console.log(`Host runtime: ${manifest.host}`);
-      if (manifest.host === "vercel") {
-        console.log(`Vercel MCP function: ${path20.join(resolvedOutDir, VERCEL_ENTRYPOINT)}`);
+      console.log(`Host runtime: ${host}`);
+      if (host === "vercel") {
+        console.log(`Vercel MCP function: ${path19.join(outDir, VERCEL_ENTRYPOINT)}`);
       } else {
-        console.log(`Hostable MCP server: ${path20.join(resolvedOutDir, SERVER_ENTRYPOINT)}`);
+        console.log(`Hostable MCP server: ${path19.join(outDir, SERVER_ENTRYPOINT)}`);
       }
-      if (plugins ?? manifest.config.build.plugins) {
+      if (plugins) {
         console.log("Built claude-plugin package.");
       }
       return;
@@ -5702,7 +5243,7 @@ async function main(argv) {
       console.log(`Sidecar
 
 Usage:
-  sidecar build [--cwd <dir>] [--target mcp|chatgpt|claude] [--host node|vercel] [--out <dir>] [--plugins|--no-plugins] [--strict]
+  sidecar build [--cwd <dir>] [--target mcp|chatgpt|claude] [--host node|vercel] [--out <dir>] [--plugins] [--strict]
   sidecar check [--cwd <dir>] [--target mcp|chatgpt|claude] [--strict]
   sidecar dev [--cwd <dir>] [--target mcp|chatgpt|claude] [--port <port>] [--tunnel [cloudflared|wrangler]]
   sidecar inspect [--cwd <dir>] [--target mcp|chatgpt|claude]
@@ -5710,54 +5251,23 @@ Usage:
 `);
   }
 }
-function defaultBuildOutDir2(host, target) {
-  if (host === "vercel") {
-    return ".vercel/output";
-  }
-  return `out/${target}`;
-}
 function readTarget(argv) {
-  const target = readOptionalTarget(argv) ?? "mcp";
-  return target;
-}
-function readOptionalTarget(argv) {
-  const target = readOption(argv, "--target");
-  if (!target) {
-    return void 0;
-  }
+  const target = readOption(argv, "--target") ?? "mcp";
   if (target === "mcp" || target === "chatgpt" || target === "claude") {
     return target;
   }
   throw new Error(`Unsupported Sidecar target "${target}". Expected mcp, chatgpt, or claude.`);
 }
-function readOptionalHost(argv) {
-  const host = readOption(argv, "--host");
-  if (!host) {
-    return void 0;
-  }
+function readHost(argv) {
+  const host = readOption(argv, "--host") ?? "node";
   if (host === "node" || host === "vercel") {
     return host;
   }
   throw new Error(`Unsupported Sidecar host "${host}". Expected node or vercel.`);
 }
-function detectHostFromEnvironment() {
-  if (process.env.VERCEL === "1") {
-    return "vercel";
-  }
-  return void 0;
-}
-function readOptionalPlugins(argv) {
-  if (argv.includes("--plugins")) {
-    return true;
-  }
-  if (argv.includes("--no-plugins")) {
-    return false;
-  }
-  return void 0;
-}
 async function previewComponents(options) {
-  const cliDir = path20.dirname(fileURLToPath(import.meta.url));
-  const css = await readFile8(path20.join(cliDir, "../../native/src/styles.css"), "utf8").catch(() => readFile8(path20.join(process.cwd(), "packages/native/src/styles.css"), "utf8")).catch(() => "");
+  const cliDir = path19.dirname(fileURLToPath(import.meta.url));
+  const css = await readFile8(path19.join(cliDir, "../../native/src/styles.css"), "utf8").catch(() => readFile8(path19.join(process.cwd(), "packages/native/src/styles.css"), "utf8")).catch(() => "");
   const html = renderComponentPreviewHtml(
     options.host,
     options.compare,
@@ -5797,10 +5307,10 @@ async function previewComponents(options) {
   server.close();
 }
 async function writeComponentApproval(rootDir, approval) {
-  const dir = path20.join(rootDir, ".sidecar", "approvals");
+  const dir = path19.join(rootDir, ".sidecar", "approvals");
   await mkdir10(dir, { recursive: true });
   await writeFile10(
-    path20.join(dir, `components.${approval.host}.json`),
+    path19.join(dir, `components.${approval.host}.json`),
     `${JSON.stringify(approval, null, 2)}
 `
   );
@@ -6152,71 +5662,71 @@ function printDiagnostics(diagnostics) {
   }
 }
 async function loadRuntimeAuth(rootDir) {
-  const authPath = path20.join(rootDir, "auth.ts");
-  if (!existsSync7(authPath)) {
+  const authPath = path19.join(rootDir, "auth.ts");
+  if (!existsSync6(authPath)) {
     return void 0;
   }
-  const parentURL = pathToFileURL3(path20.join(rootDir, "sidecar.config.ts")).href;
-  const tsconfigPath = path20.join(rootDir, "tsconfig.json");
-  const tsconfig = existsSync7(tsconfigPath) ? tsconfigPath : false;
-  const module = await tsImport2(pathToFileURL3(authPath).href, {
+  const parentURL = pathToFileURL(path19.join(rootDir, "sidecar.config.ts")).href;
+  const tsconfigPath = path19.join(rootDir, "tsconfig.json");
+  const tsconfig = existsSync6(tsconfigPath) ? tsconfigPath : false;
+  const module = await tsImport(pathToFileURL(authPath).href, {
     parentURL,
     tsconfig
   });
-  const defaultExport = unwrapRuntimeDefault2(module.default);
+  const defaultExport = unwrapRuntimeDefault(module.default);
   if (!isSidecarAuth(defaultExport)) {
     throw new Error("auth.ts must default-export auth({ ... }) from sidecar-ai.");
   }
   return defaultExport;
 }
 async function loadRuntimeProxy(rootDir) {
-  const proxyPath = path20.join(rootDir, "proxy.ts");
-  if (!existsSync7(proxyPath)) {
+  const proxyPath = path19.join(rootDir, "proxy.ts");
+  if (!existsSync6(proxyPath)) {
     return void 0;
   }
-  const parentURL = pathToFileURL3(path20.join(rootDir, "sidecar.config.ts")).href;
-  const tsconfigPath = path20.join(rootDir, "tsconfig.json");
-  const tsconfig = existsSync7(tsconfigPath) ? tsconfigPath : false;
-  const module = await tsImport2(pathToFileURL3(proxyPath).href, {
+  const parentURL = pathToFileURL(path19.join(rootDir, "sidecar.config.ts")).href;
+  const tsconfigPath = path19.join(rootDir, "tsconfig.json");
+  const tsconfig = existsSync6(tsconfigPath) ? tsconfigPath : false;
+  const module = await tsImport(pathToFileURL(proxyPath).href, {
     parentURL,
     tsconfig
   });
-  const defaultExport = unwrapRuntimeDefault2(module.default);
+  const defaultExport = unwrapRuntimeDefault(module.default);
   if (!isSidecarProxy(defaultExport)) {
     throw new Error("proxy.ts must default-export proxy({ ... }) from @sidecar-ai/server/proxy.");
   }
   return defaultExport;
 }
 async function loadRuntimeConfig(rootDir) {
-  const configPath = path20.join(rootDir, "sidecar.config.ts");
-  if (!existsSync7(configPath)) {
+  const configPath = path19.join(rootDir, "sidecar.config.ts");
+  if (!existsSync6(configPath)) {
     return void 0;
   }
-  const parentURL = pathToFileURL3(configPath).href;
-  const tsconfigPath = path20.join(rootDir, "tsconfig.json");
-  const tsconfig = existsSync7(tsconfigPath) ? tsconfigPath : false;
-  const module = await tsImport2(pathToFileURL3(configPath).href, {
+  const parentURL = pathToFileURL(configPath).href;
+  const tsconfigPath = path19.join(rootDir, "tsconfig.json");
+  const tsconfig = existsSync6(tsconfigPath) ? tsconfigPath : false;
+  const module = await tsImport(pathToFileURL(configPath).href, {
     parentURL,
     tsconfig
   });
-  const defaultExport = unwrapRuntimeDefault2(module.default);
+  const defaultExport = unwrapRuntimeDefault(module.default);
   if (!defaultExport || typeof defaultExport !== "object") {
     throw new Error("sidecar.config.ts must default-export defineConfig({ ... }) from sidecar-ai.");
   }
   return defaultExport;
 }
 async function loadRuntimeTools(rootDir, entries) {
-  const parentURL = pathToFileURL3(path20.join(rootDir, "sidecar.config.ts")).href;
-  const tsconfigPath = path20.join(rootDir, "tsconfig.json");
-  const tsconfig = existsSync7(tsconfigPath) ? tsconfigPath : false;
+  const parentURL = pathToFileURL(path19.join(rootDir, "sidecar.config.ts")).href;
+  const tsconfigPath = path19.join(rootDir, "tsconfig.json");
+  const tsconfig = existsSync6(tsconfigPath) ? tsconfigPath : false;
   const loaded = [];
   for (const entry of entries) {
-    const sourcePath = path20.join(rootDir, entry.sourceFile);
-    const module = await tsImport2(pathToFileURL3(sourcePath).href, {
+    const sourcePath = path19.join(rootDir, entry.sourceFile);
+    const module = await tsImport(pathToFileURL(sourcePath).href, {
       parentURL,
       tsconfig
     });
-    const defaultExport = unwrapRuntimeDefault2(module.default);
+    const defaultExport = unwrapRuntimeDefault(module.default);
     if (!isSidecarTool(defaultExport)) {
       throw new Error(`${entry.sourceFile} did not default-export a Sidecar tool.`);
     }
@@ -6243,7 +5753,7 @@ async function loadResources(rootDir, outDir, manifest) {
     if (!entry.widget?.outputFile) {
       continue;
     }
-    const text = await readFile8(path20.join(rootDir, outDir, entry.widget.outputFile), "utf8");
+    const text = await readFile8(path19.join(rootDir, outDir, entry.widget.outputFile), "utf8");
     resources.push({
       uri: entry.widget.resourceUri,
       name: entry.name,
@@ -6253,16 +5763,16 @@ async function loadResources(rootDir, outDir, manifest) {
       _meta: entry.widget.resourceMeta
     });
   }
-  const parentURL = pathToFileURL3(path20.join(rootDir, "sidecar.config.ts")).href;
-  const tsconfigPath = path20.join(rootDir, "tsconfig.json");
-  const tsconfig = existsSync7(tsconfigPath) ? tsconfigPath : false;
+  const parentURL = pathToFileURL(path19.join(rootDir, "sidecar.config.ts")).href;
+  const tsconfigPath = path19.join(rootDir, "tsconfig.json");
+  const tsconfig = existsSync6(tsconfigPath) ? tsconfigPath : false;
   for (const entry of manifest.resources) {
-    const sourcePath = path20.join(rootDir, entry.sourceFile);
-    const module = await tsImport2(pathToFileURL3(sourcePath).href, {
+    const sourcePath = path19.join(rootDir, entry.sourceFile);
+    const module = await tsImport(pathToFileURL(sourcePath).href, {
       parentURL,
       tsconfig
     });
-    const defaultExport = unwrapRuntimeDefault2(module.default);
+    const defaultExport = unwrapRuntimeDefault(module.default);
     if (!isSidecarResource(defaultExport)) {
       throw new Error(`${entry.sourceFile} did not default-export a Sidecar resource.`);
     }
@@ -6275,17 +5785,17 @@ async function loadResources(rootDir, outDir, manifest) {
   return resources;
 }
 async function loadRuntimePrompts(rootDir, manifest) {
-  const parentURL = pathToFileURL3(path20.join(rootDir, "sidecar.config.ts")).href;
-  const tsconfigPath = path20.join(rootDir, "tsconfig.json");
-  const tsconfig = existsSync7(tsconfigPath) ? tsconfigPath : false;
+  const parentURL = pathToFileURL(path19.join(rootDir, "sidecar.config.ts")).href;
+  const tsconfigPath = path19.join(rootDir, "tsconfig.json");
+  const tsconfig = existsSync6(tsconfigPath) ? tsconfigPath : false;
   const loaded = [];
   for (const entry of manifest.prompts) {
-    const sourcePath = path20.join(rootDir, entry.sourceFile);
-    const module = await tsImport2(pathToFileURL3(sourcePath).href, {
+    const sourcePath = path19.join(rootDir, entry.sourceFile);
+    const module = await tsImport(pathToFileURL(sourcePath).href, {
       parentURL,
       tsconfig
     });
-    const defaultExport = unwrapRuntimeDefault2(module.default);
+    const defaultExport = unwrapRuntimeDefault(module.default);
     if (!isSidecarPrompt(defaultExport)) {
       throw new Error(`${entry.sourceFile} did not default-export a Sidecar prompt.`);
     }
@@ -6296,9 +5806,9 @@ async function loadRuntimePrompts(rootDir, manifest) {
   }
   return loaded;
 }
-function unwrapRuntimeDefault2(value) {
-  if (value && typeof value === "object" && "default" in value && Object.keys(value).every((key) => key === "default" || key === "__esModule")) {
-    return unwrapRuntimeDefault2(value.default);
+function unwrapRuntimeDefault(value) {
+  if (value && typeof value === "object" && "default" in value && Object.keys(value).length === 1) {
+    return unwrapRuntimeDefault(value.default);
   }
   return value;
 }
@@ -6332,7 +5842,7 @@ function isDirectRun() {
     return false;
   }
   const entryPath = realpathSync.native(entry);
-  return import.meta.url === pathToFileURL3(entryPath).href;
+  return import.meta.url === pathToFileURL(entryPath).href;
 }
 if (isDirectRun()) {
   main(process.argv).catch((error) => {