veryfront 0.1.924 → 0.1.926

package/esm/cli/commands/workflow/command.d.ts

@@ -1,5 +1,6 @@
 import type { WorkflowArgs } from "./handler.js";
 export interface WorkflowOptions extends WorkflowArgs {
+    projectDir?: string;
 }
 export interface WorkflowDiscoveryError {
     filePath: string;

package/esm/cli/commands/workflow/command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"command.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/workflow/command.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAKjD,MAAM,WAAW,eAAgB,SAAQ,YAAY;CAAG;AAExD,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,sBAAsB,EAAE,GAC/B,MAAM,EAAE,CAUV;AA8DD,wBAAsB,eAAe,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAyF7E"}
+{"version":3,"file":"command.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/workflow/command.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAKjD,MAAM,WAAW,eAAgB,SAAQ,YAAY;IACnD,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,sBAAsB,EAAE,GAC/B,MAAM,EAAE,CAUV;AAuFD,wBAAsB,eAAe,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAyF7E"}

package/esm/cli/commands/workflow/command.js

@@ -2,6 +2,9 @@ import * as dntShim from "../../../_dnt.shims.js";
 import { cliLogger } from "../../utils/index.js";
 import { exitProcess } from "../../utils/index.js";
 import { withProjectSourceContext } from "../../shared/project-source-context.js";
+import { agentRegistry } from "../../../src/agent/composition/index.js";
+import { discoverProjectAgentRuntime } from "../../../src/agent/project/agent-runtime.js";
+import { toolRegistry } from "../../../src/tool/registry.js";
 import { sanitizeRunOutputForLogging } from "../../utils/sanitize-run-output.js";
 import { writeRunResultIfConfigured } from "../../utils/write-run-result.js";
 import { getEnv } from "../../../src/platform/index.js";
@@ -16,18 +19,39 @@ export function formatWorkflowDiscoveryErrors(errors) {
     }
     return lines;
 }
