voratiq 0.1.0-beta.2 → 0.1.0-beta.21

package/dist/workspace/chat/usage-extractor.js

@@ -0,0 +1,461 @@
+import { readFile } from "node:fs/promises";
+import { isMissing } from "../../utils/fs.js";
+import { extractObservedProviderNativeUsage, PROVIDER_USAGE_SHAPE_MAPPINGS, } from "./usage-mappings.js";
+export async function extractChatUsageFromArtifact(options) {
+    const { artifactPath, format, modelId, providerId } = options;
+    let content;
+    try {
+        content = await readFile(artifactPath, "utf8");
+    }
+    catch (error) {
+        if (isMissing(error)) {
+            return buildUnavailableResult({
+                reason: "missing",
+                artifactPath,
+                format,
+                providerId,
+                modelId,
+                message: "Chat usage artifact was not found.",
+            });
+        }
+        return buildUnavailableResult({
+            reason: "malformed",
+            artifactPath,
+            format,
+            providerId,
+            modelId,
+            message: `Chat usage artifact could not be read: ${String(error)}`,
+        });
+    }
+    const providerShape = PROVIDER_USAGE_SHAPE_MAPPINGS[providerId];
+    if (!providerShape) {
+        return buildUnavailableResult({
+            reason: "unsupported_provider",
+            artifactPath,
+            format,
+            providerId,
+            modelId,
+            message: `Usage extraction is not implemented for provider \`${providerId}\` yet.`,
+        });
+    }
+    if (format !== providerShape.artifactFormat) {
+        const providerLabel = formatProviderLabel(providerId);
+        return buildUnavailableResult({
+            reason: "unsupported_provider",
+            artifactPath,
+            format,
+            providerId,
+            modelId,
+            message: `${providerLabel} usage extraction expects a ${providerShape.artifactFormat} artifact, received \`${format}\`.`,
+        });
+    }
+    switch (providerId) {
+        case "claude":
+            return extractClaudeChatUsageFromJsonl({
+                artifactPath,
+                content,
+                modelId,
+            });
+        case "codex":
+            return extractCodexChatUsageFromJsonl({
+                artifactPath,
+                content,
+                modelId,
+            });
+        case "gemini":
+            return extractGeminiChatUsageFromJson({
+                artifactPath,
+                content,
+                modelId,
+            });
+    }
+}
+export function extractCodexChatUsageFromJsonl(options) {
+    const { artifactPath, content, modelId } = options;
+    const tokenCountEvents = [];
+    const lines = content.split(/\r?\n/u);
+    for (const [index, rawLine] of lines.entries()) {
+        const trimmed = rawLine.trim();
+        if (trimmed.length === 0) {
+            continue;
+        }
+        let parsedLine;
+        try {
+            parsedLine = JSON.parse(trimmed);
+        }
+        catch (error) {
+            return {
+                status: "unavailable",
+                reason: "malformed",
+                provider: "codex",
+                artifactPath,
+                format: "jsonl",
+                modelId,
+                message: `Invalid JSONL at line ${index + 1}: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+        const tokenCountEvent = parseCodexTokenCountEvent(parsedLine);
+        if (tokenCountEvent) {
+            tokenCountEvents.push(tokenCountEvent);
+        }
+    }
+    if (tokenCountEvents.length === 0) {
+        return buildUnavailableResult({
+            reason: "missing",
+            artifactPath,
+            format: "jsonl",
+            providerId: "codex",
+            modelId,
+            message: "No Codex token_count usage events were found in chat.jsonl.",
+        });
+    }
+    const latestTokenCountEvent = tokenCountEvents.at(-1);
+    if (!latestTokenCountEvent) {
+        return buildUnavailableResult({
+            reason: "missing",
+            artifactPath,
+            format: "jsonl",
+            providerId: "codex",
+            modelId,
+            message: "No Codex token_count usage events were found in chat.jsonl.",
+        });
+    }
+    const totalTokenUsage = asRecord(latestTokenCountEvent.info.total_token_usage);
+    if (!totalTokenUsage) {
+        return buildUnavailableResult({
+            reason: "malformed",
+            artifactPath,
+            format: "jsonl",
+            providerId: "codex",
+            modelId,
+            message: "Codex token_count event is missing info.total_token_usage.",
+        });
+    }
+    const usage = extractObservedProviderNativeUsage({
+        providerId: "codex",
+        usagePayload: totalTokenUsage,
+    });
+    if (!usage) {
+        return buildUnavailableResult({
+            reason: "malformed",
+            artifactPath,
+            format: "jsonl",
+            providerId: "codex",
+            modelId,
+            message: "Codex token_count event did not contain any valid token usage fields.",
+        });
+    }
+    return {
+        status: "available",
+        provider: "codex",
+        artifactPath,
+        format: "jsonl",
+        modelId,
+        tokenUsage: usage,
+    };
+}
+export function extractClaudeChatUsageFromJsonl(options) {
+    const { artifactPath, content, modelId } = options;
+    const usageMessages = [];
+    const lines = content.split(/\r?\n/u);
+    for (const [index, rawLine] of lines.entries()) {
+        const trimmed = rawLine.trim();
+        if (trimmed.length === 0) {
+            continue;
+        }
+        let parsedLine;
+        try {
+            parsedLine = JSON.parse(trimmed);
+        }
+        catch (error) {
+            return buildUnavailableResult({
+                reason: "malformed",
+                artifactPath,
+                format: "jsonl",
+                providerId: "claude",
+                modelId,
+                message: `Invalid JSONL at line ${index + 1}: ${error instanceof Error ? error.message : String(error)}`,
+            });
+        }
+        const usageMessage = parseClaudeUsageMessage(parsedLine, index + 1);
+        if (usageMessage) {
+            usageMessages.push(usageMessage);
+        }
+    }
+    if (usageMessages.length === 0) {
+        return buildUnavailableResult({
+            reason: "missing",
+            artifactPath,
+            format: "jsonl",
+            providerId: "claude",
+            modelId,
+            message: "No Claude message.usage payloads were found in chat.jsonl.",
+        });
+    }
+    const normalizedUsage = [];
+    for (const usageMessage of usageMessages) {
+        const usageRecord = asRecord(usageMessage.usage);
+        if (!usageRecord) {
+            return buildUnavailableResult({
+                reason: "malformed",
+                artifactPath,
+                format: "jsonl",
+                providerId: "claude",
+                modelId,
+                message: `Claude message.usage at line ${usageMessage.lineNumber} is not an object.`,
+            });
+        }
+        const usage = extractObservedProviderNativeUsage({
+            providerId: "claude",
+            usagePayload: usageRecord,
+        });
+        if (!usage) {
+            return buildUnavailableResult({
+                reason: "malformed",
+                artifactPath,
+                format: "jsonl",
+                providerId: "claude",
+                modelId,
+                message: `Claude message.usage at line ${usageMessage.lineNumber} did not contain any valid token usage fields.`,
+            });
+        }
+        normalizedUsage.push(usage);
+    }
+    const usage = sumExtractedUsage("claude", normalizedUsage);
+    if (!usage) {
+        return buildUnavailableResult({
+            reason: "malformed",
+            artifactPath,
+            format: "jsonl",
+            providerId: "claude",
+            modelId,
+            message: "Claude message.usage payloads did not contain any valid token usage fields.",
+        });
+    }
+    return {
+        status: "available",
+        provider: "claude",
+        artifactPath,
+        format: "jsonl",
+        modelId,
+        tokenUsage: usage,
+    };
+}
+export function extractGeminiChatUsageFromJson(options) {
+    const { artifactPath, content, modelId } = options;
+    let parsedRoot;
+    try {
+        parsedRoot = JSON.parse(content);
+    }
+    catch (error) {
+        return buildUnavailableResult({
+            reason: "malformed",
+            artifactPath,
+            format: "json",
+            providerId: "gemini",
+            modelId,
+            message: `Invalid JSON: ${error instanceof Error ? error.message : String(error)}`,
+        });
+    }
+    const root = asRecord(parsedRoot);
+    if (!root) {
+        return buildUnavailableResult({
+            reason: "malformed",
+            artifactPath,
+            format: "json",
+            providerId: "gemini",
+            modelId,
+            message: "Gemini chat artifact must be a JSON object.",
+        });
+    }
+    const tokensPayloads = parseGeminiTokensPayloads(root);
+    if (tokensPayloads.length === 0) {
+        return buildUnavailableResult({
+            reason: "missing",
+            artifactPath,
+            format: "json",
+            providerId: "gemini",
+            modelId,
+            message: "No Gemini tokens payloads were found in chat.json.",
+        });
+    }
+    const normalizedUsage = [];
+    for (const tokensPayload of tokensPayloads) {
+        const tokensRecord = asRecord(tokensPayload.tokens);
+        if (!tokensRecord) {
+            return buildUnavailableResult({
+                reason: "malformed",
+                artifactPath,
+                format: "json",
+                providerId: "gemini",
+                modelId,
+                message: `Gemini ${tokensPayload.location} is not an object.`,
+            });
+        }
+        const usage = extractObservedProviderNativeUsage({
+            providerId: "gemini",
+            usagePayload: tokensRecord,
+        });
+        if (!usage) {
+            return buildUnavailableResult({
+                reason: "malformed",
+                artifactPath,
+                format: "json",
+                providerId: "gemini",
+                modelId,
+                message: `Gemini ${tokensPayload.location} did not contain any valid token usage fields.`,
+            });
+        }
+        normalizedUsage.push(usage);
+    }
+    const usage = sumExtractedUsage("gemini", normalizedUsage);
+    if (!usage) {
+        return buildUnavailableResult({
+            reason: "malformed",
+            artifactPath,
+            format: "json",
+            providerId: "gemini",
+            modelId,
+            message: "Gemini tokens payloads did not contain any valid token usage fields.",
+        });
+    }
+    return {
+        status: "available",
+        provider: "gemini",
+        artifactPath,
+        format: "json",
+        modelId,
+        tokenUsage: usage,
+    };
+}
+function buildUnavailableResult(options) {
+    const { reason, artifactPath, format, providerId, modelId, message } = options;
+    return {
+        status: "unavailable",
+        reason,
+        provider: providerId,
+        artifactPath,
+        format,
+        modelId,
+        message,
+    };
+}
+function parseCodexTokenCountEvent(value) {
+    const root = asRecord(value);
+    const eventMsg = parseCodexEnvelope(root);
+    if (eventMsg) {
+        const info = asRecord(eventMsg.info);
+        if (info) {
+            return { info };
+        }
+    }
+    const legacyEventMsg = asRecord(root?.event_msg);
+    if (legacyEventMsg?.type !== "token_count") {
+        return undefined;
+    }
+    const info = asRecord(legacyEventMsg.info);
+    if (!info) {
+        return undefined;
+    }
+    return { info };
+}
+function parseCodexEnvelope(root) {
+    if (root?.type !== "event_msg") {
+        return undefined;
+    }
+    const payload = asRecord(root.payload);
+    if (payload?.type !== "token_count") {
+        return undefined;
+    }
+    return payload;
+}
+function parseClaudeUsageMessage(value, lineNumber) {
+    const root = asRecord(value);
+    const message = asRecord(root?.message);
+    if (!message || !("usage" in message)) {
+        return undefined;
+    }
+    return {
+        lineNumber,
+        usage: message.usage,
+    };
+}
+function parseGeminiTokensPayloads(root) {
+    const tokensPayloads = [];
+    if ("tokens" in root) {
+        tokensPayloads.push({
+            location: "tokens",
+            tokens: root.tokens,
+        });
+    }
+    if ("transcripts" in root) {
+        if (!Array.isArray(root.transcripts)) {
+            return [{ location: "transcripts", tokens: undefined }];
+        }
+        for (const [index, transcript] of root.transcripts.entries()) {
+            const transcriptRecord = asRecord(transcript);
+            const payload = asRecord(transcriptRecord?.payload);
+            if (!payload) {
+                continue;
+            }
+            if ("tokens" in payload) {
+                tokensPayloads.push({
+                    location: `transcripts[${index}].payload.tokens`,
+                    tokens: payload.tokens,
+                });
+            }
+            if (!Array.isArray(payload.messages)) {
+                continue;
+            }
+            for (const [messageIndex, message] of payload.messages.entries()) {
+                const messageRecord = asRecord(message);
+                if (!messageRecord || !("tokens" in messageRecord)) {
+                    continue;
+                }
+                tokensPayloads.push({
+                    location: `transcripts[${index}].payload.messages[${messageIndex}].tokens`,
+                    tokens: messageRecord.tokens,
+                });
+            }
+        }
+    }
+    return tokensPayloads;
+}
+function formatProviderLabel(providerId) {
+    switch (providerId) {
+        case "claude":
+            return "Claude";
+        case "codex":
+            return "Codex";
+        case "gemini":
+            return "Gemini";
+    }
+}
+function asRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return undefined;
+    }
+    return value;
+}
+function sumExtractedUsage(providerId, usages) {
+    if (usages.length === 0) {
+        return undefined;
+    }
+    const totals = {};
+    const fieldMappings = PROVIDER_USAGE_SHAPE_MAPPINGS[providerId].billingRelevantFields;
+    for (const fieldMapping of fieldMappings) {
+        for (const usage of usages) {
+            const usageRecord = asRecord(usage);
+            const value = usageRecord?.[fieldMapping.usageFieldPath];
+            if (typeof value !== "number") {
+                continue;
+            }
+            totals[fieldMapping.usageFieldPath] =
+                (totals[fieldMapping.usageFieldPath] ?? 0) + value;
+        }
+    }
+    return extractObservedProviderNativeUsage({
+        providerId,
+        usagePayload: totals,
+    });
+}

package/dist/workspace/chat/usage-mappings.d.ts

@@ -0,0 +1,20 @@
+import { type ChatUsageProviderId, type ExtractedTokenUsage } from "../../domain/run/model/types.js";
+import type { ChatArtifactFormat } from "./types.js";
+export interface ProviderUsageFieldMapping {
+    artifactFieldPath: string;
+    usageFieldPath: string;
+}
+export interface ProviderUsageShapeMapping {
+    providerId: ChatUsageProviderId;
+    artifactFormat: ChatArtifactFormat;
+    artifactShape: string;
+    usageRootPath: string;
+    billingRelevantFields: readonly ProviderUsageFieldMapping[];
+}
+export declare const PROVIDER_USAGE_SHAPE_MAPPINGS: Record<ChatUsageProviderId, ProviderUsageShapeMapping>;
+interface ExtractObservedProviderNativeUsageOptions {
+    providerId: ChatUsageProviderId;
+    usagePayload: unknown;
+}
+export declare function extractObservedProviderNativeUsage(options: ExtractObservedProviderNativeUsageOptions): ExtractedTokenUsage | undefined;
+export {};

package/dist/workspace/chat/usage-mappings.js

@@ -0,0 +1,136 @@
+import { extractedTokenUsageSchemaByProvider, } from "../../domain/run/model/types.js";
+export const PROVIDER_USAGE_SHAPE_MAPPINGS = {
+    claude: {
+        providerId: "claude",
+        artifactFormat: "jsonl",
+        artifactShape: "message.usage",
+        usageRootPath: "usage",
+        billingRelevantFields: [
+            {
+                artifactFieldPath: "usage.input_tokens",
+                usageFieldPath: "input_tokens",
+            },
+            {
+                artifactFieldPath: "usage.output_tokens",
+                usageFieldPath: "output_tokens",
+            },
+            {
+                artifactFieldPath: "usage.cache_read_input_tokens",
+                usageFieldPath: "cache_read_input_tokens",
+            },
+            {
+                artifactFieldPath: "usage.cache_creation_input_tokens",
+                usageFieldPath: "cache_creation_input_tokens",
+            },
+        ],
+    },
+    codex: {
+        providerId: "codex",
+        artifactFormat: "jsonl",
+        artifactShape: "event_msg(type=token_count).info.total_token_usage",
+        usageRootPath: "event_msg.info.total_token_usage",
+        billingRelevantFields: [
+            {
+                artifactFieldPath: "event_msg.info.total_token_usage.input_tokens",
+                usageFieldPath: "input_tokens",
+            },
+            {
+                artifactFieldPath: "event_msg.info.total_token_usage.cached_input_tokens",
+                usageFieldPath: "cached_input_tokens",
+            },
+            {
+                artifactFieldPath: "event_msg.info.total_token_usage.output_tokens",
+                usageFieldPath: "output_tokens",
+            },
+            {
+                artifactFieldPath: "event_msg.info.total_token_usage.reasoning_output_tokens",
+                usageFieldPath: "reasoning_output_tokens",
+            },
+            {
+                artifactFieldPath: "event_msg.info.total_token_usage.total_tokens",
+                usageFieldPath: "total_tokens",
+            },
+        ],
+    },
+    gemini: {
+        providerId: "gemini",
+        artifactFormat: "json",
+        artifactShape: "transcript.tokens",
+        usageRootPath: "tokens",
+        billingRelevantFields: [
+            {
+                artifactFieldPath: "tokens.input",
+                usageFieldPath: "input",
+            },
+            {
+                artifactFieldPath: "tokens.output",
+                usageFieldPath: "output",
+            },
+            {
+                artifactFieldPath: "tokens.cached",
+                usageFieldPath: "cached",
+            },
+            {
+                artifactFieldPath: "tokens.thoughts",
+                usageFieldPath: "thoughts",
+            },
+            {
+                artifactFieldPath: "tokens.tool",
+                usageFieldPath: "tool",
+            },
+            {
+                artifactFieldPath: "tokens.total",
+                usageFieldPath: "total",
+            },
+        ],
+    },
+};
+export function extractObservedProviderNativeUsage(options) {
+    const mapping = PROVIDER_USAGE_SHAPE_MAPPINGS[options.providerId];
+    const usageRecord = asRecord(options.usagePayload);
+    if (!usageRecord) {
+        return undefined;
+    }
+    const nativeUsage = {};
+    for (const fieldMapping of mapping.billingRelevantFields) {
+        const value = getPathValue(usageRecord, fieldMapping.usageFieldPath);
+        const tokenCount = normalizeTokenCount(value);
+        if (tokenCount !== undefined) {
+            nativeUsage[fieldMapping.usageFieldPath] = tokenCount;
+        }
+    }
+    if (Object.keys(nativeUsage).length === 0) {
+        return undefined;
+    }
+    const parsed = extractedTokenUsageSchemaByProvider[options.providerId].safeParse(nativeUsage);
+    if (!parsed.success) {
+        return undefined;
+    }
+    return parsed.data;
+}
+function asRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return undefined;
+    }
+    return value;
+}
+function getPathValue(record, path) {
+    let current = record;
+    for (const segment of path.split(".")) {
+        const currentRecord = asRecord(current);
+        if (!currentRecord || !(segment in currentRecord)) {
+            return undefined;
+        }
+        current = currentRecord[segment];
+    }
+    return current;
+}
+function normalizeTokenCount(value) {
+    if (typeof value !== "number" ||
+        !Number.isFinite(value) ||
+        !Number.isInteger(value) ||
+        value < 0) {
+        return undefined;
+    }
+    return value;
+}

package/dist/workspace/credential-guard.js

@@ -1,6 +1,6 @@
 import { readdir } from "node:fs/promises";
 import { join, relative } from "node:path";
-import { AgentProcessError } from "../commands/run/errors.js";
+import { AgentProcessError } from "../domain/run/competition/errors.js";
 const FORBIDDEN_SEGMENTS = new Set([".gemini", ".codex", ".claude"]);
 export async function enforceCredentialExclusion(options) {
     const { workspacePath, diffContent } = options;

package/dist/workspace/dependencies.js

@@ -22,7 +22,7 @@ export class WorkspaceDependencyCleanupError extends Error {
 const REPO_BOUNDARY_DESCRIPTION = "the repository root";
 const WORKSPACE_BOUNDARY_DESCRIPTION = "the workspace directory";
 function formatEnvironmentPathRuntimeError(context, detail) {
-    return `Invalid ${context.key} "${context.value}": ${detail}.`;
+    return `Invalid \`${context.key}\` path \`${context.value}\`: ${detail}.`;
 }
 function assertRepoRelativeEnvironmentPath(context) {
     const value = context.value;
@@ -43,7 +43,7 @@ function guardResolvedPath(context, root, resolvedPath, boundaryDescription) {
         return assertPathWithinRoot(root, resolvedPath);
     }
     catch {
-        throw new WorkspaceSetupError(formatEnvironmentPathRuntimeError(context, `resolved path "${resolvedPath}" escapes ${boundaryDescription} (${root}).`));
+        throw new WorkspaceSetupError(formatEnvironmentPathRuntimeError(context, `resolved path \`${resolvedPath}\` escapes ${boundaryDescription} (\`${root}\`).`));
     }
 }
 function createNodeContext(index, value) {
@@ -85,7 +85,7 @@ async function ensureNodeDependencies(root, workspacePath, environment) {
         assertRepoRelativeEnvironmentPath(context);
         const repoDependencyPath = guardResolvedPath(context, root, resolvePath(root, relativeRoot), REPO_BOUNDARY_DESCRIPTION);
         if (!(await pathExists(repoDependencyPath))) {
-            throw new WorkspaceSetupError(formatEnvironmentPathRuntimeError(context, `expected directory at "${repoDependencyPath}" but it does not exist.`));
+            throw new WorkspaceSetupError(formatEnvironmentPathRuntimeError(context, `expected directory at \`${repoDependencyPath}\` but it does not exist.`));
         }
         const workspaceDependencyPath = guardResolvedPath(context, workspacePath, resolvePath(workspacePath, relativeRoot), WORKSPACE_BOUNDARY_DESCRIPTION);
         await ensureDirectoryLink(repoDependencyPath, workspaceDependencyPath, {
@@ -104,7 +104,7 @@ async function ensurePythonEnvironment(root, workspacePath, environment) {
     assertRepoRelativeEnvironmentPath(context);
     const repoPythonPath = guardResolvedPath(context, root, resolvePath(root, pythonPath), REPO_BOUNDARY_DESCRIPTION);
     if (!(await pathExists(repoPythonPath))) {
-        throw new WorkspaceSetupError(formatEnvironmentPathRuntimeError(context, `expected directory at "${repoPythonPath}" but it does not exist.`));
+        throw new WorkspaceSetupError(formatEnvironmentPathRuntimeError(context, `expected directory at \`${repoPythonPath}\` but it does not exist.`));
     }
     const workspacePythonPath = guardResolvedPath(context, workspacePath, resolvePath(workspacePath, ".venv"), WORKSPACE_BOUNDARY_DESCRIPTION);
     await ensureDirectoryLink(repoPythonPath, workspacePythonPath, {

package/dist/workspace/errors.d.ts

@@ -6,6 +6,11 @@ export declare class WorkspaceMissingEntryError extends WorkspaceError {
     readonly entryPath: string;
     constructor(entryPath: string);
 }
+export declare class WorkspaceWrongTypeEntryError extends WorkspaceError {
+    readonly entryPath: string;
+    readonly expectedType: "file" | "directory";
+    constructor(entryPath: string, expectedType: "file" | "directory");
+}
 export declare class WorkspaceNotInitializedError extends WorkspaceError {
     readonly missingEntries: readonly string[];
     constructor(missingEntries: readonly string[]);