agents 0.14.4 → 0.15.0

package/dist/react.d.ts

@@ -1,7 +1,7 @@
 import {
   V as MCPServersState,
   d as AgentToolRunState
-} from "./agent-tool-types-V25Z_HcX.js";
+} from "./agent-tool-types-VPsjVYL0.js";
 import { ClientParameters } from "./serializable.js";
 import {
   AgentPromiseReturnType,

package/dist/serializable.d.ts

@@ -1,4 +1,4 @@
-import { $ as StreamingResponse } from "./agent-tool-types-V25Z_HcX.js";
+import { $ as StreamingResponse } from "./agent-tool-types-VPsjVYL0.js";
 
 //#region src/serializable.d.ts
 type SerializablePrimitive = undefined | null | string | number | boolean;

package/dist/skills/compile.d.ts

@@ -0,0 +1,40 @@
+//#region src/skills/compile.d.ts
+interface CompiledSkillScript {
+  /** Self-contained ESM source, ready to embed and run without a bundler. */
+  content: string;
+  /** Always `true`; mirrors the `precompiled` flag on skill resources. */
+  precompiled: true;
+}
+interface CompileSkillScriptOptions {
+  /**
+   * JavaScript target for the emitted bundle. Defaults to `es2022`, which the
+   * Workers runtime supports.
+   */
+  target?: string;
+}
+/**
+ * Whether a resource path is a skill script that should be compiled ahead of
+ * time (i.e. has a `.js`, `.mjs`, `.ts`, or `.tsx` extension).
+ */
+declare function isCompilableSkillScript(path: string): boolean;
+/**
+ * Compile a skill script file into a single self-contained ESM module.
+ *
+ * Resolves and inlines sibling imports relative to `entryPath`, strips
+ * TypeScript types, and emits ESM so the script can run in the Worker sandbox
+ * without an in-Worker bundler.
+ *
+ * @param entryPath Absolute path to the skill script file on disk.
+ */
+declare function compileSkillScript(
+  entryPath: string,
+  options?: CompileSkillScriptOptions
+): Promise<CompiledSkillScript>;
+//#endregion
+export {
+  CompileSkillScriptOptions,
+  CompiledSkillScript,
+  compileSkillScript,
+  isCompilableSkillScript
+};
+//# sourceMappingURL=compile.d.ts.map

package/dist/skills/compile.js

@@ -0,0 +1,65 @@
+import { build } from "esbuild";
+//#region src/skills/compile.ts
+/**
+* Build-time skill-script compiler.
+*
+* Skill scripts must be self-contained JavaScript modules before they can run:
+* the Worker runtime executes them directly through the sandbox and does **not**
+* ship an in-Worker bundler. This module compiles a skill script (TypeScript or
+* multi-file JavaScript) into a single self-contained ESM bundle using esbuild.
+*
+* It runs in Node (build time) only — the Agents Vite plugin uses it to compile
+* bundled skills, and skills served from R2 or other dynamic sources should be
+* compiled with {@link compileSkillScript} before upload.
+*
+* @module
+*/
+/** Skill-script extensions that can (and must) be compiled ahead of time. */
+const COMPILABLE_SCRIPT_EXTENSIONS = new Set([
+	".js",
+	".mjs",
+	".ts",
+	".tsx"
+]);
+function extensionOf(path) {
+	const file = path.split("/").at(-1) ?? path;
+	const index = file.lastIndexOf(".");
+	return index === -1 ? "" : file.slice(index).toLowerCase();
+}
+/**
+* Whether a resource path is a skill script that should be compiled ahead of
+* time (i.e. has a `.js`, `.mjs`, `.ts`, or `.tsx` extension).
+*/
+function isCompilableSkillScript(path) {
+	return COMPILABLE_SCRIPT_EXTENSIONS.has(extensionOf(path));
+}
+/**
+* Compile a skill script file into a single self-contained ESM module.
+*
+* Resolves and inlines sibling imports relative to `entryPath`, strips
+* TypeScript types, and emits ESM so the script can run in the Worker sandbox
+* without an in-Worker bundler.
+*
+* @param entryPath Absolute path to the skill script file on disk.
+*/
+async function compileSkillScript(entryPath, options = {}) {
+	const output = (await build({
+		entryPoints: [entryPath],
+		bundle: true,
+		write: false,
+		format: "esm",
+		platform: "browser",
+		target: options.target ?? "es2022",
+		logLevel: "silent",
+		legalComments: "none"
+	})).outputFiles?.[0];
+	if (!output) throw new Error(`esbuild produced no output when compiling skill script "${entryPath}".`);
+	return {
+		content: output.text,
+		precompiled: true
+	};
+}
+//#endregion
+export { compileSkillScript, isCompilableSkillScript };
+
+//# sourceMappingURL=compile.js.map

package/dist/skills/compile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.js","names":[],"sources":["../../src/skills/compile.ts"],"sourcesContent":["import { build } from \"esbuild\";\n\n/**\n * Build-time skill-script compiler.\n *\n * Skill scripts must be self-contained JavaScript modules before they can run:\n * the Worker runtime executes them directly through the sandbox and does **not**\n * ship an in-Worker bundler. This module compiles a skill script (TypeScript or\n * multi-file JavaScript) into a single self-contained ESM bundle using esbuild.\n *\n * It runs in Node (build time) only — the Agents Vite plugin uses it to compile\n * bundled skills, and skills served from R2 or other dynamic sources should be\n * compiled with {@link compileSkillScript} before upload.\n *\n * @module\n */\n\n/** Skill-script extensions that can (and must) be compiled ahead of time. */\nconst COMPILABLE_SCRIPT_EXTENSIONS = new Set([\".js\", \".mjs\", \".ts\", \".tsx\"]);\n\nexport interface CompiledSkillScript {\n  /** Self-contained ESM source, ready to embed and run without a bundler. */\n  content: string;\n  /** Always `true`; mirrors the `precompiled` flag on skill resources. */\n  precompiled: true;\n}\n\nexport interface CompileSkillScriptOptions {\n  /**\n   * JavaScript target for the emitted bundle. Defaults to `es2022`, which the\n   * Workers runtime supports.\n   */\n  target?: string;\n}\n\nfunction extensionOf(path: string): string {\n  const file = path.split(\"/\").at(-1) ?? path;\n  const index = file.lastIndexOf(\".\");\n  return index === -1 ? \"\" : file.slice(index).toLowerCase();\n}\n\n/**\n * Whether a resource path is a skill script that should be compiled ahead of\n * time (i.e. has a `.js`, `.mjs`, `.ts`, or `.tsx` extension).\n */\nexport function isCompilableSkillScript(path: string): boolean {\n  return COMPILABLE_SCRIPT_EXTENSIONS.has(extensionOf(path));\n}\n\n/**\n * Compile a skill script file into a single self-contained ESM module.\n *\n * Resolves and inlines sibling imports relative to `entryPath`, strips\n * TypeScript types, and emits ESM so the script can run in the Worker sandbox\n * without an in-Worker bundler.\n *\n * @param entryPath Absolute path to the skill script file on disk.\n */\nexport async function compileSkillScript(\n  entryPath: string,\n  options: CompileSkillScriptOptions = {}\n): Promise<CompiledSkillScript> {\n  const result = await build({\n    entryPoints: [entryPath],\n    bundle: true,\n    write: false,\n    format: \"esm\",\n    platform: \"browser\",\n    target: options.target ?? \"es2022\",\n    logLevel: \"silent\",\n    legalComments: \"none\"\n  });\n\n  const output = result.outputFiles?.[0];\n  if (!output) {\n    throw new Error(\n      `esbuild produced no output when compiling skill script \"${entryPath}\".`\n    );\n  }\n\n  return { content: output.text, precompiled: true };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAkBA,MAAM,+BAA+B,IAAI,IAAI;CAAC;CAAO;CAAQ;CAAO;AAAM,CAAC;AAiB3E,SAAS,YAAY,MAAsB;CACzC,MAAM,OAAO,KAAK,MAAM,GAAG,CAAC,CAAC,GAAG,EAAE,KAAK;CACvC,MAAM,QAAQ,KAAK,YAAY,GAAG;CAClC,OAAO,UAAU,KAAK,KAAK,KAAK,MAAM,KAAK,CAAC,CAAC,YAAY;AAC3D;;;;;AAMA,SAAgB,wBAAwB,MAAuB;CAC7D,OAAO,6BAA6B,IAAI,YAAY,IAAI,CAAC;AAC3D;;;;;;;;;;AAWA,eAAsB,mBACpB,WACA,UAAqC,CAAC,GACR;CAY9B,MAAM,UAAS,MAXM,MAAM;EACzB,aAAa,CAAC,SAAS;EACvB,QAAQ;EACR,OAAO;EACP,QAAQ;EACR,UAAU;EACV,QAAQ,QAAQ,UAAU;EAC1B,UAAU;EACV,eAAe;CACjB,CAAC,EAAA,CAEqB,cAAc;CACpC,IAAI,CAAC,QACH,MAAM,IAAI,MACR,2DAA2D,UAAU,GACvE;CAGF,OAAO;EAAE,SAAS,OAAO;EAAM,aAAa;CAAK;AACnD"}