-async function createWorkflowClient(debug) {
+function formatRuntimeDiscoveryError(error) {
+    return {
+        filePath: error.file,
+        error: error.error.message,
+    };
+}
+function withProjectStepRegistries(config) {
+    return {
+        ...config,
+        executor: {
+            ...config.executor,
+            stepExecutor: {
+                ...config.executor?.stepExecutor,
+                agentRegistry: config.executor?.stepExecutor?.agentRegistry ?? agentRegistry,
+                toolRegistry: config.executor?.stepExecutor?.toolRegistry ?? toolRegistry,
+            },
+        },
+    };
+}
+async function createWorkflowClient(config) {
     const { createWorkflowClient } = await import("../../../src/workflow/api/workflow-client.js");
+    const clientConfig = withProjectStepRegistries(config);
     const redisUrl = getEnv("REDIS_URL")?.trim();
     if (!redisUrl) {
-        return createWorkflowClient({ debug });
+        return createWorkflowClient(clientConfig);
     }
     const { RedisBackend } = await import("../../../src/workflow/backends/redis.js");
+    const debug = clientConfig.debug ?? false;
     const backend = new RedisBackend({ url: redisUrl, debug });
     if (backend.initialize) {
         await backend.initialize();
     }
-    return createWorkflowClient({ backend, debug });
+    return createWorkflowClient({ ...clientConfig, backend });
 }
 async function waitForWorkflowExit(client, runId) {
     while (true) {
@@ -79,37 +103,38 @@ export async function workflowCommand(options) {
             return;
         }
     }
-    const { discoverWorkflows } = await import("../../../src/workflow/discovery/index.js");
-    await withProjectSourceContext(dntShim.Deno.cwd(), async ({ adapter, config, proxyContext }) => {
+    const projectDir = options.projectDir ?? dntShim.Deno.cwd();
+    await withProjectSourceContext(projectDir, async ({ adapter, proxyContext }) => {
         const sourceLabel = proxyContext?.branchRef
             ? `branch ${proxyContext.branchRef}`
             : proxyContext
                 ? "main"
-                : `${dntShim.Deno.cwd()}/workflows/...`;
+                : `${projectDir}/workflows/...`;
         cliLogger.info(`Discovering workflows in ${sourceLabel}`);
-        const discovery = await discoverWorkflows({
-            projectDir: dntShim.Deno.cwd(),
+        const discovery = await discoverProjectAgentRuntime({
+            projectDir,
             adapter,
-            config,
-            debug: options.debug,
+            verbose: options.debug,
         });
+        const workflows = [...discovery.workflows.values()];
         if (discovery.errors.length > 0 && options.debug) {
-            for (const err of discovery.errors) {
+            for (const err of discovery.errors.map(formatRuntimeDiscoveryError)) {
                 cliLogger.warn(`  Warning: ${err.filePath}: ${err.error}`);
             }
         }
-        const workflow = discovery.workflows.find((candidate) => candidate.id === workflowId);
+        const workflow = workflows.find((candidate) => candidate.id === workflowId);
         if (!workflow) {
             cliLogger.error(`Workflow "${workflowId}" not found.`);
             if (discovery.errors.length > 0 && !options.debug) {
                 cliLogger.warn("Some workflow files could not be loaded:");
-                for (const line of formatWorkflowDiscoveryErrors(discovery.errors)) {
+                const errors = discovery.errors.map(formatRuntimeDiscoveryError);
+                for (const line of formatWorkflowDiscoveryErrors(errors)) {
                     cliLogger.warn(line);
                 }
             }
-            if (discovery.workflows.length > 0) {
+            if (workflows.length > 0) {
                 cliLogger.info("Available workflows:");
-                for (const candidate of discovery.workflows) {
+                for (const candidate of workflows) {
                     cliLogger.info(`  - ${candidate.id}`);
                 }
             }
@@ -119,7 +144,7 @@ export async function workflowCommand(options) {
             exitProcess(1);
             return;
         }
-        const client = await createWorkflowClient(options.debug);
+        const client = await createWorkflowClient({ debug: options.debug });
         try {
             client.register(workflow.definition);
             cliLogger.info(`Running workflow: ${workflow.id}`);

package/esm/deno.js

@@ -1,6 +1,6 @@
 export default {
     "name": "veryfront",
-    "version": "0.1.924",
+    "version": "0.1.926",
     "license": "Apache-2.0",
     "nodeModulesDir": "auto",
     "minimumDependencyAge": {

package/esm/extensions/ext-observability-opentelemetry/src/index.d.ts

@@ -7,6 +7,13 @@ import type { NodeTelemetryInitializeOptions, NodeTelemetryProvider, SpanData, T
 interface ShimTracerProvider {
     getTracer(name: string, version?: string): unknown;
 }
+type MetricsAPI = {
+    getMeter(name: string | undefined, version?: string): unknown;
+};
+type TraceAPI = {
+    getActiveSpan(): unknown;
+    getSpan(ctx: unknown): unknown;
+};
 type EnvReader = (name: string) => string | undefined;
 export interface ResolvedOtlpExtensionConfig {
     serviceName: string;
@@ -23,18 +30,14 @@ export declare function resolveOtlpExtensionConfig(read?: EnvReader): ResolvedOt
 declare class OtlpTracingExporter implements TracingExporter {
     private sdkProvider;
     private meterProvider;
-    private metricReader;
+    private metricsApi;
+    private traceApi;
     start(_ctxConfig: Record<string, unknown>): Promise<void>;
     export(_spans: SpanData[]): Promise<void>;
     shutdown(): Promise<void>;
     getProvider(): ShimTracerProvider;
-    getMetricsAPI(): {
-        getMeter(name: string | undefined, version?: string): unknown;
-    } | null;
-    getTraceAPI(): {
-        getActiveSpan(): unknown;
-        getSpan(ctx: unknown): unknown;
-    } | null;
+    getMetricsAPI(): MetricsAPI | null;
+    getTraceAPI(): TraceAPI | null;
 }
 declare class OpenTelemetryNodeTelemetryProvider implements NodeTelemetryProvider {
     private sdk;

package/esm/extensions/ext-observability-opentelemetry/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/extensions/ext-observability-opentelemetry/src/index.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,KAAK,EACV,8BAA8B,EAC9B,qBAAqB,EACrB,QAAQ,EACR,eAAe,EAChB,MAAM,gDAAgD,CAAC;AAmBxD;;;GAGG;AACH,UAAU,kBAAkB;IAC1B,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CACpD;AAED,KAAK,SAAS,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;AAEtD,MAAM,WAAW,2BAA2B;IAC1C,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,aAAa,EAAE,OAAO,CAAC;IACvB,cAAc,EAAE,OAAO,CAAC;IACxB,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,2BAA2B,EAAE,MAAM,CAAC;CACrC;AAgCD,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,MAAM,EAAE,QAAQ,GAAG,SAAS,GAC3B,MAAM,GAAG,SAAS,CAKpB;AAED,wBAAgB,0BAA0B,CACxC,IAAI,GAAE,SAAmB,GACxB,2BAA2B,CAqB7B;AAED,cAAM,mBAAoB,YAAW,eAAe;IAClD,OAAO,CAAC,WAAW,CAAoC;IACvD,OAAO,CAAC,aAAa,CAA8B;IACnD,OAAO,CAAC,YAAY,CAA8C;IAE5D,KAAK,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAsEzD,MAAM,CAAC,MAAM,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAKzC,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAmB/B,WAAW,IAAI,kBAAkB;IAOjC,aAAa,IAAI;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,GAAG,IAAI;IAKzF,WAAW,IAAI;QAAE,aAAa,IAAI,OAAO,CAAC;QAAC,OAAO,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAAA;KAAE,GAAG,IAAI;CAOnF;AAED,cAAM,kCAAmC,YAAW,qBAAqB;IACvE,OAAO,CAAC,GAAG,CAAwB;IAE7B,UAAU,CAAC,OAAO,EAAE,8BAA8B,GAAG,OAAO,CAAC,OAAO,CAAC;IA0CrE,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAQhC;AAED;;;;;GAKG;AACH,QAAA,MAAM,gBAAgB,EAAE,gBAqCvB,CAAC;AAEF,eAAe,gBAAgB,CAAC;AAChC,OAAO,EAAE,kCAAkC,EAAE,mBAAmB,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/extensions/ext-observability-opentelemetry/src/index.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,KAAK,EACV,8BAA8B,EAC9B,qBAAqB,EACrB,QAAQ,EACR,eAAe,EAChB,MAAM,gDAAgD,CAAC;AAExD;;;GAGG;AACH,UAAU,kBAAkB;IAC1B,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CACpD;AAsBD,KAAK,UAAU,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,CAAC;AACpF,KAAK,QAAQ,GAAG;IAAE,aAAa,IAAI,OAAO,CAAC;IAAC,OAAO,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAAA;CAAE,CAAC;AAuG7E,KAAK,SAAS,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;AAEtD,MAAM,WAAW,2BAA2B;IAC1C,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,aAAa,EAAE,OAAO,CAAC;IACvB,cAAc,EAAE,OAAO,CAAC;IACxB,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,2BAA2B,EAAE,MAAM,CAAC;CACrC;AAgCD,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,MAAM,EAAE,QAAQ,GAAG,SAAS,GAC3B,MAAM,GAAG,SAAS,CAKpB;AAED,wBAAgB,0BAA0B,CACxC,IAAI,GAAE,SAAmB,GACxB,2BAA2B,CAqB7B;AAED,cAAM,mBAAoB,YAAW,eAAe;IAClD,OAAO,CAAC,WAAW,CAAkC;IACrD,OAAO,CAAC,aAAa,CAAiC;IACtD,OAAO,CAAC,UAAU,CAA2B;IAC7C,OAAO,CAAC,QAAQ,CAAyB;IAEnC,KAAK,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IA2EzD,MAAM,CAAC,MAAM,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAKzC,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAkB/B,WAAW,IAAI,kBAAkB;IAKjC,aAAa,IAAI,UAAU,GAAG,IAAI;IAIlC,WAAW,IAAI,QAAQ,GAAG,IAAI;CAG/B;AAED,cAAM,kCAAmC,YAAW,qBAAqB;IACvE,OAAO,CAAC,GAAG,CAA8C;IAEnD,UAAU,CAAC,OAAO,EAAE,8BAA8B,GAAG,OAAO,CAAC,OAAO,CAAC;IA6CrE,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAQhC;AAED;;;;;GAKG;AACH,QAAA,MAAM,gBAAgB,EAAE,gBAqCvB,CAAC;AAEF,eAAe,gBAAgB,CAAC;AAChC,OAAO,EAAE,kCAAkC,EAAE,mBAAmB,EAAE,CAAC"}

package/esm/extensions/ext-observability-opentelemetry/src/index.js

@@ -14,17 +14,82 @@
  * @module extensions/ext-observability-opentelemetry
  */
 import * as dntShim from "../../../_dnt.shims.js";
-import { metrics, trace } from "@opentelemetry/api";
-import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
-import { W3CTraceContextPropagator } from "@opentelemetry/core";
-import { AsyncLocalStorageContextManager } from "@opentelemetry/context-async-hooks";
-import { NodeSDK } from "@opentelemetry/sdk-node";
-import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
-import { MeterProvider, PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
-import { BasicTracerProvider, BatchSpanProcessor, ParentBasedSampler, TraceIdRatioBasedSampler, } from "@opentelemetry/sdk-trace-base";
-import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
-import { resourceFromAttributes } from "@opentelemetry/resources";
-import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic-conventions";
+const NOOP_SPAN = {
+    setAttribute() {
+        return NOOP_SPAN;
+    },
+    setAttributes() {
+        return NOOP_SPAN;
+    },
+    setStatus() {
+        return NOOP_SPAN;
+    },
+    recordException() { },
+    addEvent() {
+        return NOOP_SPAN;
+    },
+    end() { },
+    spanContext() {
+        return {
+            traceId: "00000000000000000000000000000000",
+            spanId: "0000000000000000",
+            traceFlags: 0,
+        };
+    },
+    updateName() { },
+};
+const NOOP_TRACER = {
+    startSpan() {
+        return NOOP_SPAN;
+    },
+    startActiveSpan(_name, optionsOrFn, contextOrFn, fn) {
+        const callback = typeof optionsOrFn === "function"
+            ? optionsOrFn
+            : typeof contextOrFn === "function"
+                ? contextOrFn
+                : fn;
+        return callback?.(NOOP_SPAN);
+    },
+};
+const NOOP_TRACER_PROVIDER = {
+    getTracer() {
+        return NOOP_TRACER;
+    },
+};
+async function loadOpenTelemetryRuntime() {
+    try {
+        const [api, autoInstrumentations, core, contextAsyncHooks, sdkNode, metricsExporter, sdkMetrics, sdkTraceBase, traceExporter, resources, semanticConventions,] = await Promise.all([
+            import("@opentelemetry/api"),
+            import("@opentelemetry/auto-instrumentations-node"),
+            import("@opentelemetry/core"),
+            import("@opentelemetry/context-async-hooks"),
+            import("@opentelemetry/sdk-node"),
+            import("@opentelemetry/exporter-metrics-otlp-http"),
+            import("@opentelemetry/sdk-metrics"),
+            import("@opentelemetry/sdk-trace-base"),
+            import("@opentelemetry/exporter-trace-otlp-http"),
+            import("@opentelemetry/resources"),
+            import("@opentelemetry/semantic-conventions"),
+        ]);
+        return {
+            api,
+            autoInstrumentations,
+            core,
+            contextAsyncHooks,
+            sdkNode,
+            metricsExporter,
+            sdkMetrics,
+            sdkTraceBase,
+            traceExporter,
+            resources,
+            semanticConventions,
+        };
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(`OpenTelemetry observability requires the optional @opentelemetry packages to be installed. ${detail}`);
+    }
+}
 function readEnv(name) {
     try {
         return dntShim.dntGlobalThis.Deno?.env
@@ -81,57 +146,62 @@ export function resolveOtlpExtensionConfig(read = readEnv) {
 class OtlpTracingExporter {
     sdkProvider = null;
     meterProvider = null;
-    metricReader = null;
+    metricsApi = null;
+    traceApi = null;
     async start(_ctxConfig) {
         const cfg = resolveOtlpExtensionConfig(readEnv);
         // Honor OTEL_TRACES_ENABLED: when unset/false, skip exporter wiring so
         // deployments opting out never create OTLP traffic or set globals.
         if (!cfg.tracesEnabled && !cfg.metricsEnabled)
             return;
-        const resource = resourceFromAttributes({
-            [ATTR_SERVICE_NAME]: cfg.serviceName,
-            [ATTR_SERVICE_VERSION]: cfg.serviceVersion,
+        const otel = await loadOpenTelemetryRuntime();
+        const resource = otel.resources.resourceFromAttributes({
+            [otel.semanticConventions.ATTR_SERVICE_NAME]: cfg.serviceName,
+            [otel.semanticConventions.ATTR_SERVICE_VERSION]: cfg.serviceVersion,
         });
         if (cfg.tracesEnabled) {
             if (!cfg.tracesUrl) {
                 throw new Error("OTEL_TRACES_ENABLED=true requires OTEL_EXPORTER_OTLP_ENDPOINT or OTEL_EXPORTER_OTLP_TRACES_ENDPOINT");
             }
-            const exporter = new OTLPTraceExporter({
+            const exporter = new otel.traceExporter.OTLPTraceExporter({
                 url: cfg.tracesUrl,
                 headers: cfg.headers,
             });
-            const provider = new BasicTracerProvider({
+            const provider = new otel.sdkTraceBase.BasicTracerProvider({
                 resource,
-                spanProcessors: [new BatchSpanProcessor(exporter)],
+                spanProcessors: [new otel.sdkTraceBase.BatchSpanProcessor(exporter)],
             });
             // Wire OTel SDK globals so the real API delegates to this provider.
             // The shim also gets wired separately in bootstrap.ts via getProvider().
-            trace.setGlobalTracerProvider(provider);
-            const contextManager = new AsyncLocalStorageContextManager();
+            otel.api.trace.setGlobalTracerProvider(provider);
+            const contextManager = new otel.contextAsyncHooks.AsyncLocalStorageContextManager();
             contextManager.enable();
-            const propagator = new W3CTraceContextPropagator();
-            // Set propagator via OTel API (import is available in this extension).
-            const { propagation, context: otelContext } = await import("@opentelemetry/api");
-            propagation.setGlobalPropagator(propagator);
-            otelContext.setGlobalContextManager(contextManager);
+            const propagator = new otel.core.W3CTraceContextPropagator();
+            otel.api.propagation.setGlobalPropagator(propagator);
+            otel.api.context.setGlobalContextManager(contextManager);
             this.sdkProvider = provider;
+            this.traceApi = {
+                getActiveSpan: () => otel.api.trace.getActiveSpan(),
+                getSpan: (ctx) => otel.api.trace.getSpan(ctx),
+            };
         }
         if (cfg.metricsEnabled) {
             if (!cfg.metricsUrl) {
                 throw new Error("OTEL_METRICS_ENABLED=true requires OTEL_EXPORTER_OTLP_ENDPOINT or OTEL_EXPORTER_OTLP_METRICS_ENDPOINT");
             }
-            this.metricReader = new PeriodicExportingMetricReader({
-                exporter: new OTLPMetricExporter({
+            const metricReader = new otel.sdkMetrics.PeriodicExportingMetricReader({
+                exporter: new otel.metricsExporter.OTLPMetricExporter({
                     url: cfg.metricsUrl,
                     headers: cfg.headers,
                 }),
                 exportIntervalMillis: cfg.metricsExportIntervalMillis,
             });
-            this.meterProvider = new MeterProvider({
+            this.meterProvider = new otel.sdkMetrics.MeterProvider({
                 resource,
-                readers: [this.metricReader],
+                readers: [metricReader],
             });
-            metrics.setGlobalMeterProvider(this.meterProvider);
+            otel.api.metrics.setGlobalMeterProvider(this.meterProvider);
+            this.metricsApi = otel.api.metrics;
         }
     }
     // eslint-disable-next-line require-await
@@ -146,7 +216,6 @@ class OtlpTracingExporter {
             }
             finally {
                 this.meterProvider = null;
-                this.metricReader = null;
             }
         }
         if (this.sdkProvider) {
@@ -161,43 +230,38 @@ class OtlpTracingExporter {
     getProvider() {
         if (this.sdkProvider)
             return this.sdkProvider;
-        // Return a passthrough to OTel's real global provider if start() wasn't
-        // called (e.g., test scaffolding without full setup).
-        return trace.getTracerProvider();
+        return NOOP_TRACER_PROVIDER;
     }
     getMetricsAPI() {
-        // Return the OTel Metrics API so the core metrics subsystem can get meters.
-        return metrics;
+        return this.metricsApi;
     }
     getTraceAPI() {
-        if (!this.sdkProvider)
-            return null;
-        return {
-            getActiveSpan: () => trace.getActiveSpan(),
-            getSpan: (ctx) => trace.getSpan(ctx),
-        };
+        return this.traceApi;
     }
 }
 class OpenTelemetryNodeTelemetryProvider {
     sdk = null;
     async initialize(options) {
-        const resource = resourceFromAttributes({
+        const otel = await loadOpenTelemetryRuntime();
+        const resource = otel.resources.resourceFromAttributes({
             "service.name": options.serviceName,
             "service.version": options.serviceVersion,
             "deployment.environment": options.deploymentEnvironment,
         });
-        const traceExporter = new OTLPTraceExporter({ headers: options.exporterHeaders });
-        const sdk = new NodeSDK({
+        const traceExporter = new otel.traceExporter.OTLPTraceExporter({
+            headers: options.exporterHeaders,
+        });
+        const sdk = new otel.sdkNode.NodeSDK({
             resource,
-            sampler: new ParentBasedSampler({
-                root: new TraceIdRatioBasedSampler(options.samplingRatio),
+            sampler: new otel.sdkTraceBase.ParentBasedSampler({
+                root: new otel.sdkTraceBase.TraceIdRatioBasedSampler(options.samplingRatio),
             }),
-            spanProcessor: new BatchSpanProcessor(traceExporter, {
+            spanProcessor: new otel.sdkTraceBase.BatchSpanProcessor(traceExporter, {
                 maxExportBatchSize: 100,
                 scheduledDelayMillis: 500,
             }),
             instrumentations: [
-                getNodeAutoInstrumentations({
+                otel.autoInstrumentations.getNodeAutoInstrumentations({
                     "@opentelemetry/instrumentation-fs": { enabled: options.instrumentation.fs },
                     "@opentelemetry/instrumentation-http": { enabled: options.instrumentation.http },
                     "@opentelemetry/instrumentation-express": { enabled: options.instrumentation.express },

package/esm/src/utils/version-constant.d.ts

@@ -1,3 +1,3 @@
 /** Shared version value. */
-export declare const VERSION = "0.1.924";
+export declare const VERSION = "0.1.926";
 //# sourceMappingURL=version-constant.d.ts.map

package/esm/src/utils/version-constant.js

@@ -1,4 +1,4 @@
 // Keep in sync with deno.json version.
 // scripts/release.ts updates this constant during releases.
 /** Shared version value. */
-export const VERSION = "0.1.924";
+export const VERSION = "0.1.926";

package/esm/src/workflow/worker/dynamic-run-entrypoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dynamic-run-entrypoint.d.ts","sourceRoot":"","sources":["../../../../src/src/workflow/worker/dynamic-run-entrypoint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAQH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAY5D;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;CAMrB,CAAC;AAEX;;GAEG;AACH,MAAM,WAAW,kCAAkC;IACjD,uCAAuC;IACvC,OAAO,EAAE,eAAe,CAAC;IAEzB,2BAA2B;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,kCAAkC,GACzC,OAAO,CAAC,MAAM,CAAC,CAgIjB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,yCAAyC;IACxD,4BAA4B;IAC5B,QAAQ,EAAE,MAAM,CAAC;IAEjB,2BAA2B;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,gDAAgD;AAChD,wBAAsB,kCAAkC,CACtD,OAAO,EAAE,yCAAyC,GACjD,OAAO,CAAC,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC,CAchC"}
+{"version":3,"file":"dynamic-run-entrypoint.d.ts","sourceRoot":"","sources":["../../../../src/src/workflow/worker/dynamic-run-entrypoint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AASH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAY5D;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;CAMrB,CAAC;AAEX;;GAEG;AACH,MAAM,WAAW,kCAAkC;IACjD,uCAAuC;IACvC,OAAO,EAAE,eAAe,CAAC;IAEzB,2BAA2B;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,kCAAkC,GACzC,OAAO,CAAC,MAAM,CAAC,CAmIjB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,yCAAyC;IACxD,4BAA4B;IAC5B,QAAQ,EAAE,MAAM,CAAC;IAEjB,2BAA2B;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,gDAAgD;AAChD,wBAAsB,kCAAkC,CACtD,OAAO,EAAE,yCAAyC,GACjD,OAAO,CAAC,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC,CAchC"}

package/esm/src/workflow/worker/dynamic-run-entrypoint.js

@@ -28,7 +28,9 @@ import { logger as baseLogger } from "../../utils/index.js";
 import { getEnv } from "../../platform/compat/process.js";
 import { enhanceAdapterWithFS } from "../../platform/adapters/fs/integration.js";
 import { denoAdapter } from "../../platform/adapters/runtime/deno/index.js";
-import { discoverWorkflows } from "../discovery/index.js";
+import { agentRegistry } from "../../agent/composition/index.js";
+import { discoverProjectAgentRuntime } from "../../agent/project/agent-runtime.js";
+import { toolRegistry } from "../../tool/registry.js";
 import { WorkflowExecutor } from "../executor/workflow-executor.js";
 import { failRunExecution, getFinalRunExitCode, getTenantFromEnv, hydrateRunContextEnv, runWithTenantContext, } from "./shared.js";
 const logger = baseLogger.component("dynamic-workflow-run-entrypoint");
@@ -100,37 +102,41 @@ export async function runDynamicWorkflowRun(config) {
             if (debug) {
                 logger.info("FS adapter initialized");
             }
-            // Discover workflows from user's project
-            const discoveryResult = await discoverWorkflows({
+            // Discover workflows and the project-local agent/tool registries they may reference.
+            const discoveryResult = await discoverProjectAgentRuntime({
                 projectDir: "", // Root of project (relative paths with API)
                 adapter,
-                config: fsConfig,
-                debug,
+                verbose: debug,
             });
             if (discoveryResult.errors.length > 0 && debug) {
                 logger.warn("Some workflow files failed to load:", discoveryResult.errors);
             }
-            if (discoveryResult.workflows.length === 0) {
+            const workflows = [...discoveryResult.workflows.values()];
+            if (workflows.length === 0) {
                 logger.error("No workflows discovered");
                 return DYNAMIC_EXIT_CODES.DISCOVERY_FAILED;
             }
             if (debug) {
-                logger.info(`[DynamicWorkflowRun] Discovered ${discoveryResult.workflows.length} workflows:`, discoveryResult.workflows.map((w) => w.id));
+                logger.info(`[DynamicWorkflowRun] Discovered ${workflows.length} workflows:`, workflows.map((w) => w.id));
             }
             // Find the matching workflow
-            const workflow = discoveryResult.workflows.find((w) => w.id === run.workflowId);
+            const workflow = workflows.find((w) => w.id === run.workflowId);
             if (!workflow) {
                 logger.error(`Workflow not found: ${run.workflowId}`);
-                logger.error(`[DynamicWorkflowRun] Available workflows: ${discoveryResult.workflows.map((w) => w.id).join(", ")}`);
+                logger.error(`[DynamicWorkflowRun] Available workflows: ${workflows.map((w) => w.id).join(", ")}`);
                 return DYNAMIC_EXIT_CODES.NOT_FOUND;
             }
             if (debug) {
-                logger.info(`Found workflow "${workflow.id}" at ${workflow.filePath}`);
+                logger.info(`Found workflow "${workflow.id}"`);
             }
             // Create executor and register the workflow
             const executor = new WorkflowExecutor({
                 backend,
                 debug,
+                stepExecutor: {
+                    agentRegistry,
+                    toolRegistry,
+                },
             });
             executor.register(workflow.definition);
             // Execute the workflow

package/esm/src/workflow/worker/run-entrypoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run-entrypoint.d.ts","sourceRoot":"","sources":["../../../../src/src/workflow/worker/run-entrypoint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAIH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAWtD;;GAEG;AACH,MAAM,WAAW,2BAA2B;IAC1C,uCAAuC;IACvC,OAAO,EAAE,eAAe,CAAC;IAEzB,wBAAwB;IACxB,QAAQ,EAAE,gBAAgB,CAAC;IAE3B,2BAA2B;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;GAEG;AACH,eAAO,MAAM,UAAU;;;;;CAKb,CAAC;AAEX;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,2BAA2B,GAAG,OAAO,CAAC,MAAM,CAAC,CAgEzF;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,kCAAkC;IACjD,4BAA4B;IAC5B,QAAQ,EAAE,MAAM,CAAC;IAEjB,4BAA4B;IAC5B,SAAS,EAAE,KAAK,CAAC;QAAE,UAAU,EAAE,kBAAkB,CAAA;KAAE,CAAC,CAAC;IAErD,2BAA2B;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,wCAAwC;AACxC,wBAAsB,2BAA2B,CAC/C,OAAO,EAAE,kCAAkC,GAC1C,OAAO,CAAC,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC,CA0BhC"}
+{"version":3,"file":"run-entrypoint.d.ts","sourceRoot":"","sources":["../../../../src/src/workflow/worker/run-entrypoint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAMH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAWtD;;GAEG;AACH,MAAM,WAAW,2BAA2B;IAC1C,uCAAuC;IACvC,OAAO,EAAE,eAAe,CAAC;IAEzB,wBAAwB;IACxB,QAAQ,EAAE,gBAAgB,CAAC;IAE3B,2BAA2B;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;GAEG;AACH,eAAO,MAAM,UAAU;;;;;CAKb,CAAC;AAEX;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,2BAA2B,GAAG,OAAO,CAAC,MAAM,CAAC,CAgEzF;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,kCAAkC;IACjD,4BAA4B;IAC5B,QAAQ,EAAE,MAAM,CAAC;IAEjB,4BAA4B;IAC5B,SAAS,EAAE,KAAK,CAAC;QAAE,UAAU,EAAE,kBAAkB,CAAA;KAAE,CAAC,CAAC;IAErD,2BAA2B;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,wCAAwC;AACxC,wBAAsB,2BAA2B,CAC/C,OAAO,EAAE,kCAAkC,GAC1C,OAAO,CAAC,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC,CA8BhC"}

package/esm/src/workflow/worker/run-entrypoint.js

@@ -21,6 +21,8 @@
  */
 import { logger as baseLogger } from "../../utils/index.js";
 import { getEnv } from "../../platform/compat/process.js";
+import { agentRegistry } from "../../agent/composition/index.js";
+import { toolRegistry } from "../../tool/registry.js";
 import { failRunExecution, getFinalRunExitCode, getTenantFromEnv, hydrateRunContextEnv, runWithTenantContext, } from "./shared.js";
 const logger = baseLogger.component("workflow-run-entrypoint");
 /**
@@ -122,6 +124,10 @@ export async function createWorkflowRunEntrypoint(options) {
     const executor = new WorkflowExecutor({
         backend,
         debug: options.debug,
+        stepExecutor: {
+            agentRegistry,
+            toolRegistry,
+        },
     });
     // Register workflows
     for (const wf of options.workflows) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "veryfront",
-  "version": "0.1.924",
+  "version": "0.1.926",
   "description": "The simplest way to build AI-powered apps",
   "keywords": [
     "react",