veryfront 0.1.367 → 0.1.369

package/src/extensions/ext-esbuild/src/es-module-lexer.ts

@@ -0,0 +1,34 @@
+/**
+ * es-module-lexer-backed implementation of the {@link ModuleLexer} contract.
+ *
+ * es-module-lexer@2 exports `init` as a Promise in its ESM build but older
+ * typings expect a function. We tolerate both shapes (as the in-tree
+ * src/transforms/esm/lexer.ts did).
+ *
+ * @module extensions/ext-esbuild/es-module-lexer
+ */
+
+import type { ImportSpecifier, ModuleLexer } from "../../../src/extensions/interfaces/index.js";
+import { init, parse } from "es-module-lexer";
+
+/** es-module-lexer-backed {@link ModuleLexer} implementation. */
+export class EsModuleLexer implements ModuleLexer {
+  private initPromise: Promise<void> | null = null;
+
+  async init(): Promise<void> {
+    if (this.initPromise) {
+      await this.initPromise;
+      return;
+    }
+    const anyInit = init as unknown;
+    this.initPromise = typeof anyInit === "function"
+      ? (anyInit as () => Promise<void>)()
+      : (anyInit as Promise<void>);
+    await this.initPromise;
+  }
+
+  parse(code: string): readonly ImportSpecifier[] {
+    const [imports] = parse(code);
+    return imports as readonly ImportSpecifier[];
+  }
+}

package/src/extensions/ext-esbuild/src/esbuild-bundler.ts

@@ -0,0 +1,122 @@
+/**
+ * esbuild-backed implementation of the {@link Bundler} contract.
+ *
+ * Lazy-initializes the esbuild binary (including `deno compile` VFS
+ * extraction) on first use. All options pass through to esbuild unchanged
+ * because the {@link BundleOptions} shape was designed to be esbuild-compatible;
+ * the only translation is converting {@link BundlerPlugin}s into esbuild
+ * plugins via {@link toEsbuildPlugin}.
+ *
+ * @module extensions/ext-esbuild/esbuild-bundler
+ */
+
+import type {
+  BuildContext,
+  BundleOptions,
+  BundleOutput,
+  Bundler,
+  BundleResult,
+  BundlerMessage,
+  Metafile,
+  TransformOptions,
+  TransformResult,
+} from "../../../src/extensions/interfaces/index.js";
+
+import { ensureEsbuildBinary } from "./binary.js";
+import { toEsbuildPlugin } from "./plugin-adapter.js";
+
+// deno-lint-ignore no-explicit-any
+type EsbuildModule = any;
+
+let esbuildModule: EsbuildModule | null = null;
+
+async function getEsbuild(): Promise<EsbuildModule> {
+  await ensureEsbuildBinary();
+  if (esbuildModule) return esbuildModule;
+  esbuildModule = await import("esbuild");
+  return esbuildModule;
+}
+
+// deno-lint-ignore no-explicit-any
+function toMessage(m: any): BundlerMessage {
+  return {
+    text: m.text,
+    location: m.location ?? null,
+    notes: m.notes,
+    pluginName: m.pluginName,
+    detail: m.detail,
+  };
+}
+
+// deno-lint-ignore no-explicit-any
+function toMessages(ms: any[] | undefined): BundlerMessage[] {
+  return (ms ?? []).map(toMessage);
+}
+
+// deno-lint-ignore no-explicit-any
+function toOutput(f: any): BundleOutput {
+  return {
+    path: f.path,
+    contents: f.contents,
+    text: f.text,
+    hash: f.hash,
+  };
+}
+
+function mapOptions(options: BundleOptions): Record<string, unknown> {
+  const { plugins, ...rest } = options;
+  const mapped: Record<string, unknown> = { ...rest };
+  if (plugins && plugins.length > 0) {
+    mapped.plugins = plugins.map(toEsbuildPlugin);
+  }
+  return mapped;
+}
+
+/** esbuild-backed {@link Bundler} implementation. */
+export class EsbuildBundler implements Bundler {
+  async bundle(options: BundleOptions): Promise<BundleResult> {
+    const esbuild = await getEsbuild();
+    const result = await esbuild.build(mapOptions(options));
+    return {
+      outputFiles: (result.outputFiles ?? []).map(toOutput),
+      warnings: toMessages(result.warnings),
+      errors: toMessages(result.errors),
+      metafile: result.metafile as Metafile | undefined,
+    };
+  }
+
+  async transform(options: TransformOptions): Promise<TransformResult> {
+    const esbuild = await getEsbuild();
+    const { code, ...rest } = options;
+    const result = await esbuild.transform(code, rest);
+    return {
+      code: result.code,
+      map: result.map,
+      warnings: toMessages(result.warnings).map((m) => m.text),
+    };
+  }
+
+  async context(options: BundleOptions): Promise<BuildContext> {
+    const esbuild = await getEsbuild();
+    const ctx = await esbuild.context(mapOptions(options));
+    return {
+      rebuild: async () => {
+        const result = await ctx.rebuild();
+        return {
+          outputFiles: (result.outputFiles ?? []).map(toOutput),
+          warnings: toMessages(result.warnings),
+          errors: toMessages(result.errors),
+          metafile: result.metafile as Metafile | undefined,
+        };
+      },
+      dispose: () => ctx.dispose(),
+    };
+  }
+
+  async stop(): Promise<void> {
+    const m = esbuildModule;
+    if (!m) return;
+    esbuildModule = null;
+    await m.stop();
+  }
+}