package/dist/skills/index.d.ts

@@ -38,6 +38,14 @@ interface SkillResourceDescriptor {
   size?: number;
   encoding?: "text" | "base64";
   mimeType?: string;
+  /**
+   * Set when a script resource was compiled to a self-contained JavaScript
+   * module ahead of time — by the Agents Vite plugin for bundled skills, or via
+   * `compileSkillScript` from `agents/skills/compile` for R2/dynamic skills. The
+   * runtime runs precompiled scripts directly; the runtime ships no in-Worker
+   * bundler, so non-precompiled TypeScript or multi-file scripts cannot run.
+   */
+  precompiled?: boolean;
 }
 interface SkillResource extends SkillResourceDescriptor {
   content: string;

package/dist/skills/index.js

@@ -505,45 +505,42 @@ function scriptModule(source, request) {
 		"}"
 	].join("\n");
 }
-function moduleSource(module) {
-	if (typeof module === "string") return module;
-	return module?.js ?? module?.cjs ?? null;
+/**
+* Whether a script declares a default export, in either the raw author form
+* (`export default ...`) or the bundled form esbuild emits
+* (`export { run as default }`).
+*/
+function hasDefaultExport(source) {
+	return /^\s*export\s+default\s+/m.test(source) || /export\s*\{[^}]*\bas\s+default\b[^}]*\}/m.test(source);
 }
 /**
-* Remove `export { ... }` blocks (illegal inside the function wrapper) and
-* rewrite a `export { X as default }` binding to the local `__skillRun`.
+* Remove `export { ... }` blocks, which are illegal inside the function wrapper
+* the runner builds around skill scripts.
 */
 function stripStrayExports(source) {
 	return source.replace(/\n?export\s*\{[\s\S]*?\};?/g, "");
 }
 function rewriteBundledSource(source) {
-	const defaultExport = source.match(/export\s*\{\s*([A-Za-z_$][\w$]*)\s+as\s+default\s*\};?/m);
-	let out = source;
-	if (defaultExport) out = out.replace(defaultExport[0], `const __skillRun = ${defaultExport[1]};`);
-	return stripStrayExports(out);
+	const defaultBinding = source.match(/\bexport\s*\{[^}]*\b([A-Za-z_$][\w$]*)\s+as\s+default\b[^}]*\}/m);
+	const stripped = stripStrayExports(source);
+	if (defaultBinding) return `${stripped}\nconst __skillRun = ${defaultBinding[1]};`;
+	return stripped;
 }
 async function prepareJavaScriptSource(request, runtime) {
-	const files = {};
+	if ((request.resources ?? []).some((resource) => resource.path === request.path && resource.precompiled === true)) return rewriteBundledSource(request.source);
+	let scriptFileCount = 1;
 	for (const resource of request.resources ?? []) {
+		if (resource.path === request.path) continue;
 		const extension = extensionOf(resource.path);
 		if (resource.kind === "script" && (resource.encoding ?? "text") === "text" && [
 			".js",
 			".mjs",
 			".ts",
 			".tsx"
-		].includes(extension)) files[resource.path] = resource.content;
+		].includes(extension)) scriptFileCount++;
 	}
