npm - @sidecar-ai/cli - Versions diffs - 0.1.0-alpha.10 → 0.1.0-alpha.4 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/dist/index.js CHANGED Viewed

@@ -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) => {