veryfront 0.1.623 → 0.1.625

package/esm/cli/commands/knowledge/parser.js

@@ -0,0 +1,353 @@
+import * as dntShim from "../../../_dnt.shims.js";
+import { basename, extname, join } from "../../../src/platform/compat/path/index.js";
+import { KreuzbergDocumentExtractor } from "../../../extensions/ext-document-kreuzberg/src/index.js";
+const CODE_FENCE = "`".repeat(3);
+const TEXT_FILE_EXTENSIONS = new Set([
+    ".c",
+    ".cc",
+    ".conf",
+    ".cpp",
+    ".cs",
+    ".css",
+    ".go",
+    ".h",
+    ".hpp",
+    ".ini",
+    ".java",
+    ".js",
+    ".jsonl",
+    ".jsx",
+    ".kt",
+    ".less",
+    ".lua",
+    ".mjs",
+    ".ndjson",
+    ".php",
+    ".pl",
+    ".py",
+    ".r",
+    ".rb",
+    ".rs",
+    ".sass",
+    ".scala",
+    ".scss",
+    ".sh",
+    ".sql",
+    ".swift",
+    ".toml",
+    ".ts",
+    ".tsx",
+    ".xml",
+    ".yaml",
+    ".yml",
+    ".zsh",
+]);
+const TEXT_FILE_NAMES = new Set([
+    "dockerfile",
+    "makefile",
+    "readme",
+    "license",
+    "changelog",
+]);
+const MIME_BY_EXTENSION = {
+    ".csv": "text/csv",
+    ".doc": "application/msword",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".epub": "application/epub+zip",
+    ".htm": "text/html",
+    ".html": "text/html",
+    ".json": "application/json",
+    ".md": "text/markdown",
+    ".mdx": "text/mdx",
+    ".pdf": "application/pdf",
+    ".ppt": "application/vnd.ms-powerpoint",
+    ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    ".rtf": "application/rtf",
+    ".tsv": "text/tab-separated-values",
+    ".txt": "text/plain",
+    ".xls": "application/vnd.ms-excel",
+    ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ".xml": "text/xml",
+};
+export function slugifyKnowledgeValue(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") ||
+        "document";
+}
+function titleizeFilename(path) {
+    const name = basename(path);
+    const dot = name.lastIndexOf(".");
+    const stem = dot > 0 ? name.slice(0, dot) : name;
+    const title = stem.replaceAll("_", " ").replaceAll("-", " ").trim();
+    return title
+        .split(/\s+/)
+        .filter(Boolean)
+        .map((word) => `${word.slice(0, 1).toUpperCase()}${word.slice(1)}`)
+        .join(" ") || name;
+}
+function cleanText(value) {
+    return value.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+function yamlQuote(value) {
+    return JSON.stringify(value == null ? "" : String(value));
+}
+function buildFrontmatter(source, sourceType, description) {
+    return [
+        "---",
+        `source: ${yamlQuote(source)}`,
+        `source_type: ${yamlQuote(sourceType)}`,
+        `added: ${yamlQuote(new Date().toISOString().slice(0, 10))}`,
+        `description: ${yamlQuote(description)}`,
+        "---",
+    ].join("\n");
+}
+function tableToMarkdown(rows) {
+    if (!rows.length)
+        return "";
+    const maxColumns = Math.max(...rows.map((row) => row.length));
+    if (maxColumns === 0)
+        return "";
+    const normalized = rows.map((row) => Array.from({ length: maxColumns }, (_, index) => (row[index] ?? "").replaceAll("|", "\\|").replaceAll("\n", " ").trim()));
+    const [header = [], ...body] = normalized;
+    return [
+        `| ${header.join(" | ")} |`,
+        `| ${Array.from({ length: maxColumns }, () => "---").join(" | ")} |`,
+        ...body.map((row) => `| ${row.join(" | ")} |`),
+    ].join("\n");
+}
+function parseCsvLine(line) {
+    const values = [];
+    let current = "";
+    let inQuotes = false;
+    for (let index = 0; index < line.length; index += 1) {
+        const char = line[index];
+        if (char === '"') {
+            if (inQuotes && line[index + 1] === '"') {
+                current += '"';
+                index += 1;
+            }
+            else {
+                inQuotes = !inQuotes;
+            }
+        }
+        else if (char === "," && !inQuotes) {
+            values.push(current.trim());
+            current = "";
+        }
+        else {
+            current += char;
+        }
+    }
+    values.push(current.trim());
+    return values;
+}
+async function parseCsvLike(path, delimiter) {
+    const raw = await dntShim.Deno.readTextFile(path);
+    const lines = raw.split("\n").filter((line) => line.trim());
+    if (!lines.length) {
+        return { content: "_Empty file._", stats: { rows: 0, columns: 0 }, warnings: [] };
+    }
+    const parseLine = delimiter === ","
+        ? parseCsvLine
+        : (line) => line.split("\t").map((value) => value.trim());
+    const header = parseLine(lines[0] ?? "");
+    const data = lines.slice(1).map(parseLine);
+    const limitedRows = [header, ...data.slice(0, 200)];
+    const warnings = data.length > 200
+        ? [`Truncated ${data.length - 200} rows from markdown output`]
+        : [];
+    const parts = [
+        `**Rows:** ${data.length} | **Columns:** ${header.length}`,
+        "",
+        tableToMarkdown(limitedRows),
+    ];
+    if (data.length > 200) {
+        parts.push(`\n_...and ${data.length - 200} more rows (truncated)._`);
+    }
+    return {
+        content: parts.join("\n").trim(),
+        stats: { rows: data.length, columns: header.length },
+        warnings,
+    };
+}
+async function parseText(path) {
+    const content = cleanText(await dntShim.Deno.readTextFile(path));
+    return {
+        content,
+        stats: { characters: content.length, lines: content ? content.split("\n").length : 0 },
+        warnings: [],
+    };
+}
+async function parseJson(path) {
+    const raw = await dntShim.Deno.readTextFile(path);
+    const data = JSON.parse(raw);
+    if (Array.isArray(data) && data.length > 0 && data[0] != null && typeof data[0] === "object" &&
+        !Array.isArray(data[0])) {
+        const first = data[0];
+        const headers = Object.keys(first);
+        const rows = data.slice(0, 200).map((entry) => {
+            const record = entry != null && typeof entry === "object" && !Array.isArray(entry)
+                ? entry
+                : {};
+            return headers.map((header) => String(record[header] ?? ""));
+        });
+        const warnings = data.length > 200
+            ? [`Truncated ${data.length - 200} records from markdown output`]
+            : [];
+        const parts = [
+            `**Records:** ${data.length} | **Fields:** ${headers.length}`,
+            "",
+            tableToMarkdown([headers, ...rows]),
+        ];
+        if (data.length > 200) {
+            parts.push(`\n_...and ${data.length - 200} more records (truncated)._`);
+        }
+        return {
+            content: parts.join("\n").trim(),
+            stats: { records: data.length, fields: headers.length },
+            warnings,
+        };
+    }
+    const rendered = JSON.stringify(data, null, 2);
+    return {
+        content: `${CODE_FENCE}json\n${rendered}\n${CODE_FENCE}`,
+        stats: { top_level_type: Array.isArray(data) ? "list" : typeof data },
+        warnings: [],
+    };
+}
+async function parseWithKreuzberg(path, deps) {
+    const mimeType = MIME_BY_EXTENSION[extname(path).toLowerCase()] ?? "application/octet-stream";
+    const content = cleanText(await deps.extractDocumentText({ filePath: path, mimeType }));
+    return {
+        content: content || "_No extractable text found in document._",
+        stats: {
+            characters: content.length,
+            lines: content ? content.split("\n").length : 0,
+            engine: "kreuzberg",
+        },
+        warnings: [],
+    };
+}
+function selectParserDefinition(path) {
+    const extension = extname(path).toLowerCase();
+    const name = basename(path).toLowerCase();
+    if (extension === ".csv" || extension === ".tsv") {
+        const delimiter = extension === ".tsv" ? "\t" : ",";
+        return {
+            sourceType: extension.slice(1),
+            parse: (filePath) => parseCsvLike(filePath, delimiter),
+        };
+    }
+    if (extension === ".txt" || extension === ".md" || extension === ".mdx") {
+        return { sourceType: extension.slice(1), parse: parseText };
+    }
+    if (extension === ".json") {
+        return { sourceType: "json", parse: parseJson };
+    }
+    if (TEXT_FILE_EXTENSIONS.has(extension)) {
+        return { sourceType: extension.slice(1), parse: parseText };
+    }
+    if (!extension && TEXT_FILE_NAMES.has(name)) {
+        return { sourceType: "text", parse: parseText };
+    }
+    if (extension in MIME_BY_EXTENSION) {
+        return {
+            sourceType: extension.slice(1),
+            parse: (filePath, deps) => parseWithKreuzberg(filePath, deps),
+        };
+    }
+    throw new Error(`Unsupported file type: ${extension || name}`);
+}
+function buildSummary(sourceType, stats) {
+    if (stats.engine === "kreuzberg") {
+        return `Extracted ${sourceType.toUpperCase()} text with Kreuzberg (${stats.characters ?? 0} chars).`;
+    }
+    if (sourceType === "csv" || sourceType === "tsv") {
+        return `Parsed ${stats.rows ?? 0} rows across ${stats.columns ?? 0} columns.`;
+    }
+    if (sourceType === "json") {
+        if ("records" in stats) {
+            return `Parsed ${stats.records ?? 0} record(s) across ${stats.fields ?? 0} fields.`;
+        }
+        return `Converted JSON (${stats.top_level_type ?? "object"}) to markdown.`;
+    }
+    return `Converted document to markdown (${stats.characters ?? 0} chars).`;
+}
+async function defaultExtractDocumentText(input) {
+    const bytes = await dntShim.Deno.readFile(input.filePath);
+    const extractor = new KreuzbergDocumentExtractor();
+    return await extractor.extractInWorker(bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength), input.mimeType);
+}
+export async function runKnowledgeParser(input, deps = {}) {
+    const [result] = await runKnowledgeParsers({
+        files: [{
+                filePath: input.filePath,
+                description: input.description,
+                slug: input.slug,
+                sourceReference: input.sourceReference,
+            }],
+        outputDir: input.outputDir,
+    }, deps);
+    if (!result) {
+        throw new Error("knowledge ingest parser returned no results");
+    }
+    return result;
+}
+export async function runKnowledgeParsers(input, deps = {}) {
+    if (!input.files.length) {
+        return [];
+    }
+    const parserDeps = {
+        extractDocumentText: deps.extractDocumentText ?? defaultExtractDocumentText,
+    };
+    await dntShim.Deno.mkdir(input.outputDir, { recursive: true });
+    const results = [];
+    for (const file of input.files) {
+        try {
+            const stat = await dntShim.Deno.stat(file.filePath);
+            if (!stat.isFile) {
+                throw new Error(`File not found: ${file.filePath}`);
+            }
+            const definition = selectParserDefinition(file.filePath);
+            const parsed = await definition.parse(file.filePath, parserDeps);
+            const content = cleanText(parsed.content);
+            const fileName = basename(file.filePath);
+            const extension = extname(fileName);
+            const stem = extension ? fileName.slice(0, -extension.length) : fileName;
+            const slug = file.slug ?? slugifyKnowledgeValue(stem);
+            const description = file.description ?? `Parsed from ${basename(file.filePath)}`;
+            const title = titleizeFilename(file.filePath);
+            const outputPath = join(input.outputDir, `${slug}.md`);
+            const markdown = [
+                buildFrontmatter(file.sourceReference ?? basename(file.filePath), definition.sourceType, description),
+                "",
+                `# ${title}`,
+                "",
+                content,
+                "",
+            ].join("\n");
+            await dntShim.Deno.writeTextFile(outputPath, markdown);
+            results.push({
+                success: true,
+                source_path: file.filePath,
+                source_filename: basename(file.filePath),
+                source_type: definition.sourceType,
+                slug,
+                sandbox_output_path: outputPath,
+                suggested_project_path: `knowledge/${slug}.md`,
+                description,
+                title,
+                summary: buildSummary(definition.sourceType, parsed.stats),
+                stats: parsed.stats,
+                warnings: parsed.warnings,
+            });
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.startsWith("knowledge ingest parser failed")) {
+                throw error;
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`knowledge ingest parser failed: ${message}`);
+        }
+    }
+    return results;
+}