package/src/extensions/ext-esbuild/src/index.ts

@@ -0,0 +1,46 @@
+/**
+ * ext-esbuild — Bundler + ModuleLexer contract implementations backed by
+ * esbuild and es-module-lexer.
+ *
+ * @module extensions/ext-esbuild
+ */
+
+import type { ExtensionFactory } from "../../../src/extensions/index.js";
+
+import { EsbuildBundler } from "./esbuild-bundler.js";
+import { EsModuleLexer } from "./es-module-lexer.js";
+
+/**
+ * Default export — the ext-esbuild extension factory.
+ *
+ * Registers both the `Bundler` (esbuild-backed) and `ModuleLexer`
+ * (es-module-lexer-backed) contracts.
+ */
+const extEsbuild: ExtensionFactory = () => {
+  const bundler = new EsbuildBundler();
+  const lexer = new EsModuleLexer();
+
+  return {
+    name: "ext-esbuild",
+    version: "0.1.0",
+    capabilities: [
+      { type: "contract", name: "Bundler" },
+      { type: "contract", name: "ModuleLexer" },
+    ],
+    setup(ctx) {
+      if (!ctx.get("Bundler")) {
+        ctx.provide("Bundler", bundler);
+      }
+      if (!ctx.get("ModuleLexer")) {
+        ctx.provide("ModuleLexer", lexer);
+      }
+      ctx.logger.info("[ext-esbuild] Bundler + ModuleLexer registered");
+    },
+    async teardown() {
+      await bundler.stop?.();
+    },
+  };
+};
+
+export default extEsbuild;
+export { EsbuildBundler, EsModuleLexer };

package/src/extensions/ext-esbuild/src/plugin-adapter.ts

@@ -0,0 +1,66 @@
+/**
+ * Plugin adapter — converts {@link BundlerPlugin} (the bundler-agnostic
+ * contract shape) into an esbuild `Plugin`. The contract's onResolve /
+ * onLoad shapes were deliberately designed to match esbuild's, so the
+ * translation is near-1:1; this module exists to isolate the esbuild
+ * import from the rest of the extension.
+ *
+ * @module extensions/ext-esbuild/plugin-adapter
+ */
+
+import type {
+  BundlerPlugin,
+  BundlerPluginBuild,
+  OnLoadArgs,
+  OnLoadResult,
+  OnResolveArgs,
+  OnResolveResult,
+} from "../../../src/extensions/interfaces/index.js";
+// deno-lint-ignore no-explicit-any
+type EsbuildPlugin = any;
+
+export function toEsbuildPlugin(plugin: BundlerPlugin): EsbuildPlugin {
+  return {
+    name: plugin.name,
+    // deno-lint-ignore no-explicit-any
+    setup(build: any) {
+      const bridged: BundlerPluginBuild = {
+        onResolve(options, callback) {
+          // deno-lint-ignore no-explicit-any
+          build.onResolve(options, async (args: any) => {
+            const resolveArgs: OnResolveArgs = {
+              path: args.path,
+              importer: args.importer,
+              namespace: args.namespace,
+              resolveDir: args.resolveDir,
+              kind: args.kind,
+              pluginData: args.pluginData,
+            };
+            const result = await callback(resolveArgs);
+            if (result == null) return result ?? null;
+            return result as OnResolveResult;
+          });
+        },
+        onLoad(options, callback) {
+          // deno-lint-ignore no-explicit-any
+          build.onLoad(options, async (args: any) => {
+            const loadArgs: OnLoadArgs = {
+              path: args.path,
+              namespace: args.namespace,
+              suffix: args.suffix,
+              pluginData: args.pluginData,
+            };
+            const result = await callback(loadArgs);
+            if (result == null) return result ?? null;
+            return result as OnLoadResult;
+          });
+        },
+        onDispose(callback) {
+          build.onDispose(callback);
+        },
+      };
+
+      plugin.setup(bridged);
+    },
+  };
+}