-	files[request.path] = request.source;
-	if (!(runtime === "typescript" || Object.keys(files).length > 1)) return request.source;
-	const { createWorker } = await import("@cloudflare/worker-bundler");
-	const result = await createWorker({
-		files,
-		entryPoint: request.path,
-		bundle: true
-	});
-	const compiled = moduleSource(result.modules[result.mainModule]) ?? moduleSource(Object.values(result.modules)[0]);
-	if (!compiled) throw new Error(`Failed to compile skill script: ${request.path}`);
-	return rewriteBundledSource(compiled);
+	if (runtime === "javascript" && scriptFileCount === 1) return request.source;
+	throw new Error(`Skill script "${request.path}" must be compiled to a self-contained JavaScript module before it can run. Bundled skills are compiled automatically by the Agents Vite plugin. Skills served from R2 or other dynamic sources must be bundled ahead of time (e.g. with \`compileSkillScript\` from "agents/skills/compile") before upload.`);
 }
 async function executeToolFromSet(tools, name, input) {
 	const target = tools?.[name];
@@ -1052,7 +1049,7 @@ async function runBashScript(request, options, bridge) {
 	}
 }
 async function runJavaScriptScript(request, options, bridge, runtime) {
-	if (!/^\s*export\s+default\s+/m.test(request.source)) throw new Error("JS/TS skill scripts must `export default` an async run(input, ctx) function.");
+	if (!hasDefaultExport(request.source)) throw new Error("JS/TS skill scripts must `export default` an async run(input, ctx) function.");
 	const source = await prepareJavaScriptSource(request, runtime);
 	const result = await new DynamicWorkerExecutor({
 		loader: options.loader,