package/esm/cli/commands/knowledge/result.d.ts

@@ -34,7 +34,7 @@ export interface KnowledgeIngestResultMetadata {
     source_mode: "explicit_sources" | "path_prefix";
     knowledge_path: string;
 }
-export interface KnowledgeIngestJobResult {
+export interface KnowledgeIngestRunResult {
     kind: "knowledge_ingest";
     version: 1;
     metadata: KnowledgeIngestResultMetadata;
@@ -43,12 +43,12 @@ export interface KnowledgeIngestJobResult {
     skipped: KnowledgeIngestSkippedFileResult[];
     failed: KnowledgeIngestFailedFileResult[];
 }
-export declare function buildKnowledgeIngestJobResult(input: {
+export declare function buildKnowledgeIngestRunResult(input: {
     requestedCount: number;
     sourceMode: KnowledgeIngestResultMetadata["source_mode"];
     knowledgePath: string;
     ingested: KnowledgeIngestFileResult[];
     skipped?: KnowledgeIngestSkippedFileResult[];
     failed?: KnowledgeIngestFailedFileResult[];
-}): KnowledgeIngestJobResult;
+}): KnowledgeIngestRunResult;
 //# sourceMappingURL=result.d.ts.map

package/esm/cli/commands/knowledge/result.js

@@ -1,4 +1,4 @@
-export function buildKnowledgeIngestJobResult(input) {
+export function buildKnowledgeIngestRunResult(input) {
     const skipped = input.skipped ?? [];
     const failed = input.failed ?? [];
     return {

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

@@ -4,7 +4,7 @@ import { getConfig } from "../../../src/config/index.js";
 import { enhanceAdapterWithFS, getEnv, isExtendedFSAdapter, runtime, } from "../../../src/platform/index.js";
 import { buildPreparedCSSArtifactFromFiles, createStyleScopeProfile, resolveStyleContentVersion, } from "../../../src/rendering/styles.js";
 import { cliLogger, exitProcess } from "../../utils/index.js";
-import { writeJobResultIfConfigured } from "../../utils/write-job-result.js";
+import { writeRunResultIfConfigured } from "../../utils/write-run-result.js";
 const getStyleArtifactBuildConfigSchema = defineSchema((v) => v.object({
     style_profile_hash: v.string().min(1).optional(),
     branch: v.string().min(1).optional(),
@@ -194,7 +194,7 @@ export async function stylesCommand(options) {
                 value: selector.value,
             },
         };
-        await writeJobResultIfConfigured(result);
+        await writeRunResultIfConfigured(result);
         cliLogger.info(`Built style artifact ${build.hash}`);
     }
     catch (error) {

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

@@ -8,8 +8,8 @@ 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 { sanitizeJobOutputForLogging } from "../../utils/sanitize-job-output.js";
-import { writeJobResultIfConfigured } from "../../utils/write-job-result.js";
+import { sanitizeRunOutputForLogging } from "../../utils/sanitize-run-output.js";
+import { writeRunResultIfConfigured } from "../../utils/write-run-result.js";
 export async function taskCommand(options) {
     const { discoverTasks } = await import("../../../src/task/discovery.js");
     const { runTask } = await import("../../../src/task/runner.js");
@@ -77,8 +77,8 @@ export async function taskCommand(options) {
         if (result.success) {
             cliLogger.info(`Task completed in ${result.durationMs}ms`);
             if (result.result !== undefined) {
-                await writeJobResultIfConfigured(result.result);
-                cliLogger.info(`Result: ${JSON.stringify(sanitizeJobOutputForLogging(result.result), null, 2)}`);
+                await writeRunResultIfConfigured(result.result);
+                cliLogger.info(`Result: ${JSON.stringify(sanitizeRunOutputForLogging(result.result), null, 2)}`);
             }
             return;
         }

package/esm/cli/commands/worker/command-help.js

@@ -11,7 +11,7 @@ export const workerHelp = {
         },
         {
             flag: "-c, --concurrency <number>",
-            description: "Maximum concurrent jobs",
+            description: "Maximum concurrent runs",
             default: "3",
         },
         {
@@ -26,13 +26,13 @@ export const workerHelp = {
         },
         {
             flag: "-e, --executor <type>",
-            description: "Job executor type (process | k8s)",
+            description: "Run executor type (process | k8s)",
             default: "process",
         },
         {
             flag: "--entrypoint <path>",
             description: "Path to workflow run entrypoint script",
-            default: "./workflow-job.ts",
+            default: "./workflow-run.ts",
         },
         {
             flag: "--debug",
@@ -42,6 +42,6 @@ export const workerHelp = {
     examples: [
         "veryfront worker",
         "veryfront worker --redis-url redis://prod:6379 --concurrency 5",
-        "veryfront worker --entrypoint ./src/jobs/workflow-runner.ts --debug",
+        "veryfront worker --entrypoint ./src/runs/workflow-runner.ts --debug",
     ],
 };

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

@@ -2,7 +2,7 @@
  * Worker command - Start workflow run worker
  *
  * Polls Redis for pending/stalled workflow runs and executes them
- * as isolated processes. Supports multi-tenant execution: each job
+ * as isolated processes. Supports multi-tenant execution: each run
  * runs with its own tenant context captured at workflow creation time.
  */
 import type { WorkerArgs } from "./handler.js";

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

@@ -2,15 +2,15 @@
  * Worker command - Start workflow run worker
  *
  * Polls Redis for pending/stalled workflow runs and executes them
- * as isolated processes. Supports multi-tenant execution: each job
+ * as isolated processes. Supports multi-tenant execution: each run
  * runs with its own tenant context captured at workflow creation time.
  */
 import { cliLogger } from "../../utils/index.js";
 import { exitProcess, registerTerminationSignals, showLogo } from "../../utils/index.js";
 export async function workerCommand(options) {
     showLogo();
-    const { WorkflowRunManager } = await import("../../../src/workflow/worker/job-manager.js");
-    const { ProcessJobExecutor } = await import("../../../src/workflow/worker/executors/process.js");
+    const { WorkflowRunManager } = await import("../../../src/workflow/worker/run-manager.js");
+    const { ProcessRunExecutor } = await import("../../../src/workflow/worker/executors/process.js");
     const { RedisBackend } = await import("../../../src/workflow/backends/redis.js");
     cliLogger.info("Starting workflow worker...");
     cliLogger.info(`  Redis:       ${options.redisUrl}`);
@@ -25,18 +25,18 @@ export async function workerCommand(options) {
     if (backend.initialize) {
         await backend.initialize();
     }
-    // Create job executor
+    // Create run executor
     // The entrypoint script runs inside each spawned process.
     // It reads WORKFLOW_RUN_ID + TENANT_* env vars, discovers workflows
     // from the user's project, and executes the matching one.
-    const entrypointPath = options.entrypoint ?? "./workflow-job.ts";
+    const entrypointPath = options.entrypoint ?? "./workflow-run.ts";
     if (options.executor === "k8s") {
         cliLogger.error("K8s executor requires custom configuration. Use --executor process for local dev, " +
-            "or configure K8sJobExecutor programmatically for production.");
+            "or configure K8sRunExecutor programmatically for production.");
         exitProcess(1);
         return;
     }
-    const executor = new ProcessJobExecutor({
+    const executor = new ProcessRunExecutor({
         entrypointPath,
         env: {
             REDIS_URL: options.redisUrl,
@@ -48,7 +48,7 @@ export async function workerCommand(options) {
         backend,
         executor,
         pollInterval: options.pollInterval,
-        maxConcurrentJobs: options.concurrency,
+        maxConcurrentExecutions: options.concurrency,
         stalledThreshold: options.stalledThreshold,
         debug: options.debug,
     });
@@ -67,7 +67,7 @@ export async function workerCommand(options) {
             await backend.destroy();
             const stats = manager.getStats();
             cliLogger.info("Worker stopped.");
-            cliLogger.info(`  Jobs: ${stats.jobsCreated} created, ${stats.jobsCompleted} completed, ${stats.jobsFailed} failed`);
+            cliLogger.info(`  Runs: ${stats.executionsCreated} created, ${stats.executionsCompleted} completed, ${stats.executionsFailed} failed`);
         }
         catch (error) {
             cliLogger.warn("Error during shutdown:", error);

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

@@ -2,8 +2,8 @@ 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 { sanitizeJobOutputForLogging } from "../../utils/sanitize-job-output.js";
-import { writeJobResultIfConfigured } from "../../utils/write-job-result.js";
+import { sanitizeRunOutputForLogging } from "../../utils/sanitize-run-output.js";
+import { writeRunResultIfConfigured } from "../../utils/write-run-result.js";
 import { getEnv } from "../../../src/platform/index.js";
 const WORKFLOW_STATUS_POLL_INTERVAL_MS = 1_000;
 const MAX_DISCOVERY_ERRORS_TO_PRINT = 5;
@@ -38,8 +38,8 @@ async function waitForWorkflowExit(client, runId) {
         if (run.status === "completed") {
             cliLogger.info(`Workflow completed: ${runId}`);
             if (run.output !== undefined) {
-                await writeJobResultIfConfigured(run.output);
-                cliLogger.info(`Result: ${JSON.stringify(sanitizeJobOutputForLogging(run.output), null, 2)}`);
+                await writeRunResultIfConfigured(run.output);
+                cliLogger.info(`Result: ${JSON.stringify(sanitizeRunOutputForLogging(run.output), null, 2)}`);
             }
             return;
         }

package/esm/cli/utils/sanitize-run-output.d.ts

@@ -0,0 +1,2 @@
+export declare function sanitizeRunOutputForLogging(value: unknown): unknown;
+//# sourceMappingURL=sanitize-run-output.d.ts.map

package/esm/cli/utils/sanitize-run-output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize-run-output.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/sanitize-run-output.ts"],"names":[],"mappings":"AAoBA,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAEnE"}

package/esm/cli/utils/{sanitize-job-output.js → sanitize-run-output.js}

@@ -14,6 +14,6 @@ function sanitizeValue(value) {
     }
     return sanitized;
 }
-export function sanitizeJobOutputForLogging(value) {
+export function sanitizeRunOutputForLogging(value) {
     return sanitizeValue(value);
 }

package/esm/cli/utils/write-run-result.d.ts

@@ -0,0 +1,2 @@
+export declare function writeRunResultIfConfigured(value: unknown): Promise<void>;
+//# sourceMappingURL=write-run-result.d.ts.map

package/esm/cli/utils/write-run-result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write-run-result.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/write-run-result.ts"],"names":[],"mappings":"AAWA,wBAAsB,0BAA0B,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAW9E"}

package/esm/cli/utils/write-run-result.js

@@ -0,0 +1,16 @@
+import * as dntShim from "../../_dnt.shims.js";
+import { dirname } from "../../src/platform/compat/path/index.js";
+import { sanitizeRunOutputForLogging } from "./sanitize-run-output.js";
+const RUN_RESULT_PATH_ENV = "VERYFRONT_RUN_RESULT_PATH";
+function getRunResultPath() {
+    const value = dntShim.Deno.env.get(RUN_RESULT_PATH_ENV)?.trim();
+    return value ? value : null;
+}
+export async function writeRunResultIfConfigured(value) {
+    const resultPath = getRunResultPath();
+    if (!resultPath) {
+        return;
+    }
+    await dntShim.Deno.mkdir(dirname(resultPath), { recursive: true });
+    await dntShim.Deno.writeTextFile(resultPath, JSON.stringify(sanitizeRunOutputForLogging(value), null, 2));
+}

package/esm/deno.d.ts

@@ -34,7 +34,7 @@ declare namespace _default {
         "./schemas": string;
         "./prompt": string;
         "./resource": string;
-        "./jobs": string;
+        "./runs": string;
         "./mcp": string;
         "./middleware": string;
         "./observability": string;
@@ -94,7 +94,7 @@ declare namespace _default {
         "veryfront/components/chat": string;
         "veryfront/sandbox": string;
         "veryfront/embedding": string;
-        "veryfront/jobs": string;
+        "veryfront/runs": string;
         "veryfront/agent/identity": string;
         "veryfront/agent/react": string;
         "veryfront/agent/testing": string;
@@ -179,7 +179,8 @@ declare namespace _default {
         "#veryfront/react": string;
         "#veryfront/rendering": string;
         "#veryfront/resource": string;
-        "#veryfront/jobs": string;
+        "#veryfront/runs": string;
+        "#veryfront/runs/": string;
         "#veryfront/routing": string;
         "#veryfront/security": string;
         "#veryfront/skill": string;