package/src/extensions/ext-esbuild/src/runtime.ts

@@ -0,0 +1,54 @@
+/**
+ * Runtime detection — inlined from src/platform/compat/runtime.ts so the
+ * extension stays dependency-free on core.
+ *
+ * Only the bits needed by the esbuild binary extractor are included here.
+ *
+ * @module extensions/ext-esbuild/runtime
+ */
+import * as dntShim from "../../../_dnt.shims.js";
+
+
+type GlobalWithRuntime = typeof dntShim.dntGlobalThis & {
+  process?: { versions?: { node?: string; deno?: string } };
+  Bun?: unknown;
+};
+
+function hasRealDeno(): boolean {
+  return (
+    typeof dntShim.Deno !== "undefined" &&
+    typeof dntShim.Deno.version === "object" &&
+    typeof dntShim.Deno.build === "object" &&
+    typeof dntShim.Deno.build.os === "string"
+  );
+}
+
+function hasBunGlobal(): boolean {
+  return (dntShim.dntGlobalThis as GlobalWithRuntime).Bun != null;
+}
+
+function hasNodeProcess(): boolean {
+  const g = dntShim.dntGlobalThis as GlobalWithRuntime;
+  return g.process?.versions?.node != null && !g.process?.versions?.deno;
+}
+
+export const isDeno: boolean = !hasNodeProcess() && !hasBunGlobal() && hasRealDeno();
+
+function testDenoCompiledDetection(execPath: string): boolean {
+  if (!execPath) return false;
+  const binary = execPath.split(/[/\\]/).pop()?.toLowerCase();
+  if (!binary) return false;
+  return binary !== "deno" && binary !== "deno.exe";
+}
+
+function isDenoCompiledBinary(): boolean {
+  if (!hasRealDeno()) return false;
+  try {
+    return testDenoCompiledDetection(dntShim.Deno.execPath());
+  } catch {
+    return false;
+  }
+}
+
+/** True if running inside a `deno compile`'d binary (needs VFS extraction). */
+export const isDenoCompiled: boolean = isDeno && isDenoCompiledBinary();

package/src/src/agent/conversation-bootstrap.ts

