@gencode/uni 0.4.1 → 0.4.2

package/dist/uni/src/run.js

@@ -1,16 +1,13 @@
 import { randomUUID } from "node:crypto";
 import path from "node:path";
 import { isAgentDiagnosticEvent } from "@gencode/shared";
-import { ArtifactAccumulator } from "./artifacts/accumulator.js";
-import { ARTIFACTS_START_TAG, parseAndStripArtifacts, } from "./artifacts/parser.js";
-import { ArtifactStreamFilter } from "./artifacts/stream-filter.js";
-import { inferArtifactsFromToolExecution } from "./artifacts/tool-inference.js";
 import { generateApiKey } from "./auth/api-key.js";
 import { normalizeProviderEvent } from "./events/normalizer.js";
 import { UniHookDispatcher } from "./hooks.js";
 import { providerStateDir, providerStateRoot } from "./providers/provider-state.js";
 import { createBuiltInProviderRegistry } from "./providers/registry.js";
-import { createArtifactOperationRecorder } from "./session/artifact-operation-store.js";
+import { createChangeOperationRecorder } from "./session/change-operation-store.js";
+import { clearArtifactPersistenceFailure, loadArtifactPersistenceFailure, } from "./mcp/artifact-server.js";
 import { createUniContextStore, } from "./session/context-store.js";
 import { resolveRunInput } from "./session/input.js";
 import { initializeUniLogger, uniLogger } from "./session/logger.js";
@@ -29,18 +26,39 @@ const ALIGNED_RUNTIME_AGENTS = new Set([
     "opencode",
     "pi",
 ]);