@@ -216,7 +216,7 @@ export async function bootstrapConversationAgentRun(input: {
   handoffMessageBody: unknown;
   runId?: string;
   agentId: string;
-  runtimeProviderId?: string | null;
+  implementationKind?: string | null;
   projectId?: string | null;
   branchId?: string | null;
 }): Promise<BootstrapConversationAgentRunResult> {
@@ -247,7 +247,7 @@ export async function bootstrapConversationAgentRun(input: {
     conversationId: conversation.id,
     runId: input.runId,
     agentId: input.agentId,
-    runtimeProviderId: input.runtimeProviderId,
+    implementationKind: input.implementationKind,
     projectId: effectiveProjectId,
     branchId: input.branchId,
   });

package/src/src/agent/conversation-root-run-context.ts

@@ -57,7 +57,7 @@ export async function startConversationRootRun(input: {
   projectId?: string | null;
   branchId?: string | null;
   agentId: string;
-  runtimeProviderId?: string | null;
+  implementationKind?: string | null;
   providedRun?: ConversationRootRunDescriptor;
 }): Promise<ConversationRunProjection | null> {
   if (input.providedRun) {
@@ -82,7 +82,7 @@ export async function startConversationRootRun(input: {
     projectId: input.projectId ?? null,
     branchId: input.branchId,
     agentId: input.agentId,
-    runtimeProviderId: input.runtimeProviderId,
+    implementationKind: input.implementationKind,
   });
 }
 
@@ -93,7 +93,7 @@ export function createConversationRootRunStartAdapter(input: {
   projectId?: string | null;
   branchId?: string | null;
   agentId: string;
-  runtimeProviderId?: string | null;
+  implementationKind?: string | null;
   providedRun?: ConversationRootRunDescriptor;
 }): (input: { abortSignal: AbortSignal }) => Promise<{ run: ConversationRunProjection | null }> {
   return async () => ({
@@ -104,7 +104,7 @@ export function createConversationRootRunStartAdapter(input: {
       projectId: input.projectId,
       branchId: input.branchId,
       agentId: input.agentId,
-      runtimeProviderId: input.runtimeProviderId,
+      implementationKind: input.implementationKind,
       providedRun: input.providedRun,
     }),
   });
@@ -117,7 +117,7 @@ export async function prepareConversationRootRunContext(input: {
   projectId?: string | null;
   branchId?: string | null;
   agentId: string;
-  runtimeProviderId?: string | null;
+  implementationKind?: string | null;
   providedRun?: ConversationRootRunDescriptor;
   parentRunId?: string;
   parentMessageId?: string;
@@ -130,7 +130,7 @@ export async function prepareConversationRootRunContext(input: {
     projectId: input.projectId,
     branchId: input.branchId,
     agentId: input.agentId,
-    runtimeProviderId: input.runtimeProviderId,
+    implementationKind: input.implementationKind,
     providedRun: input.providedRun,
   })({ abortSignal: new AbortController().signal });
 

package/src/src/agent/durable.ts

@@ -294,7 +294,7 @@ export interface CreateConversationAgentRunInput {
   conversationId: string;
   runId?: string;
   agentId: string;
-  runtimeProviderId?: string | null;
+  implementationKind?: string | null;
   projectId?: string | null;
   branchId?: string | null;
 }
@@ -1257,11 +1257,11 @@ export async function createConversationAgentRun(
   });
   const runId = input.runId ?? `run_${dntShim.crypto.randomUUID()}`;
 
-  const request = input.runtimeProviderId
+  const request = input.implementationKind
     ? {
       mode: "agent" as const,
       agent_id: input.agentId,
-      runtime_provider_id: input.runtimeProviderId,
+      implementation_kind: input.implementationKind,
       initial_status: "pending" as const,
       ...(targets.sourceTargetKind ? { source_target_kind: targets.sourceTargetKind } : {}),
       ...(targets.runtimeTargetKind ? { runtime_target_kind: targets.runtimeTargetKind } : {}),

package/src/src/agent/fork-runtime-stream.ts

@@ -1,5 +1,11 @@
 import * as dntShim from "../../_dnt.shims.js";
-import type { Tool } from "../tool/index.js";
+import {
+  createToolsFromHostDefinitions,
+  type HostToolSet,
+  type Tool,
+  traceHostTools,
+  type TraceHostToolsOptions,
+} from "../tool/index.js";
 import { isRecord } from "../chat/conversation.js";
 import { safeJsonParse } from "../chat/provider-errors.js";
 import { runWithVeryfrontCloudContextAsync } from "../provider/veryfront-cloud/context.js";
@@ -14,6 +20,7 @@ import {
   HOSTED_CHILD_STREAM_TIMEOUT_TOKEN,
   resolveHostedChildPromiseWithTimeout,
 } from "./hosted-child-stream-watchdog.js";
+import { getForkRuntimeAllowedToolNames } from "./provider-native-tool-inventory.js";
 import { AgentRuntime } from "./runtime/index.js";
 import type { AgentResponse, Message as AgentMessage } from "./schemas/index.js";
 
@@ -201,6 +208,59 @@ export type StartAgentRuntimeForkInput = {
   runStep?: AgentRuntimeForkStepRunner;
 };
 
+export type StartAgentRuntimeForkWithHostToolsInput =
+  & Omit<
+    StartAgentRuntimeForkInput,
+    "forkToolNames" | "model" | "runtimeTools"
+  >
+  & {
+    provider: string;
+    forkModel: string;
+    forkTools: HostToolSet;
+    traceTools?: TraceHostToolsOptions;
+  };
+
+export function startAgentRuntimeForkWithHostTools(
+  input: StartAgentRuntimeForkWithHostToolsInput,
+): {
+  streamResult: ForkRuntimeStreamResult;
+  forkToolNames: string[];
+} {
+  const forkTools = input.traceTools
+    ? traceHostTools(input.forkTools, input.traceTools)
+    : input.forkTools;
+  const runtimeTools = createToolsFromHostDefinitions(forkTools);
+  const forkToolNames = getForkRuntimeAllowedToolNames({
+    provider: input.provider,
+    forkModel: input.forkModel,
+    forkTools: input.forkTools,
+  });
+
+  return {
+    streamResult: startAgentRuntimeFork({
+      apiUrl: input.apiUrl,
+      authToken: input.authToken,
+      projectId: input.projectId,
+      model: input.forkModel,
+      maxSteps: input.maxSteps,
+      prompt: input.prompt,
+      maxContinuationSteps: input.maxContinuationSteps,
+      abortSignal: input.abortSignal,
+      forkToolNames,
+      runtimeTools,
+      providerOptions: input.providerOptions,
+      buildInstructions: input.buildInstructions,
+      onBeforeStop: input.onBeforeStop,
+      initialMessages: input.initialMessages,
+      responseTimeoutMs: input.responseTimeoutMs,
+      logger: input.logger,
+      prepareStep: input.prepareStep,
+      runStep: input.runStep,
+    }),
+    forkToolNames,
+  };
+}
+
 function createForkRuntimeDeferred<T>(): {
   promise: Promise<T>;
   resolve: (value: T | PromiseLike<T>) => void;

package/src/src/agent/hosted-child-bootstrap.ts

@@ -18,7 +18,7 @@ export interface BootstrapHostedChildRunInput extends HostedChildConversationBod
   prompt: string;
   runId?: string;
   agentId: string;
-  runtimeProviderId?: string | null;
+  implementationKind?: string | null;
   branchId?: string | null;
 }
 
@@ -59,7 +59,7 @@ export async function bootstrapHostedChildRun(
     },
     runId: input.runId,
     agentId: input.agentId,
-    runtimeProviderId: input.runtimeProviderId,
+    implementationKind: input.implementationKind,
     projectId: input.runProjectId ?? null,
     branchId: input.branchId,
   });

package/src/src/agent/index.ts

@@ -316,6 +316,8 @@ export {
   shouldContinueForkRuntimeStep,
   startAgentRuntimeFork,
   type StartAgentRuntimeForkInput,
+  startAgentRuntimeForkWithHostTools,
+  type StartAgentRuntimeForkWithHostToolsInput,
 } from "./fork-runtime-stream.js";
 export {
   executeHostedChildForkStream,

package/src/src/build/bundler/code-splitter/build-context.ts

@@ -3,7 +3,7 @@
  * @module code-splitter/build-context
  */
 
-import { type BuildContext, context } from "esbuild";
+import { type BuildContext, context } from "../../../extensions/bundler.js";
 import { join } from "../../../platform/compat/path/index.js";
 import { createFileSystem } from "../../../platform/compat/fs.js";
 import { getReactImportMap, REACT_DEFAULT_VERSION } from "../../../utils/index.js";

package/src/src/build/bundler/code-splitter/esbuild-plugin.ts

@@ -3,7 +3,7 @@ import {
   getReactImportMap,
   REACT_DEFAULT_VERSION,
 } from "../../../utils/index.js";
-import type { OnResolveArgs, Plugin, PluginBuild } from "esbuild";
+import type { OnResolveArgs, Plugin, PluginBuild } from "../../../extensions/bundler.js";
 import { join } from "../../../platform/compat/path/index.js";
 
 export function createSplitterPlugin(projectDir: string): Plugin {

package/src/src/build/bundler/code-splitter/manifest-builder.ts

@@ -5,7 +5,7 @@
 import * as dntShim from "../../../../_dnt.shims.js";
 
 
-import type { Metafile } from "esbuild";
+import type { Metafile } from "../../../extensions/bundler.js";
 import { join, relative } from "../../../platform/compat/path/index.js";
 import { createFileSystem } from "../../../platform/compat/fs.js";
 import type { ChunkInfo, ChunkManifest, MetafileOutput } from "./types.js";

package/src/src/build/bundler/code-splitter/splitter.ts

@@ -1,5 +1,5 @@
 import { bundlerLogger as logger } from "../../../utils/index.js";
-import type { Metafile } from "esbuild";
+import type { Metafile } from "../../../extensions/bundler.js";
 import { ensureDir } from "../../../../deps/jsr.io/@std/fs/1.0.23/mod.js";
 import { relative } from "../../../platform/compat/path/index.js";
 import type { ChunkInfo, SplitOptions, SplitResult } from "./types.js";

package/src/src/build/bundler/code-splitter/types.ts

@@ -1,4 +1,4 @@
-import type { Metafile } from "esbuild";
+import type { Metafile } from "../../../extensions/bundler.js";
 
 export type MetafileOutput = Metafile["outputs"][string];
 

package/src/src/build/compiler/mdx-compiler/transpiler.ts

@@ -1,4 +1,4 @@
-import * as esbuild from "esbuild";
+import * as esbuild from "../../../extensions/bundler.js";
 import type { CompileOptions } from "./types.js";
 
 export async function transpileCode(code: string, options: CompileOptions): Promise<string> {

package/src/src/build/compiler/mdx-to-js.ts

@@ -1,6 +1,6 @@
 import { compile as compileMdx } from "@mdx-js/mdx";
 import { bundlerLogger as logger } from "../../utils/index.js";
-import * as esbuild from "esbuild";
+import * as esbuild from "../../extensions/bundler.js";
 import { extract } from "../../platform/compat/std/front-matter-yaml.js";
 import type { RuntimeAdapter } from "../../platform/adapters/base.js";
 import { createError, toError } from "../../errors/veryfront-error.js";

package/src/src/build/embedded/preset.ts

@@ -1,7 +1,7 @@
 import * as dntShim from "../../../_dnt.shims.js";
 import { bundlerLogger as logger } from "../../utils/index.js";
 import { createError, toError } from "../../errors/veryfront-error.js";
-import * as esbuild from "esbuild";
+import * as esbuild from "../../extensions/bundler.js";
 import { join } from "../../platform/compat/path/index.js";
 import { compileMDXToJS } from "../compiler/index.js";
 import { runtime } from "../../platform/adapters/detect.js";

package/src/src/build/production-build/client-runtime.ts

@@ -14,7 +14,7 @@ import {
   resolve,
 } from "../../platform/compat/path/index.js";
 import { serverLogger as logger } from "../../utils/index.js";
-import type { OnResolveArgs, Plugin } from "esbuild";
+import type { OnResolveArgs, Plugin } from "../../extensions/bundler.js";
 import type { RuntimeAdapter } from "../../platform/adapters/base.js";
 import { createError, toError } from "../../errors/veryfront-error.js";
 import { createFileSystem } from "../../platform/compat/fs.js";
@@ -305,7 +305,7 @@ function createFsLoaderPlugin(): Plugin {
 }
 
 async function bundleClientEntry(entryRelative: string): Promise<string> {
-  const { build, stop } = await import("esbuild");
+  const { build, stop } = await import("../../extensions/bundler.js");
   const entryUrl = new URL(entryRelative, import.meta.url);
   const shimUrl = new URL("../../rendering/client/browser-stubs/logger.ts", import.meta.url);
 

package/src/src/discovery/transpiler.ts

@@ -7,7 +7,7 @@
 import * as dntShim from "../../_dnt.shims.js";
 
 
-import type { Plugin, PluginBuild } from "esbuild";
+import type { Plugin, PluginBuild } from "../extensions/bundler.js";
 import { isDeno, isDenoCompiled } from "../platform/compat/runtime.js";
 import { createFileSystem } from "../platform/compat/fs.js";
 import * as pathHelper from "../platform/compat/path/index.js";
@@ -167,7 +167,7 @@ export async function importModule(
   }
 
   const loader = getEsbuildLoader(filePath);
-  const { build } = await import("esbuild");
+  const { build } = await import("../extensions/bundler.js");
   const fileDir = pathHelper.dirname(filePath);
 
   // When using fsAdapter (VFS), bundle all relative imports via the plugin.