-const UNI_ARTIFACT_DECLARATION_PROMPT = [
-    "## Artifact Declaration",
-    "Before your final answer, audit the current turn for user-relevant persistent files and user-openable URLs.",
-    "If this turn produced, modified, exported, downloaded, uploaded, shared, or published any such artifact, append exactly one JSON array block in this form:",
-    "<aimax_artifacts>",
-    '[{"kind":"file","file":"/absolute/or/workspace-relative/path","label":"short description"},{"kind":"url","url":"https://example.test/result","label":"short description"}]',
-    "</aimax_artifacts>",
-    "Audit successful write/edit/apply_patch operations, command outputs and redirections, plugin/skill results, online resources, and explicit child-agent artifacts.",
-    "Do not declare deleted, failed, read-only, temporary/cache, or internal AIMax session files.",
-    "If there are no artifacts, omit the block. Do not duplicate paths or URLs.",
-    "The block is for the runtime parser. It must be the last content in the answer, with no text after </aimax_artifacts>.",
-].join("\n");
+function artifactToolPrompt(runtimeAgent) {
+    const toolName = runtimeAgent === "pi"
+        ? "record_artifacts"
+        : runtimeAgent === "opencode"
+            ? "aimax_record_artifacts"
+            : "mcp__aimax__record_artifacts";
+    return [
+        "## Mandatory Current-Run Finalization Checkpoint",
+        `The final-artifact tool exposed by this provider is \`${toolName}\`.`,
+        "This instruction applies to the CURRENT user request, including every follow-up, resume, retry, or new turn in an existing Session.",
+        "For THIS run, call the final-artifact tool exactly once after all generation, modification, export, publication, download, upload, and verification work is complete.",
+        "A final-artifact tool call visible in earlier conversation history is already consumed by that earlier run and never satisfies THIS run.",
+        "Before calling it, audit the entire run and submit every final user-deliverable file and URL in one call.",
+        "The artifact tool must be the final tool call. After it succeeds, immediately provide the final answer and call no other tool.",
+        "If this run produced no final artifacts, still call it with `{ \"artifacts\": [] }`.",
+        "Do not provide the final answer until THIS run's fresh final-artifact tool call has completed.",
+        "A final artifact must have been created, generated, exported, downloaded, published, or materially modified in this run specifically for the user. It must be part of the requested result, remain valid when the task ends, be something the user will directly open/use, and not be an intermediate output.",
+        "Record by default:",
+        "- Final PDF, DOCX, XLSX, PPTX, images, audio, video, reports, data exports, archives, installers, and release packages.",
+        "- Standalone scripts, examples, or projects explicitly requested as deliverables.",
+        "- Files downloaded into the workspace for delivery to the user.",
+        "- User-openable online documents, Wiki pages, published pages, share links, and download links.",
+        "- Modified source files only when the user explicitly requested those files themselves as deliverables.",
+        "- Child-agent deliverables only when the root run adopts them as part of the final result.",
+        "Do not record by default:",
+        "- Ordinary repository code changes, unit-test changes, configuration files, lockfiles, changesets, or routine engineering-documentation edits.",
+        "- Temporary files, caches, logs, test stdout/stderr, build intermediates, node_modules, or dependency caches.",
+        "- Files that were only read, or outputs that were deleted, failed, rolled back, replaced, or are no longer valid.",
+        "- AIMax internal state, session files, memory files, context snapshots, or tool-result spill files.",
+        "Decision test: without looking at the git diff, is this file or URL itself something the user asked to take away, open, or use? If not, do not record it.",
+        "Final reminder: an earlier call never counts. THIS run must make its own fresh call, including when resuming the same Session.",
+    ].join("\n");
+}
 export const UNSUPPORTED_UNI_RUN_OPTION_MESSAGES = {
     agent: "--agent is not supported by @gencode/uni yet",
     skillsLoadPaths: "--skillsLoadPaths is not supported by @gencode/uni yet",
@@ -274,21 +292,22 @@ function promptText(input) {
         return input.message;
     return input.singleUserText ?? JSON.stringify(input.messages);
 }
-function providerInput(input, aligned) {
+function providerInput(input, aligned, runtimeAgent) {
     if (!aligned)
         return input;
+    const prompt = artifactToolPrompt(runtimeAgent);
     if (input.kind === "text") {
-        return { kind: "text", message: `${input.message}\n\n${UNI_ARTIFACT_DECLARATION_PROMPT}` };
+        return { kind: "text", message: `${input.message}\n\n${prompt}` };
     }
     const messages = [
         ...input.messages,
-        { role: "user", content: UNI_ARTIFACT_DECLARATION_PROMPT },
+        { role: "user", content: prompt },
     ];
     return {
         kind: "messages",
         messages,
         ...(input.singleUserText
-            ? { singleUserText: `${input.singleUserText}\n\n${UNI_ARTIFACT_DECLARATION_PROMPT}` }
+            ? { singleUserText: `${input.singleUserText}\n\n${prompt}` }
             : {}),
     };
 }
@@ -444,46 +463,6 @@ function firstString(record, keys) {
     }
     return undefined;
 }
-function patchSummary(input) {
-    const added = [];
-    const modified = [];
-    const deleted = [];
-    const changes = input.changes;
-    if (Array.isArray(changes)) {
-        for (const raw of changes) {
-            if (!raw || typeof raw !== "object")
-                continue;
-            const change = raw;
-            const file = firstString(change, ["path", "file", "file_path"]);
-            if (!file)
-                continue;
-            const kind = firstString(change, ["kind", "type", "operation"])?.toLowerCase();
-            if (kind === "add" || kind === "create")
-                added.push(file);
-            else if (kind === "delete" || kind === "remove")
-                deleted.push(file);
-            else
-                modified.push(file);
-        }
-    }
-    const patch = firstString(input, ["patch", "input"]);
-    if (patch) {
-        for (const line of patch.split(/\r?\n/)) {
-            const match = line.match(/^\*\*\* (Add|Update|Delete) File:\s*(.+)$/);
-            if (!match?.[2])
-                continue;
-            if (match[1] === "Add")
-                added.push(match[2].trim());
-            else if (match[1] === "Delete")
-                deleted.push(match[2].trim());
-            else
-                modified.push(match[2].trim());
-        }
-    }
-    if (added.length + modified.length + deleted.length === 0)
-        return undefined;
-    return { added, modified, deleted };
-}
 function structuredFileChangesPatch(input) {
     const changes = toRecord(input).changes;
     if (!Array.isArray(changes))
@@ -512,19 +491,19 @@ function structuredFileChangesPatch(input) {
     markers.push("*** End Patch");
     return markers.length > 2 ? markers.join("\n") : undefined;
 }
-function artifactAuditStartEvent(event) {
+function changeAuditStartEvent(event) {
     if (canonicalToolName(event.name) !== "apply_patch")
         return event;
     const patch = structuredFileChangesPatch(event.input);
     return patch ? { ...event, name: "apply_patch", input: { patch } } : event;
 }
-function artifactAuditEndEvent(event) {
+function changeAuditEndEvent(event) {
     if (canonicalToolName(event.name) !== "apply_patch")
         return event;
     const patch = structuredFileChangesPatch(event.input);
     return patch ? { ...event, name: "apply_patch", input: { patch } } : event;
 }
-function artifactAuditFileOperation(event) {
+function changeAuditFileOperation(event) {
     const name = canonicalToolName(event.name);
     if (name !== "apply_patch")
         return { ...event, name };
@@ -535,94 +514,6 @@ function artifactAuditFileOperation(event) {
         ...(patch ? { input: { patch } } : {}),
     };
 }
-function inferenceResultForTool(params) {
-    const input = toRecord(params.input);
-    const name = canonicalToolName(params.name);
-    const content = [{ type: "text", text: params.output }];
-    if (name === "write_file") {
-        return { content, details: { path: firstString(input, ["path", "file_path", "filePath"]) } };
-    }
-    if (name === "edit_file") {
-        return {
-            content,
-            details: {
-                path: firstString(input, ["path", "file_path", "filePath"]),
-                occurrences: params.isError ? 0 : 1,
-            },
-        };
-    }
-    if (name === "apply_patch")
-        return { content, details: { summary: patchSummary(input) } };
-    if (name === "exec" || name === "bash" || name === "process") {
-        return {
-            content,
-            details: {
-                status: params.isError ? "failed" : "completed",
-                cwd: firstString(input, ["cwd"]) ?? undefined,
-            },
-        };
-    }
-    return params.output;
-}
-function inferenceResult(event) {
-    return inferenceResultForTool(event);
-}
-function isInternalArtifact(artifact, dataDir) {
-    if (artifact.kind !== "file")
-        return false;
-    const internalRoot = path.resolve(dataDir, ".aimax");
-    const candidate = path.resolve(artifact.file);
-    return candidate === internalRoot || candidate.startsWith(`${internalRoot}${path.sep}`);
-}
-function parseArtifactArray(value, workspaceDir) {
-    if (!Array.isArray(value))
-        return [];
-    const now = new Date().toISOString();
-    return value.flatMap((raw) => {
-        if (!raw || typeof raw !== "object" || Array.isArray(raw))
-            return [];
-        const record = raw;
-        const label = typeof record.label === "string" && record.label.trim()
-            ? record.label.trim()
-            : undefined;
-        if (record.kind === "file" && typeof record.file === "string" && record.file.trim() && label) {
-            const file = path.isAbsolute(record.file) ? path.normalize(record.file) : path.resolve(workspaceDir, record.file);
-            return [{ kind: "file", file, label, timestamp: now }];
-        }
-        if (record.kind === "url" && typeof record.url === "string" && record.url.trim() && label) {
-            try {
-                const url = new URL(record.url).toString();
-                return [{ kind: "url", url, label, timestamp: now }];
-            }
-            catch {
-                return [];
-            }
-        }
-        return [];
-    });
-}
-function extractChildArtifacts(toolName, output, workspaceDir) {
-    const normalized = toolName.trim().toLowerCase().replaceAll("-", "_");
-    if (!normalized.includes("subagent") && normalized !== "task" && normalized !== "batch")
-        return [];
-    let parsed;
-    try {
-        parsed = JSON.parse(output);
-    }
-    catch {
-        return [];
-    }
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
-        return [];
-    const record = parsed;
-    const direct = parseArtifactArray(record.artifacts, workspaceDir);
-    if (direct.length > 0)
-        return direct;
-    const result = record.result;
-    return result && typeof result === "object" && !Array.isArray(result)
-        ? parseArtifactArray(result.artifacts, workspaceDir)
-        : [];
-}
 export async function runUni(options) {
     const config = await resolveRunConfig(options);
     initializeUniLogger(config.dataDir);
@@ -691,13 +582,28 @@ export async function runUni(options) {
         runtimeAgent: config.runtimeAgent,
         messageId: config.messageId,
     });
-    const streamFilter = aligned ? new ArtifactStreamFilter() : undefined;
-    const artifactAccumulator = aligned
-        ? new ArtifactAccumulator({ urlWhitelist: config.artifactsUrlWhitelist })
+    const workspaceDir = config.projectDir ?? path.join(config.dataDir, "workspace");
+    const artifactStoreOptions = aligned
+        ? {
+            dataDir: config.dataDir,
+            logicalSessionId: config.sessionId,
+            storeName: config.sessionStore,
+            workspaceDir,
+            projectDir: config.projectDir,
+            urlWhitelist: config.artifactsUrlWhitelist,
+        }
+        : undefined;
+    if (artifactStoreOptions) {
+        await clearArtifactPersistenceFailure(artifactStoreOptions);
+    }
+    const artifactTool = artifactStoreOptions
+        ? {
+            configBase64: Buffer.from(JSON.stringify(artifactStoreOptions), "utf8")
+                .toString("base64url"),
+        }
         : undefined;
-    const workspaceDir = config.projectDir ?? config.dataDir;
     const operationRecorder = aligned && config.channel !== "CRON"
-        ? createArtifactOperationRecorder({
+        ? createChangeOperationRecorder({
             dataDir: config.dataDir,
             logicalSessionId: config.sessionId,
             storeName: config.sessionStore,
@@ -713,6 +619,7 @@ export async function runUni(options) {
     let observedUsage;
     let observedModel;
     let observedError;
+    let artifactPersistenceFailure;
     let observedTitle;
     const emitProgress = async (event) => {
         progressEvents.push(event);
@@ -741,9 +648,7 @@ export async function runUni(options) {
     });
     const emitVisibleText = async (type, text) => {
         rawProviderText += text;
-        const visible = streamFilter ? streamFilter.push(text) : text;
-        if (!visible)
-            return;
+        const visible = text;
         await flushCompletedTools();
         turn.addText(visible);
         const normalized = normalizeProviderEvent(config.sessionId, config.messageId, { type, text: visible });
@@ -803,8 +708,9 @@ export async function runUni(options) {
                 flashModel: config.flashModel,
                 timeoutMs: config.timeoutMs,
                 runtimeConfig: config.runtimeConfig,
-                input: providerInput(config.input, aligned),
+                input: providerInput(config.input, aligned, config.runtimeAgent),
                 signal: abortController.signal,
+                artifactTool,
             }, async (providerEvent) => {
                 let eventForProgress = providerEvent;
                 if (providerEvent.type === "session_started") {
@@ -838,18 +744,9 @@ export async function runUni(options) {
                     return;
                 }
                 if (providerEvent.type === "file_operation") {
-                    const auditEvent = artifactAuditFileOperation(providerEvent);
+                    const auditEvent = changeAuditFileOperation(providerEvent);
                     await Promise.resolve(operationRecorder?.recordObservedFileOperation(auditEvent))
                         .catch(() => undefined);
-                    if (!providerEvent.isError && artifactAccumulator) {
-                        artifactAccumulator.addInferred(inferArtifactsFromToolExecution({
-                            toolName: canonicalToolName(providerEvent.name),
-                            input: toRecord(providerEvent.input),
-                            result: inferenceResultForTool(providerEvent),
-                            isError: false,
-                            workspaceDir,
-                        }).filter((artifact) => !isInternalArtifact(artifact, config.dataDir)));
-                    }
                     return;
                 }
                 if (providerEvent.type === "tool_start") {
@@ -861,7 +758,7 @@ export async function runUni(options) {
                         startedAt: Date.now(),
                     });
                     turn.startTool(providerEvent);
-                    await Promise.resolve(operationRecorder?.onToolStart(artifactAuditStartEvent(providerEvent)))
+                    await Promise.resolve(operationRecorder?.onToolStart(changeAuditStartEvent(providerEvent)))
                         .catch(() => undefined);
                     await hookDispatcher.dispatchBeforeToolCall({
                         toolCallId: providerEvent.toolCallId,
@@ -879,9 +776,14 @@ export async function runUni(options) {
                             input: active.params,
                         }
                         : providerEvent;
+                    const normalizedToolName = toolEndEvent.name.toLowerCase();
+                    if (toolEndEvent.isError
+                        && normalizedToolName.includes("record_artifacts")) {
+                        artifactPersistenceFailure = toolEndEvent.output || "record_artifacts failed";
+                    }
                     eventForProgress = toolEndEvent;
-                    const paired = turn.endTool(toolEndEvent);
-                    await Promise.resolve(operationRecorder?.onToolEnd(artifactAuditEndEvent(toolEndEvent)))
+                    turn.endTool(toolEndEvent);
+                    await Promise.resolve(operationRecorder?.onToolEnd(changeAuditEndEvent(toolEndEvent)))
                         .catch(() => undefined);
                     if (config.runtimeAgent === "opencode"
                         && !observedToolStartIds.has(toolEndEvent.toolCallId)
@@ -903,17 +805,6 @@ export async function runUni(options) {
                     }).catch((error) => {
                         uniLogger.warn("failed to persist observable tool result", { error: String(error) });
                     });
-                    if (aligned && paired && !providerEvent.isError && artifactAccumulator) {
-                        artifactAccumulator.addChild(extractChildArtifacts(toolEndEvent.name, toolEndEvent.output, workspaceDir)
-                            .filter((artifact) => !isInternalArtifact(artifact, config.dataDir)));
-                        artifactAccumulator.addInferred(inferArtifactsFromToolExecution({
-                            toolName: canonicalToolName(toolEndEvent.name),
-                            input: params,
-                            result: inferenceResult(toolEndEvent),
-                            isError: toolEndEvent.isError,
-                            workspaceDir,
-                        }).filter((artifact) => !isInternalArtifact(artifact, config.dataDir)));
-                    }
                     await hookDispatcher.dispatchAfterToolCall({
                         toolCallId: providerEvent.toolCallId,
                         toolName: toolEndEvent.name,
@@ -957,47 +848,12 @@ export async function runUni(options) {
             await bindProviderSession(providerResult.sessionId);
             observedProviderSessionIds.add(providerResult.sessionId);
         }
-        const filterTail = streamFilter?.finish() ?? "";
-        if (filterTail) {
-            await flushCompletedTools();
-            turn.addText(filterTail);
-            for (const event of normalizeProviderEvent(config.sessionId, config.messageId, {
-                type: "text_delta",
-                text: filterTail,
-            }))
-                await emitProgress(event);
-        }
         const hasExplicitTerminalText = providerResult.text !== undefined || observedDoneText !== undefined;
         const rawProviderFinalText = providerResult.text ?? observedDoneText ?? rawProviderText;
         const providerFinalText = aligned
             ? redactKnownProviderIds(rawProviderFinalText, observedProviderSessionIds)
             : rawProviderFinalText;
-        const parsedArtifacts = aligned
-            ? parseAndStripArtifacts(providerFinalText, { workspaceDir })
-            : { cleanedText: providerFinalText, artifacts: [], warnings: [] };
-        const streamedArtifactParse = aligned
-            && rawProviderText !== providerFinalText
-            && rawProviderText.includes(ARTIFACTS_START_TAG)
-            ? parseAndStripArtifacts(rawProviderText, { workspaceDir })
-            : undefined;
-        artifactAccumulator?.addOwn(parsedArtifacts.artifacts.filter((artifact) => !isInternalArtifact(artifact, config.dataDir)));
-        artifactAccumulator?.addOwn((streamedArtifactParse?.artifacts ?? [])
-            .filter((artifact) => !isInternalArtifact(artifact, config.dataDir)));
-        for (const warning of new Set([
-            ...parsedArtifacts.warnings,
-            ...(streamedArtifactParse?.warnings ?? []),
-        ])) {
-            await emitProgress({
-                type: "diagnostic",
-                sessionId: config.sessionId,
-                messageId: config.messageId,
-                level: "warn",
-                scope: "runner",
-                phase: "artifact_declaration",
-                message: warning,
-            });
-        }
-        if (rawProviderText && state.finalText !== parsedArtifacts.cleanedText) {
+        if (rawProviderText && state.finalText !== providerFinalText) {
             await emitProgress({
                 type: "diagnostic",
                 sessionId: config.sessionId,
@@ -1010,12 +866,17 @@ export async function runUni(options) {
         }
         const usage = providerResult.usage ?? observedUsage;
         const rawError = providerResult.error ?? observedError;
-        const error = rawError
+        const providerError = rawError
             ? redactKnownProviderIds(rawError, observedProviderSessionIds)
             : undefined;
+        artifactPersistenceFailure ??= artifactStoreOptions
+            ? await loadArtifactPersistenceFailure(artifactStoreOptions)
+            : undefined;
+        const error = artifactPersistenceFailure
+            ? `Artifact persistence failed: ${artifactPersistenceFailure}`
+            : providerError;
         const durationMs = Date.now() - startedAt;
-        const artifacts = artifactAccumulator?.dump() ?? [];
-        state.finalText = parsedArtifacts.cleanedText;
+        state.finalText = providerFinalText;
         if (!usage && aligned) {
             await emitProgress({
                 type: "diagnostic",
@@ -1028,12 +889,11 @@ export async function runUni(options) {
             });
         }
         const finalEntries = turn.finalize({
-            fallbackContent: parsedArtifacts.cleanedText,
+            fallbackContent: providerFinalText,
             forceFallbackContent: hasExplicitTerminalText,
             usage,
             durationMs,
             error,
-            artifacts: artifacts.length > 0 ? artifacts : undefined,
         });
         await appendTurnEntries(finalEntries);
         if (usage && contextStore) {
@@ -1067,11 +927,10 @@ export async function runUni(options) {
             });
         }
         const resultPayload = {
-            text: parsedArtifacts.cleanedText,
+            text: providerFinalText,
             usage: usage ?? { ...ZERO_USAGE },
             durationMs,
             ...(error ? { error } : {}),
-            ...(aligned && artifacts.length > 0 ? { artifacts } : {}),
         };
         if (error) {
             uniLogger.error("uni run failed", {