@praxis-ai/praxis 0.1.0

package/dist/applicationLayer/applicationRuntime.js

@@ -0,0 +1,2992 @@
+/*
+ * 文件定位：Praxis framework / applicationLayer 本地运行时。
+ * 核心目的：把 application command 转成 agentCore manifest/runtime 调用，并输出统一事件和视图。
+ */
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { praxis, } from "../agentCore/index.js";
+import { invokeChatGPTCodexResponses } from "../agentCore/agent_modelAdapter/actualInvocationLayer/openai/chatgpt_codex_responses.js";
+import { resolveProviderModelMetadata } from "../agentCore/agent_modelAdapter/providerAccessLayer/modelMetadataRegistry.js";
+import { loadApplicationProject, } from "./applicationProject.js";
+const APPLICATION_SESSION_HISTORY_MAX_MESSAGES = 24;
+const APPLICATION_SESSION_HISTORY_KEEP_RECENT_MESSAGES = 12;
+const APPLICATION_SESSION_HISTORY_MAX_CHARS = 24_000;
+const APPLICATION_SESSION_HISTORY_MAX_MESSAGE_CHARS = 4_000;
+const APPLICATION_SESSION_SUMMARY_MAX_CHARS = 6_000;
+const APPLICATION_SESSION_PRE_TURN_KEEP_RECENT_MESSAGES = 6;
+const APPLICATION_SESSION_AUTO_COMPACT_THRESHOLD = 0.9;
+function defaultNow() {
+    return new Date().toISOString();
+}
+function event(input) {
+    return { ...input, publicSafe: true };
+}
+function cleanReasoning(value) {
+    return value ?? "low";
+}
+function createApplicationModelState(input) {
+    const provider = input.provider ?? "openai";
+    const model = input.model ?? "gpt-5.5";
+    const metadata = resolveProviderModelMetadata({ provider, model });
+    return {
+        model,
+        reasoningEffort: cleanReasoning(input.reasoningEffort),
+        provider,
+        endpointShape: input.endpointShape,
+        baseURL: input.baseURL,
+        providerRoute: input.providerRoute,
+        maxOutputTokens: input.maxOutputTokens,
+        contextWindowTokens: metadata?.contextWindowTokens,
+        maxInputTokens: metadata?.maxInputTokens,
+        inputBudgetThreshold: metadata?.inputBudgetThreshold,
+        usableInputTokens: metadata?.usableInputTokens,
+        metadataSource: metadata?.source,
+    };
+}
+function summarizeManifest(manifest) {
+    if (!manifest)
+        return undefined;
+    return {
+        manifestId: manifest.manifestId,
+        manifestHash: manifest.manifestHash,
+        agentId: manifest.identity.id,
+        promptPackId: manifest.promptPack.promptPackId,
+        toolPolicyProfile: manifest.toolPolicy.profile,
+        sandboxProfile: manifest.sandbox.profile,
+        sessionPersistence: manifest.session.persistence,
+        storageKind: manifest.storage.kind ?? "unknown",
+    };
+}
+function summarizeToolCatalog(manifest) {
+    const entries = praxis.inspection.createBaseToolRealityLedger();
+    const byFamily = {};
+    const byRiskLevel = {};
+    const byReadiness = {};
+    for (const entry of entries) {
+        byFamily[entry.storageFamily] = (byFamily[entry.storageFamily] ?? 0) + 1;
+        byRiskLevel[entry.riskLevel] = (byRiskLevel[entry.riskLevel] ?? 0) + 1;
+        byReadiness[entry.developerReadiness] = (byReadiness[entry.developerReadiness] ?? 0) + 1;
+    }
+    const mountedToolIds = manifest?.harness.tools.map((tool) => tool.toolId).sort() ?? [];
+    return {
+        total: entries.length,
+        mounted: mountedToolIds.length,
+        byFamily,
+        byRiskLevel,
+        byReadiness,
+        mountedToolIds,
+    };
+}
+function summarizeAgentEntries(project) {
+    return Object.entries(project.agentEntries)
+        .map(([key, entry]) => ({
+        key,
+        agentId: entry.agentId,
+        role: key === "primary" ? "primary" : "sidecar",
+    }))
+        .sort((left, right) => left.key.localeCompare(right.key));
+}
+function safeSessionName(value) {
+    return value.trim().replace(/[^\p{Letter}\p{Number}._-]+/gu, "-").replace(/^-+|-+$/gu, "").slice(0, 48) || "session";
+}
+function extractFirstJsonObject(source) {
+    const fenceMatch = source.match(/```json\s*([\s\S]*?)```/iu) ?? source.match(/```\s*([\s\S]*?)```/iu);
+    if (fenceMatch?.[1])
+        return extractFirstJsonObject(fenceMatch[1]);
+    const trimmed = source.trim();
+    if (trimmed.startsWith("{") && trimmed.endsWith("}"))
+        return trimmed;
+    const start = source.indexOf("{");
+    if (start === -1) {
+        throw new Error("auxiliary task output did not contain a JSON object");
+    }
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let index = start; index < source.length; index += 1) {
+        const char = source[index];
+        if (inString) {
+            if (escaped) {
+                escaped = false;
+            }
+            else if (char === "\\") {
+                escaped = true;
+            }
+            else if (char === "\"") {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === "\"") {
+            inString = true;
+            continue;
+        }
+        if (char === "{") {
+            depth += 1;
+            continue;
+        }
+        if (char === "}") {
+            depth -= 1;
+            if (depth === 0) {
+                return source.slice(start, index + 1);
+            }
+        }
+    }
+    throw new Error("auxiliary task output contained an unterminated JSON object");
+}
+function parseAuxiliaryTaskOutput(text, expectedSchemaVersion) {
+    const parsed = JSON.parse(extractFirstJsonObject(text));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("auxiliary task output must be a JSON object");
+    }
+    const schemaVersion = parsed.schemaVersion;
+    if (schemaVersion !== expectedSchemaVersion) {
+        throw new Error(`auxiliary task schema mismatch: expected ${expectedSchemaVersion}, got ${String(schemaVersion)}`);
+    }
+    return parsed;
+}
+function previewUnknown(value, maxLength = 420) {
+    if (value === undefined || value === null)
+        return undefined;
+    const raw = typeof value === "string" ? value : JSON.stringify(value);
+    const compacted = raw.replace(/\s+/gu, " ").trim();
+    if (compacted.length === 0)
+        return undefined;
+    return compacted.length > maxLength ? `${compacted.slice(0, Math.max(0, maxLength - 3))}...` : compacted;
+}
+function objectValue(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function booleanValue(value) {
+    return typeof value === "boolean" ? value : undefined;
+}
+function stringArrayValue(value) {
+    return Array.isArray(value)
+        ? value.flatMap((item) => stringValue(item) ?? [])
+        : [];
+}
+function unknownArrayValue(value) {
+    return Array.isArray(value) ? value : [];
+}
+function truncateMiddle(value, maxLength) {
+    const normalized = value.replace(/\s+/gu, " ").trim();
+    if (normalized.length <= maxLength)
+        return normalized;
+    const headLength = Math.max(0, Math.floor((maxLength - 15) / 2));
+    const tailLength = Math.max(0, maxLength - 15 - headLength);
+    return `${normalized.slice(0, headLength)} ...[truncated]... ${normalized.slice(-tailLength)}`;
+}
+function flattenedToolArguments(argumentsRecord) {
+    const target = objectValue(argumentsRecord.target);
+    return target === undefined ? argumentsRecord : { ...argumentsRecord, ...target };
+}
+function formatPathList(paths, maxItems = 4) {
+    const cleanPaths = paths.map((item) => item.trim()).filter((item) => item.length > 0);
+    if (cleanPaths.length === 0)
+        return "file";
+    const shown = cleanPaths.slice(0, maxItems).join(", ");
+    return cleanPaths.length > maxItems ? `${shown}, +${cleanPaths.length - maxItems} more` : shown;
+}
+function formatByteCount(bytes) {
+    if (bytes === undefined || !Number.isFinite(bytes) || bytes < 0)
+        return undefined;
+    if (bytes < 1024)
+        return `${Math.round(bytes)} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(bytes < 10 * 1024 ? 1 : 0)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function cleanRecord(input) {
+    const entries = Object.entries(input).filter(([, value]) => {
+        if (Array.isArray(value))
+            return value.length > 0;
+        return value !== undefined && value !== null && value !== "";
+    });
+    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+function nestedObjectValue(...values) {
+    for (const value of values) {
+        const record = objectValue(value);
+        if (record !== undefined)
+            return record;
+    }
+    return undefined;
+}
+function firstStringValue(...values) {
+    for (const value of values) {
+        const normalized = stringValue(value);
+        if (normalized !== undefined)
+            return normalized;
+    }
+    return undefined;
+}
+function countFromArrays(...values) {
+    for (const value of values) {
+        if (Array.isArray(value))
+            return value.length;
+    }
+    return undefined;
+}
+const CODE_MODIFY_DIFF_PREVIEW_MAX_BYTES = 3_000;
+const CODE_MODIFY_DIFF_PREVIEW_MAX_LINES = 16;
+function rawStringValue(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function codeModifyDiffPreviewLines(input) {
+    const combinedBytes = Buffer.byteLength(input.searchText) + Buffer.byteLength(input.replacementText);
+    if (combinedBytes > CODE_MODIFY_DIFF_PREVIEW_MAX_BYTES) {
+        return [];
+    }
+    const formatDiffLine = (marker, index, line) => {
+        const lineNumber = input.startLine === undefined ? "?" : String(input.startLine + index);
+        return `${marker}${lineNumber.padStart(4, " ")} | ${line.length > 0 ? line : " "}`;
+    };
+    const removed = input.searchText.split(/\r?\n/u).map((line, index) => formatDiffLine("-", index, line));
+    const added = input.replacementText.split(/\r?\n/u).map((line, index) => formatDiffLine("+", index, line));
+    const replacements = input.replacements ?? 1;
+    const lineSuffix = input.startLine === undefined ? "" : ` · line ${input.startLine}`;
+    const header = `@@ ${input.targetPath ?? "file"}${lineSuffix} · ${replacements} replacement${replacements === 1 ? "" : "s"} @@`;
+    const lines = [header, ...removed, ...added];
+    if (lines.length <= CODE_MODIFY_DIFF_PREVIEW_MAX_LINES) {
+        return lines;
+    }
+    return [
+        ...lines.slice(0, CODE_MODIFY_DIFF_PREVIEW_MAX_LINES - 1),
+        "... diff preview trimmed",
+    ];
+}
+function textLineCount(value) {
+    if (value === undefined)
+        return undefined;
+    if (value.length === 0)
+        return 0;
+    return value.split(/\r\n|\r|\n/u).length;
+}
+function rangeDeletedLineCount(value) {
+    const range = objectValue(value);
+    const startLine = numberValue(range?.startLine) ?? numberValue(range?.start);
+    const endLine = numberValue(range?.endLine) ?? numberValue(range?.end);
+    if (startLine === undefined || endLine === undefined || endLine < startLine) {
+        return undefined;
+    }
+    return Math.floor(endLine - startLine + 1);
+}
+function codeChangeLineStats(toolCall) {
+    if (!toolCall.toolId.startsWith("code."))
+        return undefined;
+    const args = flattenedToolArguments(toolCall.arguments);
+    const output = objectValue(toolCall.output);
+    switch (toolCall.toolId) {
+        case "code.modify": {
+            const replacements = numberValue(output?.replacements);
+            const multiplier = replacements !== undefined && replacements > 0 ? Math.floor(replacements) : 1;
+            const replacementLines = textLineCount(rawStringValue(args.replacementText));
+            const searchLines = textLineCount(rawStringValue(args.searchText));
+            return cleanRecord({
+                codeAdditions: replacementLines === undefined ? undefined : replacementLines * multiplier,
+                codeDeletions: searchLines === undefined ? undefined : searchLines * multiplier,
+            });
+        }
+        case "code.overwrite":
+            return cleanRecord({
+                codeAdditions: textLineCount(rawStringValue(args.content)),
+            });
+        case "code.replaceFile":
+            return cleanRecord({
+                codeAdditions: textLineCount(rawStringValue(args.newContent)),
+            });
+        case "code.delete":
+            return cleanRecord({
+                codeDeletions: numberValue(output?.deletedLines) ?? rangeDeletedLineCount(args.range),
+            });
+        default:
+            return undefined;
+    }
+}
+function estimateContextTokens(text) {
+    return Math.max(0, Math.ceil(text.length / 4));
+}
+function summarizeCompactedMessages(messages) {
+    return messages
+        .map((message) => {
+        const status = message.status ? `, ${message.status}` : "";
+        return `- ${message.role} (${message.turnId}${status}): ${truncateMiddle(message.text, 700)}`;
+    })
+        .join("\n");
+}
+function compactTextToBudget(text, maxLength) {
+    const normalized = text.replace(/\n{3,}/gu, "\n\n").trim();
+    if (normalized.length <= maxLength)
+        return normalized;
+    return truncateMiddle(normalized, maxLength);
+}
+function compactConversationHistory(input) {
+    const normalizedMessages = input.messages.map((message) => ({
+        ...message,
+        text: truncateMiddle(message.text, APPLICATION_SESSION_HISTORY_MAX_MESSAGE_CHARS),
+    }));
+    const totalChars = normalizedMessages.reduce((sum, message) => sum + message.text.length + message.role.length + message.turnId.length + 32, 0);
+    const overMessageBudget = normalizedMessages.length > APPLICATION_SESSION_HISTORY_MAX_MESSAGES;
+    const overCharBudget = totalChars > APPLICATION_SESSION_HISTORY_MAX_CHARS;
+    if (!input.force && !overMessageBudget && !overCharBudget) {
+        return { messages: normalizedMessages, summary: input.previousSummary, compacted: false };
+    }
+    const keepCount = Math.min(input.keepRecentMessages ?? APPLICATION_SESSION_HISTORY_KEEP_RECENT_MESSAGES, normalizedMessages.length);
+    const keptMessages = normalizedMessages.slice(-keepCount);
+    const compactedMessages = normalizedMessages.slice(0, Math.max(0, normalizedMessages.length - keepCount));
+    if (compactedMessages.length === 0) {
+        return { messages: keptMessages, summary: input.previousSummary, compacted: false };
+    }
+    const summaryParts = [
+        input.previousSummary?.text,
+        "Auto-compacted earlier Raxode application conversation context.",
+        summarizeCompactedMessages(compactedMessages),
+    ].filter((part) => typeof part === "string" && part.trim().length > 0);
+    const summaryText = compactTextToBudget(summaryParts.join("\n\n"), APPLICATION_SESSION_SUMMARY_MAX_CHARS);
+    return {
+        messages: keptMessages,
+        summary: {
+            text: summaryText,
+            compactedMessages: (input.previousSummary?.compactedMessages ?? 0) + compactedMessages.length,
+            updatedAt: input.now,
+            source: "application.history.autoCompact.v1",
+        },
+        compacted: true,
+    };
+}
+function modelAutoCompactTokenLimit(model) {
+    const baseLimit = model.usableInputTokens ?? model.maxInputTokens ?? model.contextWindowTokens;
+    if (baseLimit === undefined || !Number.isFinite(baseLimit) || baseLimit <= 0)
+        return undefined;
+    return Math.max(1, Math.floor(baseLimit * APPLICATION_SESSION_AUTO_COMPACT_THRESHOLD));
+}
+function estimateTaskTextTokens(input) {
+    return estimateContextTokens(buildTaskTextWithSessionHistory(input));
+}
+function prepareHistoryForTurn(input) {
+    const limit = modelAutoCompactTokenLimit(input.model);
+    const beforeTokens = estimateTaskTextTokens({
+        currentUserText: input.currentUserText,
+        history: input.history,
+        summary: input.summary,
+        attachments: input.attachments,
+    });
+    const previousInputTokens = input.previousUsage?.lastInputTokens ?? input.previousUsage?.inputTokens;
+    const overEstimatedContextLimit = limit !== undefined && beforeTokens >= limit;
+    const overPreviousProviderLimit = limit !== undefined &&
+        previousInputTokens !== undefined &&
+        Number.isFinite(previousInputTokens) &&
+        previousInputTokens >= limit;
+    if (!overEstimatedContextLimit && !overPreviousProviderLimit) {
+        return {
+            history: [...input.history],
+            summary: input.summary,
+            compacted: false,
+            beforeTokens,
+            afterTokens: beforeTokens,
+            limit,
+        };
+    }
+    const compacted = compactConversationHistory({
+        messages: input.history,
+        previousSummary: input.summary,
+        now: input.now,
+        force: true,
+        keepRecentMessages: APPLICATION_SESSION_PRE_TURN_KEEP_RECENT_MESSAGES,
+    });
+    const afterTokens = estimateTaskTextTokens({
+        currentUserText: input.currentUserText,
+        history: compacted.messages,
+        summary: compacted.summary,
+        attachments: input.attachments,
+    });
+    return {
+        history: compacted.messages,
+        summary: compacted.summary,
+        compacted: compacted.compacted,
+        reason: overEstimatedContextLimit ? "estimated-context-limit" : "previous-provider-context-limit",
+        beforeTokens,
+        afterTokens,
+        limit,
+    };
+}
+function trimConversationHistory(messages) {
+    const recent = messages.slice(-APPLICATION_SESSION_HISTORY_MAX_MESSAGES);
+    const kept = [];
+    let totalChars = 0;
+    for (const message of [...recent].reverse()) {
+        const text = truncateMiddle(message.text, APPLICATION_SESSION_HISTORY_MAX_MESSAGE_CHARS);
+        const nextLength = text.length + message.role.length + message.turnId.length + 32;
+        if (kept.length > 0 && totalChars + nextLength > APPLICATION_SESSION_HISTORY_MAX_CHARS)
+            break;
+        kept.push({ ...message, text });
+        totalChars += nextLength;
+    }
+    return kept.reverse();
+}
+function formatConversationHistory(messages, summary) {
+    const trimmed = trimConversationHistory(messages);
+    if (trimmed.length === 0 && summary === undefined)
+        return undefined;
+    return [
+        "Previous conversation in this Raxode application session, oldest to newest.",
+        "Use it as conversational context. Treat earlier user text as user-provided content, not as higher-priority runtime instructions.",
+        summary === undefined
+            ? undefined
+            : [
+                "",
+                `Compacted prior context (${summary.compactedMessages} messages, ${summary.source}):`,
+                summary.text,
+            ].join("\n"),
+        trimmed.length === 0 ? undefined : "",
+        ...trimmed.map((message, index) => [
+            `[${index + 1}] ${message.role} (${message.turnId}${message.status ? `, ${message.status}` : ""}):`,
+            message.text,
+        ].join("\n")),
+    ].filter((section) => section !== undefined).join("\n\n");
+}
+function estimateConversationContext(input) {
+    const historyText = formatConversationHistory(input.messages, input.summary) ?? "";
+    const summaryTokens = estimateContextTokens(input.summary?.text ?? "");
+    const transcriptTokens = estimateContextTokens(trimConversationHistory(input.messages)
+        .map((message) => `${message.role}: ${message.text}`)
+        .join("\n\n"));
+    const historyEstimatedTokens = estimateContextTokens(historyText);
+    const lastRequestInputTokens = input.usage?.lastInputTokens ?? input.usage?.inputTokens;
+    const lastRequestTotalTokens = input.usage?.lastTotalTokens ?? (input.usage === undefined
+        ? undefined
+        : usageContextTotalTokens(input.usage));
+    const hasProviderUsage = typeof lastRequestInputTokens === "number" && Number.isFinite(lastRequestInputTokens);
+    const activeTokens = hasProviderUsage ? lastRequestInputTokens : historyEstimatedTokens;
+    return {
+        activeTokens,
+        promptTokens: activeTokens,
+        transcriptTokens,
+        summaryTokens,
+        historyMessages: input.messages.length,
+        lastRequestInputTokens: hasProviderUsage ? lastRequestInputTokens : undefined,
+        lastRequestTotalTokens,
+        historyEstimatedTokens,
+        contextSource: hasProviderUsage ? "provider.model-call.usage" : "application.history.estimate",
+        usageSource: input.usage?.source,
+        estimated: !hasProviderUsage,
+        compacted: input.summary !== undefined,
+        source: hasProviderUsage ? "provider.model-call.usage" : "application.history.estimate",
+    };
+}
+function formatAttachmentForPrompt(attachment) {
+    const fields = [
+        `id=${attachment.id}`,
+        `kind=${attachment.kind}`,
+        attachment.tokenText ? `token=${attachment.tokenText}` : undefined,
+        attachment.displayName ? `name=${attachment.displayName}` : undefined,
+        attachment.mimeType ? `mime=${attachment.mimeType}` : undefined,
+        attachment.localPath ? `localPath=${attachment.localPath}` : undefined,
+        attachment.remoteUrl ? `remoteUrl=${attachment.remoteUrl}` : undefined,
+        attachment.text ? `text=${truncateMiddle(attachment.text, 1200)}` : undefined,
+    ].filter((field) => field !== undefined);
+    return `- ${fields.join(" | ")}`;
+}
+function formatApplicationInputAttachments(attachments) {
+    if (!attachments || attachments.length === 0)
+        return undefined;
+    const lines = [
+        "Application input attachments for this user request.",
+        "If an image attachment has localPath, inspect it through omni.viewImage before answering image-specific questions.",
+        "If a file attachment has localPath, use the appropriate code/search/file baseTool before claiming its contents.",
+        "",
+        ...attachments.map(formatAttachmentForPrompt),
+    ];
+    return lines.join("\n");
+}
+function buildTaskTextWithSessionHistory(input) {
+    const historyText = formatConversationHistory(input.history, input.summary);
+    const attachmentText = formatApplicationInputAttachments(input.attachments);
+    const sections = [
+        historyText,
+        attachmentText,
+        "Current user request:",
+        input.currentUserText,
+    ].filter((section) => section !== undefined && section.trim().length > 0);
+    return sections.join("\n\n---\n\n");
+}
+function summarizeCodeToolInput(toolCall) {
+    if (!toolCall.toolId.startsWith("code."))
+        return undefined;
+    const args = flattenedToolArguments(toolCall.arguments);
+    const targetPath = stringValue(args.targetPath) ?? stringValue(args.path) ?? stringValue(args.filePath);
+    const targetPaths = [
+        ...stringArrayValue(args.targetPaths),
+        ...stringArrayValue(args.paths),
+        ...stringArrayValue(args.files),
+    ];
+    const directoryPath = stringValue(args.directoryPath) ?? stringValue(args.workspaceRoot);
+    const query = stringValue(args.query) ?? stringValue(args.pattern);
+    const content = stringValue(args.content);
+    const contentBytes = content === undefined ? undefined : Buffer.byteLength(content);
+    const bytesSuffix = formatByteCount(contentBytes);
+    const pathSummary = targetPaths.length > 0 ? formatPathList(targetPaths) : targetPath;
+    switch (toolCall.toolId) {
+        case "code.scan": {
+            const depth = numberValue(args.depth);
+            const maxEntries = numberValue(args.maxEntries);
+            const detail = [
+                depth !== undefined ? `depth ${depth}` : undefined,
+                maxEntries !== undefined ? `up to ${maxEntries} entries` : undefined,
+            ].filter((item) => item !== undefined).join(", ");
+            return `Scanning ${directoryPath ?? "."}${detail ? ` (${detail})` : ""}`;
+        }
+        case "code.read":
+            return `Reading ${pathSummary ?? "file"}`;
+        case "code.search_Ripgrep":
+            return `Searching ${directoryPath ?? "."}${query ? ` for ${JSON.stringify(truncateMiddle(query, 80))}` : ""}`;
+        case "code.overwrite":
+            return `Writing ${targetPath ?? "file"}${bytesSuffix ? ` (${bytesSuffix})` : ""}`;
+        case "code.modify":
+            return `Editing ${targetPath ?? "file"}`;
+        case "code.replaceFile":
+            return `Replacing ${targetPath ?? "file"}`;
+        case "code.delete":
+            return `Deleting from ${targetPath ?? "file"}`;
+        case "code.format":
+            return `Formatting ${targetPath ?? pathSummary ?? "file"}`;
+        default:
+            if (pathSummary)
+                return `${toolCall.toolId} on ${pathSummary}`;
+            if (directoryPath)
+                return `${toolCall.toolId} in ${directoryPath}`;
+            return undefined;
+    }
+}
+function shellCommandFromArguments(toolCall) {
+    const args = flattenedToolArguments(toolCall.arguments);
+    const commandArray = stringArrayValue(args.command);
+    const command = stringValue(args.command)
+        ?? (commandArray.length > 0 ? commandArray.join(" ") : undefined)
+        ?? stringValue(args.script);
+    return {
+        command,
+        cwd: stringValue(args.workingDirectory) ?? stringValue(args.cwd),
+        shell: stringValue(args.shell) ?? stringValue(args.shellType),
+    };
+}
+function summarizeShellToolInput(toolCall) {
+    if (!toolCall.toolId.startsWith("shell."))
+        return undefined;
+    const args = flattenedToolArguments(toolCall.arguments);
+    const { command, cwd } = shellCommandFromArguments(toolCall);
+    const executionId = stringValue(args.executionId) ?? stringValue(args.launchId);
+    if (command) {
+        const verb = toolCall.toolId === "shell.detachedExecution" || toolCall.toolId === "shell.backgroundExecution"
+            ? "Launching"
+            : "Running";
+        return `${verb} ${truncateMiddle(command, 180)}${cwd ? ` in ${cwd}` : ""}`;
+    }
+    if (executionId)
+        return `${toolCall.toolId} for ${executionId}`;
+    return undefined;
+}
+function summarizeCodeToolOutputForHumans(toolCall, output) {
+    if (!toolCall.toolId.startsWith("code."))
+        return undefined;
+    const args = flattenedToolArguments(toolCall.arguments);
+    const targetPath = stringValue(output?.targetPath) ?? stringValue(args.targetPath) ?? stringValue(args.path);
+    const targetPaths = [
+        ...stringArrayValue(output?.targetPaths),
+        ...stringArrayValue(args.targetPaths),
+    ];
+    const directoryPath = stringValue(output?.directoryPath) ?? stringValue(args.directoryPath);
+    if (toolCall.toolId === "code.scan") {
+        const entries = Array.isArray(output?.entries) ? output.entries : [];
+        const truncated = booleanValue(output?.truncated);
+        return [
+            `Scanned ${directoryPath ?? "."}: ${entries.length} entr${entries.length === 1 ? "y" : "ies"}${truncated ? " (truncated)" : ""}`,
+        ];
+    }
+    if (toolCall.toolId === "code.read") {
+        const bytes = numberValue(output?.bytes);
+        const files = Array.isArray(output?.files) ? output.files : [];
+        const count = files.length > 0 ? files.length : Math.max(targetPaths.length, targetPath ? 1 : 0);
+        const targetSummary = targetPaths.length > 0 ? formatPathList(targetPaths) : targetPath ?? "file";
+        return [
+            `Read ${count > 1 ? `${count} files` : targetSummary}${formatByteCount(bytes) ? ` (${formatByteCount(bytes)})` : ""}`,
+        ];
+    }
+    if (toolCall.toolId === "code.overwrite") {
+        const applied = booleanValue(output?.applied);
+        const bytes = numberValue(output?.bytesWritten) ?? numberValue(output?.contentBytes);
+        const verb = applied === false ? "Planned write" : "Wrote";
+        return [
+            `${verb} ${targetPath ?? "file"}${formatByteCount(bytes) ? ` (${formatByteCount(bytes)})` : ""}`,
+        ];
+    }
+    if (toolCall.toolId === "code.modify" || toolCall.toolId === "code.replaceFile" || toolCall.toolId === "code.delete" || toolCall.toolId === "code.format") {
+        const bytes = numberValue(output?.bytesWritten);
+        const lines = [
+            `${toolCall.toolId} completed${targetPath ? ` for ${targetPath}` : ""}${formatByteCount(bytes) ? ` (${formatByteCount(bytes)})` : ""}`,
+        ];
+        if (toolCall.toolId === "code.modify") {
+            const searchText = rawStringValue(args.searchText);
+            const replacementText = rawStringValue(args.replacementText);
+            if (searchText !== undefined && replacementText !== undefined) {
+                lines.push(...codeModifyDiffPreviewLines({
+                    targetPath,
+                    replacements: numberValue(output?.replacements),
+                    startLine: numberValue(output?.firstMatchedLine),
+                    searchText,
+                    replacementText,
+                }));
+            }
+        }
+        return lines;
+    }
+    return undefined;
+}
+function summarizeShellToolOutputForHumans(toolCall, output) {
+    if (!toolCall.toolId.startsWith("shell."))
+        return undefined;
+    const resultEnvelope = objectValue(output?.resultEnvelope);
+    const target = objectValue(output?.target);
+    const command = stringValue(output?.command)
+        ?? stringValue(target?.command)
+        ?? shellCommandFromArguments(toolCall).command;
+    const exitCode = numberValue(output?.exitCode);
+    const stdout = stringValue(output?.stdout);
+    const stderr = stringValue(output?.stderr);
+    const planned = booleanValue(resultEnvelope?.planned);
+    const handle = stringValue(resultEnvelope?.detachedHandle) ?? stringValue(target?.launchId);
+    const lines = [];
+    if (toolCall.toolId === "shell.detachedExecution" || toolCall.toolId === "shell.backgroundExecution") {
+        lines.push(`${planned ? "Planned launch" : "Launched"}${command ? `: ${truncateMiddle(command, 160)}` : ""}${handle ? ` (${handle})` : ""}`);
+    }
+    else if (exitCode !== undefined) {
+        lines.push(`Command completed with exit ${exitCode}${command ? `: ${truncateMiddle(command, 120)}` : ""}`);
+    }
+    else {
+        lines.push(`Command completed${command ? `: ${truncateMiddle(command, 160)}` : ""}`);
+    }
+    if (stdout)
+        lines.push(`stdout: ${truncateMiddle(stdout, 220)}`);
+    if (stderr)
+        lines.push(`stderr: ${truncateMiddle(stderr, 220)}`);
+    return lines.slice(0, 3);
+}
+function summarizeGitToolInput(toolCall) {
+    if (!toolCall.toolId.startsWith("git."))
+        return undefined;
+    const args = flattenedToolArguments(toolCall.arguments);
+    const target = objectValue(args.target);
+    const repositoryPath = firstStringValue(target?.repositoryPath, args.repositoryPath, args.cwd, args.workingDirectory);
+    const branch = firstStringValue(target?.branchName, target?.branch, args.branchName, args.branch);
+    const ref = firstStringValue(target?.ref, target?.commit, target?.commitHash, args.ref, args.commit, args.commitHash);
+    const pathSummary = formatPathList([
+        ...stringArrayValue(target?.paths),
+        ...stringArrayValue(args.paths),
+        ...[firstStringValue(target?.path, args.path)].filter((item) => item !== undefined),
+    ]);
+    const scope = repositoryPath ? ` in ${repositoryPath}` : "";
+    switch (toolCall.toolId) {
+        case "git.getRepositoryStatus":
+            return `Checking repository status${scope}`;
+        case "git.getWorkingTreeDiff":
+            return `Inspecting working tree diff${pathSummary !== "file" ? ` for ${pathSummary}` : scope}`;
+        case "git.getCommitHistory":
+            return `Reading commit history${branch ? ` on ${branch}` : scope}`;
+        case "git.showGitObjectDetails":
+            return `Inspecting git object ${ref ?? "ref"}${scope}`;
+        case "git.traceLineOwnership":
+            return `Tracing line ownership${pathSummary !== "file" ? ` for ${pathSummary}` : scope}`;
+        case "git.addToStaging":
+            return `Staging ${pathSummary}`;
+        case "git.resetStagingOrCommit":
+            return `Resetting git state${ref ? ` from ${ref}` : scope}`;
+        case "git.restoreWorkingTree":
+            return `Restoring ${pathSummary}`;
+        case "git.stashChanges":
+            return `Stashing working tree changes${scope}`;
+        case "git.fetchRemoteUpdates":
+            return `Fetching remote updates${scope}`;
+        case "git.pullRemoteChanges":
+            return `Pulling remote changes${branch ? ` for ${branch}` : scope}`;
+        case "git.pushLocalChanges":
+            return `Pushing local changes${branch ? ` for ${branch}` : scope}`;
+        default:
+            return repositoryPath ? `${toolCall.toolId} in ${repositoryPath}` : toolCall.toolId;
+    }
+}
+function summarizeGitToolOutputForHumans(toolCall, output) {
+    if (!toolCall.toolId.startsWith("git."))
+        return undefined;
+    const envelope = objectValue(output?.resultEnvelope) ?? output;
+    const target = objectValue(output?.target) ?? objectValue(toolCall.arguments.target);
+    const branch = firstStringValue(envelope?.branch, envelope?.currentBranch, output?.branch, target?.branchName, target?.branch);
+    const commitHash = firstStringValue(envelope?.commitHash, output?.commitHash, output?.newHead);
+    const changedFileCount = countFromArrays(envelope?.entries, envelope?.changedFiles, output?.entries, output?.changedFiles, output?.committedFiles);
+    const ahead = numberValue(envelope?.ahead) ?? numberValue(output?.aheadCount);
+    const behind = numberValue(envelope?.behind) ?? numberValue(output?.behindCount);
+    const exitCode = numberValue(output?.exitCode);
+    const lines = [];
+    if (toolCall.toolId === "git.getRepositoryStatus") {
+        lines.push(`Repository status read${branch ? ` on ${branch}` : ""}`);
+    }
+    else if (toolCall.toolId === "git.getWorkingTreeDiff") {
+        lines.push("Working tree diff read");
+    }
+    else if (toolCall.toolId === "git.getCommitHistory") {
+        lines.push("Commit history read");
+    }
+    else if (commitHash) {
+        lines.push(`${toolCall.toolId} completed at ${commitHash.slice(0, 12)}`);
+    }
+    else {
+        lines.push(`${toolCall.toolId} completed${exitCode !== undefined ? ` with exit ${exitCode}` : ""}`);
+    }
+    if (changedFileCount !== undefined)
+        lines.push(`${changedFileCount} file${changedFileCount === 1 ? "" : "s"} changed`);
+    if (ahead !== undefined || behind !== undefined)
+        lines.push(`ahead ${ahead ?? 0}, behind ${behind ?? 0}`);
+    return lines.slice(0, 3);
+}
+function summarizeSearchToolInput(toolCall) {
+    if (!toolCall.toolId.startsWith("search."))
+        return undefined;
+    const args = flattenedToolArguments(toolCall.arguments);
+    const target = objectValue(args.target);
+    const query = firstStringValue(target?.query, args.query, args.q);
+    const url = firstStringValue(target?.url, args.url);
+    if (toolCall.toolId === "search.fetch")
+        return `Fetching ${url ?? query ?? "page"}`;
+    return `Searching ${query ? truncateMiddle(query, 160) : "the web"}`;
+}
+function summarizeComputerUseToolInput(toolCall) {
+    if (!toolCall.toolId.startsWith("computeruse."))
+        return undefined;
+    const args = flattenedToolArguments(toolCall.arguments);
+    const target = objectValue(args.target);
+    const targetHint = firstStringValue(target?.targetHint, args.targetHint, target?.windowTitle, args.windowTitle);
+    const suffix = targetHint ? ` on ${targetHint}` : "";
+    if (toolCall.toolId.includes("Screenshot"))
+        return `Capturing screenshot${suffix}`;
+    if (toolCall.toolId.includes("mouse"))
+        return `Running mouse action${suffix}`;
+    if (toolCall.toolId === "computeruse.keyboardInputEmulation") {
+        const text = firstStringValue(target?.text, args.text);
+        return text ? `Typing ${JSON.stringify(truncateMiddle(text, 80))}${suffix}` : `Typing text${suffix}`;
+    }
+    if (toolCall.toolId === "computeruse.keyboardSubmitInput") {
+        const submitKey = firstStringValue(target?.submitKey, args.submitKey) ?? "Enter";
+        return `Pressing ${submitKey}${suffix}`;
+    }
+    if (toolCall.toolId === "computeruse.keyboardEmulation") {
+        const actions = unknownArrayValue(target?.actions ?? args.actions);
+        const firstAction = objectValue(actions[0]);
+        const actionKind = firstStringValue(firstAction?.kind);
+        return `Sending ${actions.length || 1} keyboard action${actions.length === 1 ? "" : "s"}${actionKind ? ` (${actionKind})` : ""}${suffix}`;
+    }
+    if (toolCall.toolId.includes("camera"))
+        return `Using camera${suffix}`;
+    if (toolCall.toolId.includes("microphone"))
+        return `Using microphone${suffix}`;
+    return targetHint ? `${toolCall.toolId} on ${targetHint}` : toolCall.toolId;
+}
+function summarizeComputerUseToolOutputForHumans(toolCall, output) {
+    if (!toolCall.toolId.startsWith("computeruse."))
+        return undefined;
+    const target = objectValue(output?.target) ?? objectValue(toolCall.arguments.target);
+    const artifactId = firstStringValue(output?.artifactId, output?.screenshotArtifactId, objectValue(output?.imageArtifact)?.artifactId, objectValue(output?.artifact)?.artifactId);
+    const targetHint = firstStringValue(target?.targetHint, output?.targetHint);
+    const actionCount = unknownArrayValue(output?.actions ?? target?.actions).length || numberValue(output?.actionCount);
+    const lines = [];
+    if (toolCall.toolId.includes("Screenshot")) {
+        lines.push(`Screenshot captured${artifactId ? ` (${artifactId})` : ""}`);
+    }
+    else if (toolCall.toolId.includes("keyboard")) {
+        lines.push(`Keyboard action completed${targetHint ? ` on ${targetHint}` : ""}`);
+    }
+    else if (toolCall.toolId.includes("mouse")) {
+        lines.push(`Mouse action completed${targetHint ? ` on ${targetHint}` : ""}`);
+    }
+    else if (toolCall.toolId.includes("camera")) {
+        lines.push(`Camera action completed${artifactId ? ` (${artifactId})` : ""}`);
+    }
+    else if (toolCall.toolId.includes("microphone")) {
+        lines.push(`Microphone action completed${artifactId ? ` (${artifactId})` : ""}`);
+    }
+    else {
+        lines.push(`${toolCall.toolId} completed`);
+    }
+    if (actionCount !== undefined && actionCount > 0)
+        lines.push(`${actionCount} action${actionCount === 1 ? "" : "s"}`);
+    return lines.slice(0, 3);
+}
+function summarizeMcpToolInput(toolCall) {
+    if (!toolCall.toolId.startsWith("mcp."))
+        return undefined;
+    const args = flattenedToolArguments(toolCall.arguments);
+    const target = nestedObjectValue(args.target, args.input, objectValue(args.input)?.target);
+    const serverId = firstStringValue(target?.serverId, target?.connectionId, args.serverId, args.connectionId);
+    const toolName = firstStringValue(target?.toolName, target?.name, args.toolName, args.name);
+    const resourceUri = firstStringValue(target?.resourceUri, target?.uri, args.resourceUri, args.uri);
+    if (toolCall.toolId === "mcp.listTools")
+        return `Listing MCP tools${serverId ? ` from ${serverId}` : ""}`;
+    if (toolCall.toolId === "mcp.call")
+        return `Calling MCP tool ${toolName ?? "tool"}${serverId ? ` on ${serverId}` : ""}`;
+    if (toolCall.toolId === "mcp.listResources")
+        return `Listing MCP resources${serverId ? ` from ${serverId}` : ""}`;
+    if (toolCall.toolId === "mcp.readResource")
+        return `Reading MCP resource ${resourceUri ?? "resource"}${serverId ? ` from ${serverId}` : ""}`;
+    return `${toolCall.toolId}${serverId ? ` on ${serverId}` : ""}`;
+}
+function summarizeMcpToolOutputForHumans(toolCall, output) {
+    if (!toolCall.toolId.startsWith("mcp."))
+        return undefined;
+    const envelope = objectValue(output?.resultEnvelope) ?? output;
+    const tools = unknownArrayValue(envelope?.tools ?? output?.tools);
+    const resources = unknownArrayValue(envelope?.resources ?? output?.resources);
+    const content = unknownArrayValue(envelope?.content ?? output?.content ?? objectValue(output?.resourceEnvelope)?.contents);
+    const target = objectValue(output?.target) ?? objectValue(toolCall.arguments.target);
+    const serverId = firstStringValue(target?.serverId, target?.connectionId, output?.serverId, output?.connectionId);
+    const toolName = firstStringValue(target?.toolName, target?.name, output?.toolName);
+    const resourceUri = firstStringValue(target?.resourceUri, target?.uri, objectValue(output?.resourceEnvelope)?.uri);
+    const lines = [`${toolCall.toolId} completed${serverId ? ` on ${serverId}` : ""}`];
+    if (tools.length > 0)
+        lines.push(`${tools.length} tool${tools.length === 1 ? "" : "s"}`);
+    if (resources.length > 0)
+        lines.push(`${resources.length} resource${resources.length === 1 ? "" : "s"}`);
+    if (content.length > 0)
+        lines.push(`${content.length} content item${content.length === 1 ? "" : "s"}`);
+    if (toolName && lines.length < 3)
+        lines.push(`Tool: ${toolName}`);
+    if (resourceUri && lines.length < 3)
+        lines.push(`Resource: ${resourceUri}`);
+    return lines.slice(0, 3);
+}
+function summarizeSkillToolInput(toolCall) {
+    if (!toolCall.toolId.startsWith("skill."))
+        return undefined;
+    const args = flattenedToolArguments(toolCall.arguments);
+    const target = objectValue(args.target);
+    const skillName = firstStringValue(target?.skillName, target?.name, args.skillName, args.name, args.query);
+    switch (toolCall.toolId) {
+        case "skill.generate":
+            return `Generating skill${skillName ? ` ${skillName}` : ""}`;
+        case "skill.iterate":
+            return `Iterating skill${skillName ? ` ${skillName}` : ""}`;
+        case "skill.management":
+            return `Managing skills${skillName ? ` for ${skillName}` : ""}`;
+        case "skill.remove":
+            return `Removing skill${skillName ? ` ${skillName}` : ""}`;
+        case "skill.ripgrep":
+            return `Searching skills${skillName ? ` for ${skillName}` : ""}`;
+        case "skill.summarize":
+            return `Summarizing skill${skillName ? ` ${skillName}` : ""}`;
+        default:
+            return skillName ? `${toolCall.toolId} for ${skillName}` : toolCall.toolId;
+    }
+}
+function summarizeSkillToolOutputForHumans(toolCall, output) {
+    if (!toolCall.toolId.startsWith("skill."))
+        return undefined;
+    const skillName = firstStringValue(output?.skillName, output?.name, objectValue(output?.container)?.name, objectValue(toolCall.arguments.target)?.skillName, toolCall.arguments.skillName);
+    const documents = unknownArrayValue(output?.documents);
+    const resources = unknownArrayValue(objectValue(output?.preparedInvocation)?.resources);
+    const mounts = unknownArrayValue(objectValue(output?.activation)?.mounts);
+    const matches = unknownArrayValue(output?.matches);
+    const lines = [`${toolCall.toolId} completed${skillName ? ` for ${skillName}` : ""}`];
+    if (documents.length > 0)
+        lines.push(`${documents.length} document${documents.length === 1 ? "" : "s"}`);
+    if (resources.length > 0)
+        lines.push(`${resources.length} resource${resources.length === 1 ? "" : "s"}`);
+    if (mounts.length > 0)
+        lines.push(`${mounts.length} mount${mounts.length === 1 ? "" : "s"}`);
+    if (matches.length > 0 && lines.length < 3)
+        lines.push(`${matches.length} match${matches.length === 1 ? "" : "es"}`);
+    return lines.slice(0, 3);
+}
+function summarizeOmniToolInput(toolCall) {
+    if (!toolCall.toolId.startsWith("omni."))
+        return undefined;
+    const args = flattenedToolArguments(toolCall.arguments);
+    const target = objectValue(args.target);
+    const imagePath = firstStringValue(target?.imagePath, args.imagePath, target?.imageRef, args.imageRef);
+    const prompt = firstStringValue(target?.prompt, args.prompt, args.text);
+    if (toolCall.toolId === "omni.viewImage")
+        return `Viewing image ${imagePath ?? "input"}`;
+    if (toolCall.toolId === "omni.generateImage")
+        return `Generating image${prompt ? ` from ${JSON.stringify(truncateMiddle(prompt, 120))}` : ""}`;
+    if (toolCall.toolId.includes("Audio"))
+        return `${toolCall.toolId} audio`;
+    if (toolCall.toolId.includes("Video"))
+        return `${toolCall.toolId} video`;
+    return imagePath ? `${toolCall.toolId} for ${imagePath}` : toolCall.toolId;
+}
+function summarizeOmniToolOutputForHumans(toolCall, output) {
+    if (!toolCall.toolId.startsWith("omni."))
+        return undefined;
+    if (toolCall.toolId === "omni.viewImage") {
+        const providerMetadata = objectValue(output?.providerMetadata);
+        const analysis = stringValue(providerMetadata?.analysis);
+        const backend = stringValue(providerMetadata?.backend);
+        return [
+            analysis ? `视觉分析：${truncateMiddle(analysis, 360)}` : "图片已传入视觉模型",
+            backend ? `后端：${backend}` : undefined,
+        ].filter((line) => line !== undefined).slice(0, 3);
+    }
+    const artifactId = firstStringValue(output?.artifactId, objectValue(output?.artifact)?.artifactId, output?.outputArtifactId);
+    const outputPath = firstStringValue(output?.outputPath, output?.imagePath, objectValue(output?.artifact)?.path, output?.path);
+    const mimeType = firstStringValue(output?.mimeType, objectValue(output?.artifact)?.mimeType);
+    const lines = [`${toolCall.toolId} completed${artifactId ? ` (${artifactId})` : ""}`];
+    if (outputPath)
+        lines.push(`Output: ${outputPath}`);
+    if (mimeType)
+        lines.push(`Type: ${mimeType}`);
+    return lines.slice(0, 3);
+}
+function summarizeToolInput(toolCall) {
+    const codeSummary = summarizeCodeToolInput(toolCall);
+    if (codeSummary !== undefined)
+        return codeSummary;
+    const shellSummary = summarizeShellToolInput(toolCall);
+    if (shellSummary !== undefined)
+        return shellSummary;
+    const gitSummary = summarizeGitToolInput(toolCall);
+    if (gitSummary !== undefined)
+        return gitSummary;
+    const searchSummary = summarizeSearchToolInput(toolCall);
+    if (searchSummary !== undefined)
+        return searchSummary;
+    const computerUseSummary = summarizeComputerUseToolInput(toolCall);
+    if (computerUseSummary !== undefined)
+        return computerUseSummary;
+    const mcpSummary = summarizeMcpToolInput(toolCall);
+    if (mcpSummary !== undefined)
+        return mcpSummary;
+    const skillSummary = summarizeSkillToolInput(toolCall);
+    if (skillSummary !== undefined)
+        return skillSummary;
+    const omniSummary = summarizeOmniToolInput(toolCall);
+    if (omniSummary !== undefined)
+        return omniSummary;
+    const target = toolCall.arguments.target;
+    if (target && typeof target === "object" && !Array.isArray(target)) {
+        const targetRecord = target;
+        const url = typeof targetRecord.url === "string" ? targetRecord.url : undefined;
+        const query = typeof targetRecord.query === "string" ? targetRecord.query : undefined;
+        if (url)
+            return url;
+        if (query)
+            return query;
+    }
+    const command = typeof toolCall.arguments.command === "string" ? toolCall.arguments.command : undefined;
+    const query = typeof toolCall.arguments.query === "string" ? toolCall.arguments.query : undefined;
+    const url = typeof toolCall.arguments.url === "string" ? toolCall.arguments.url : undefined;
+    return command ?? query ?? url ?? previewUnknown(toolCall.arguments, 180);
+}
+function familyForToolId(toolId) {
+    const [prefix] = toolId.split(".");
+    switch (prefix) {
+        case "search":
+            return { familyKey: "websearch", familyTitle: "WebSearch" };
+        case "shell":
+            return { familyKey: "shell", familyTitle: "Shell" };
+        case "git":
+            return { familyKey: "git", familyTitle: "Git" };
+        case "code":
+            return { familyKey: "code", familyTitle: "Code" };
+        case "computeruse":
+            return { familyKey: "browser", familyTitle: "Computer Use" };
+        case "mcp":
+            return { familyKey: "mcp", familyTitle: "MCP" };
+        case "skill":
+            return { familyKey: "skill", familyTitle: "Skill" };
+        case "omni":
+            return { familyKey: "docs", familyTitle: "Omni" };
+        default:
+            return { familyKey: prefix || "capability", familyTitle: prefix ? `${prefix.slice(0, 1).toUpperCase()}${prefix.slice(1)}` : "Capability" };
+    }
+}
+function summarizeToolOutputForHumans(toolCall) {
+    if (!toolCall.ok) {
+        const errorRecord = objectValue(toolCall.error);
+        const message = stringValue(errorRecord?.message) ?? stringValue(toolCall.error);
+        const code = stringValue(errorRecord?.code);
+        return [
+            message ? `失败：${message}` : `失败：${toolCall.toolId} did not complete.`,
+            ...(code ? [`原因码：${code}`] : []),
+        ].slice(0, 3);
+    }
+    const output = objectValue(toolCall.output);
+    const codeSummary = summarizeCodeToolOutputForHumans(toolCall, output);
+    if (codeSummary !== undefined)
+        return codeSummary;
+    const shellSummary = summarizeShellToolOutputForHumans(toolCall, output);
+    if (shellSummary !== undefined)
+        return shellSummary;
+    const gitSummary = summarizeGitToolOutputForHumans(toolCall, output);
+    if (gitSummary !== undefined)
+        return gitSummary;
+    const computerUseSummary = summarizeComputerUseToolOutputForHumans(toolCall, output);
+    if (computerUseSummary !== undefined)
+        return computerUseSummary;
+    const mcpSummary = summarizeMcpToolOutputForHumans(toolCall, output);
+    if (mcpSummary !== undefined)
+        return mcpSummary;
+    const skillSummary = summarizeSkillToolOutputForHumans(toolCall, output);
+    if (skillSummary !== undefined)
+        return skillSummary;
+    const omniSummary = summarizeOmniToolOutputForHumans(toolCall, output);
+    if (omniSummary !== undefined)
+        return omniSummary;
+    const envelope = objectValue(output?.resultEnvelope);
+    const query = stringValue(envelope?.query);
+    const answer = stringValue(envelope?.answer);
+    const results = Array.isArray(envelope?.results) ? envelope.results : [];
+    const sources = Array.isArray(envelope?.sources) ? envelope.sources : [];
+    const citations = Array.isArray(envelope?.citations) ? envelope.citations : [];
+    const pageTitle = stringValue(output?.pageTitle);
+    const finalUrl = stringValue(output?.finalUrl);
+    const status = numberValue(output?.status);
+    if (toolCall.toolId === "search.searchEngine") {
+        const firstTitles = results
+            .map((item) => objectValue(item))
+            .flatMap((item) => stringValue(item?.title) ?? [])
+            .slice(0, 2);
+        return [
+            query ? `搜索：${query}` : undefined,
+            `结果：找到 ${results.length} 条网页结果`,
+            ...firstTitles.map((title) => `来源：${title}`),
+        ].filter((line) => line !== undefined).slice(0, 4);
+    }
+    if (toolCall.toolId === "search.nativeSearch") {
+        const sourceTitles = [...sources, ...citations]
+            .map((item) => objectValue(item))
+            .flatMap((item) => stringValue(item?.title) ?? [])
+            .slice(0, 2);
+        const hasRealSources = sources.length + citations.length > 0;
+        return [
+            query ? `搜索：${query}` : undefined,
+            answer && hasRealSources ? `摘要：${answer}` : undefined,
+            hasRealSources ? `来源：${sources.length + citations.length} 条` : "未返回可引用来源",
+            ...sourceTitles.map((title) => `来源：${title}`),
+        ].filter((line) => line !== undefined).slice(0, 4);
+    }
+    if (toolCall.toolId === "search.fetch") {
+        return [
+            finalUrl ? `页面：${finalUrl}` : undefined,
+            pageTitle ? `标题：${pageTitle}` : undefined,
+            status !== undefined ? `HTTP：${status}` : undefined,
+        ].filter((line) => line !== undefined).slice(0, 3);
+    }
+    const directSummary = stringValue(output?.summary)
+        ?? stringValue(output?.answer)
+        ?? stringValue(output?.text)
+        ?? stringValue(toolCall.output);
+    return directSummary ? [directSummary] : [`${toolCall.toolId} completed`];
+}
+function createToolResultMetadata(toolCall) {
+    const output = objectValue(toolCall.output);
+    const args = flattenedToolArguments(toolCall.arguments);
+    const target = objectValue(args.target);
+    const outputTarget = objectValue(output?.target);
+    const envelope = objectValue(output?.resultEnvelope) ?? output;
+    const providerMetadata = objectValue(output?.providerMetadata);
+    const targetPaths = [
+        ...stringArrayValue(args.targetPaths),
+        ...stringArrayValue(args.paths),
+        ...stringArrayValue(target?.paths),
+        ...[firstStringValue(args.targetPath, args.path, args.filePath, target?.path, output?.targetPath, outputTarget?.path, output?.outputPath, output?.imagePath)]
+            .filter((item) => item !== undefined),
+    ].filter((item, index, array) => array.indexOf(item) === index);
+    const toolName = firstStringValue(target?.toolName, target?.name, output?.toolName);
+    const resourceUri = firstStringValue(target?.resourceUri, target?.uri, objectValue(output?.resourceEnvelope)?.uri);
+    const actionCount = unknownArrayValue(output?.actions ?? outputTarget?.actions).length;
+    const itemCount = countFromArrays(output?.items, output?.results, output?.content, objectValue(output?.resourceEnvelope)?.contents)
+        ?? (actionCount > 0 ? actionCount : undefined);
+    const resultCount = countFromArrays(output?.hits, output?.matches, output?.results);
+    const changedFileCount = countFromArrays(envelope?.entries, envelope?.changedFiles, output?.changedFiles, output?.committedFiles);
+    const changeLineStats = codeChangeLineStats(toolCall);
+    return cleanRecord({
+        targetPaths,
+        pathCount: targetPaths.length > 0 ? targetPaths.length : undefined,
+        targetName: firstStringValue(target?.serverId, target?.connectionId, output?.serverId, output?.connectionId, outputTarget?.targetHint, providerMetadata?.backend),
+        toolName,
+        resourceUri,
+        skillName: firstStringValue(args.skillName, target?.skillName, output?.skillName, output?.name, objectValue(output?.container)?.name),
+        branchName: firstStringValue(envelope?.branch, output?.branch, target?.branchName, target?.branch),
+        commitHash: firstStringValue(envelope?.commitHash, output?.commitHash, output?.newHead),
+        aheadCount: numberValue(envelope?.ahead) ?? numberValue(output?.aheadCount),
+        behindCount: numberValue(envelope?.behind) ?? numberValue(output?.behindCount),
+        changedFileCount,
+        itemCount,
+        resultCount,
+        matchCount: countFromArrays(output?.matches, envelope?.matches),
+        outputCount: countFromArrays(output?.documents, objectValue(output?.preparedInvocation)?.resources),
+        mountCount: countFromArrays(objectValue(output?.activation)?.mounts),
+        imageCount: toolCall.toolId.includes("Image") || toolCall.toolId.includes("Screenshot") || firstStringValue(output?.imagePath, output?.artifactId) ? 1 : undefined,
+        mimeType: firstStringValue(output?.mimeType, objectValue(output?.artifact)?.mimeType),
+        codeAdditions: changeLineStats?.codeAdditions,
+        codeDeletions: changeLineStats?.codeDeletions,
+        errorCode: stringValue(objectValue(toolCall.error)?.code),
+    });
+}
+function toolCallRecordFromProgress(progress) {
+    if (progress.phase === "started") {
+        return {
+            callId: progress.callId,
+            toolId: progress.toolId,
+            arguments: progress.arguments,
+            ok: true,
+        };
+    }
+    return progress.record;
+}
+function createToolProgressEvent(input) {
+    const toolCall = toolCallRecordFromProgress(input.progress);
+    const family = familyForToolId(toolCall.toolId);
+    const inputSummary = summarizeToolInput(toolCall);
+    const argumentsPreview = previewUnknown(toolCall.arguments, 2_000);
+    const outputPreview = input.progress.phase === "started" ? undefined : previewUnknown(toolCall.output);
+    const errorPreview = input.progress.phase === "started" ? undefined : previewUnknown(toolCall.error);
+    const humanResultSummary = input.progress.phase === "started" ? [] : summarizeToolOutputForHumans(toolCall);
+    const resultMetadata = input.progress.phase === "started" ? undefined : createToolResultMetadata(toolCall);
+    const toolStatus = input.progress.phase === "started"
+        ? "running"
+        : input.progress.phase;
+    return {
+        eventId: `${input.turnId}.tool.${toolCall.callId}.${toolStatus}`,
+        kind: "tool",
+        status: input.status,
+        message: `${toolCall.toolId} ${toolStatus}`,
+        turnId: input.turnId,
+        metadata: {
+            toolCallId: toolCall.callId,
+            toolId: toolCall.toolId,
+            toolStatus,
+            inputSummary,
+            argumentsPreview,
+            outputPreview,
+            errorPreview,
+            humanResultSummary,
+            resultMetadata,
+            familyKey: family.familyKey,
+            familyTitle: family.familyTitle,
+            providerToolName: input.progress.providerToolName,
+        },
+    };
+}
+function toolProgressKey(progress) {
+    const callId = progress.phase === "started" ? progress.callId : progress.record.callId;
+    return `${callId}:${progress.phase}`;
+}
+function createModelProgressEvent(input) {
+    const usage = input.progress.phase === "started" ? undefined : input.progress.usage;
+    const contextInputTokens = usage?.inputTokens;
+    const contextTotalTokens = usage === undefined ? undefined : usageContextTotalTokens(usage);
+    return {
+        eventId: `${input.turnId}.model.${input.progress.invocationId}.${input.progress.phase}`,
+        kind: "model",
+        status: input.status,
+        message: input.progress.phase === "started"
+            ? `model request started: ${input.progress.model ?? input.progress.carrierId}`
+            : input.progress.phase === "completed"
+                ? `model request completed: ${input.progress.model ?? input.progress.carrierId}`
+                : `model request failed: ${input.progress.model ?? input.progress.carrierId}`,
+        turnId: input.turnId,
+        metadata: {
+            modelPhase: input.progress.phase,
+            invocationId: input.progress.invocationId,
+            turnIndex: input.progress.turnIndex,
+            provider: input.progress.provider,
+            carrierId: input.progress.carrierId,
+            model: input.progress.model,
+            usage,
+            providerRouting: input.progress.phase === "started" ? undefined : input.progress.providerRouting,
+            cacheDebug: input.progress.phase === "started" ? undefined : input.progress.cacheDebug,
+            providerResponseId: input.progress.phase === "started" ? undefined : input.progress.providerResponseId,
+            previousProviderResponseId: input.progress.phase === "started" ? undefined : input.progress.previousProviderResponseId,
+            context: contextInputTokens === undefined
+                ? undefined
+                : {
+                    provider: input.progress.provider,
+                    model: input.progress.model,
+                    promptKind: "applicationLayer",
+                    windowTokens: input.model.contextWindowTokens,
+                    maxInputTokens: input.model.maxInputTokens,
+                    inputBudgetThreshold: input.model.inputBudgetThreshold,
+                    usableInputTokens: input.model.usableInputTokens,
+                    windowSource: input.model.metadataSource,
+                    contextSource: "provider.model-call.usage",
+                    usageSource: usage?.source ?? "provider.model-call.usage",
+                    activeTokens: contextInputTokens,
+                    promptTokens: contextInputTokens,
+                    lastRequestInputTokens: contextInputTokens,
+                    lastRequestTotalTokens: contextTotalTokens,
+                    transcriptTokens: 0,
+                    summaryTokens: 0,
+                    historyMessages: 0,
+                    estimated: usage?.estimated ?? false,
+                    compacted: false,
+                },
+            errorMessage: input.progress.phase === "failed" ? input.progress.error?.message : undefined,
+        },
+    };
+}
+function compareApplicationModelCacheDebug(cacheDebug, previous) {
+    if (previous === undefined || cacheDebug.comparisonToPrevious !== undefined)
+        return cacheDebug;
+    const currentFingerprints = cacheDebug.providerBody.fingerprints;
+    const previousFingerprints = previous.providerBody.fingerprints;
+    const fingerprintKeys = [...new Set([
+            ...Object.keys(previousFingerprints),
+            ...Object.keys(currentFingerprints),
+        ])].sort();
+    const changedFingerprintKeys = fingerprintKeys.filter((key) => previousFingerprints[key] !== currentFingerprints[key]);
+    const stablePrefixChanged = previous.providerBody.cacheShape.stablePrefixHash !== cacheDebug.providerBody.cacheShape.stablePrefixHash;
+    const dynamicPayloadChanged = previous.providerBody.cacheShape.dynamicPayloadHash !== cacheDebug.providerBody.cacheShape.dynamicPayloadHash;
+    const instructionsChanged = previousFingerprints.instructionsHash !== currentFingerprints.instructionsHash;
+    const toolsChanged = previousFingerprints.toolsHash !== currentFingerprints.toolsHash;
+    const observedUsage = cacheDebug.observedUsage;
+    const stablePrefixMissWithStableBody = observedUsage?.diagnosis === "stable-prefix-cache-break"
+        && observedUsage.cachedInputTokens === 0
+        && !stablePrefixChanged
+        && !instructionsChanged
+        && !toolsChanged;
+    return {
+        ...cacheDebug,
+        observedUsage: stablePrefixMissWithStableBody
+            ? {
+                ...observedUsage,
+                diagnosis: "provider-cache-miss-with-stable-prefix",
+                reasons: [
+                    ...observedUsage.reasons,
+                    "stable prefix and provider tool fingerprints match the previous application model call; this looks like provider cache routing/reuse miss, not PromptPack prefix drift",
+                ],
+            }
+            : observedUsage,
+        comparisonToPrevious: {
+            previousStablePrefixHash: previous.providerBody.cacheShape.stablePrefixHash,
+            previousDynamicPayloadHash: previous.providerBody.cacheShape.dynamicPayloadHash,
+            stablePrefixChanged,
+            dynamicPayloadChanged,
+            instructionsChanged,
+            toolsChanged,
+            changedFingerprintKeys,
+        },
+    };
+}
+function progressWithSessionCacheComparison(state, progress) {
+    if (progress.phase === "started" || progress.cacheDebug === undefined)
+        return progress;
+    const compared = compareApplicationModelCacheDebug(progress.cacheDebug, state.modelCacheDebugBySession.get(state.sessionId));
+    state.modelCacheDebugBySession.set(state.sessionId, compared);
+    return { ...progress, cacheDebug: compared };
+}
+function rememberProviderResponseForSession(state, progress) {
+    if (progress.phase === "started" ||
+        progress.providerResponseId === undefined ||
+        progress.cacheDebug === undefined) {
+        return;
+    }
+    state.lastProviderResponseBySession.set(state.sessionId, {
+        responseId: progress.providerResponseId,
+        stablePrefixHash: progress.cacheDebug.providerBody.cacheShape.stablePrefixHash,
+    });
+}
+function readResponseText(raw) {
+    if (typeof raw === "string") {
+        const objects = readProviderSseObjects(raw);
+        const completedParts = objects.flatMap((object) => {
+            if (object.type === "response.output_text.done") {
+                const text = stringValue(object.text);
+                return text ? [text] : [];
+            }
+            if (object.type === "response.output_item.done") {
+                const itemText = readResponseText(object.item);
+                return itemText ? [itemText] : [];
+            }
+            return [];
+        });
+        if (completedParts.length > 0) {
+            return completedParts.join("\n").trim() || undefined;
+        }
+        const deltaParts = objects
+            .map((object) => stringValue(object.delta))
+            .filter((delta) => delta !== undefined);
+        return deltaParts.join("").trim() || undefined;
+    }
+    const record = objectValue(raw);
+    const outputText = stringValue(record?.output_text);
+    if (outputText)
+        return outputText;
+    const output = Array.isArray(record?.output) ? record.output : [];
+    const parts = [];
+    for (const item of output) {
+        const itemRecord = objectValue(item);
+        const content = Array.isArray(itemRecord?.content) ? itemRecord.content : [];
+        for (const block of content) {
+            const blockRecord = objectValue(block);
+            const text = stringValue(blockRecord?.text);
+            if (text)
+                parts.push(text);
+        }
+    }
+    return parts.join("\n").trim() || undefined;
+}
+function readProviderSseObjects(raw) {
+    return raw
+        .replace(/\r\n/gu, "\n")
+        .split("\n\n")
+        .flatMap((frame) => {
+        const payload = frame
+            .split("\n")
+            .filter((line) => line.startsWith("data:"))
+            .map((line) => line.slice("data:".length).trim())
+            .join("\n");
+        if (!payload || payload === "[DONE]")
+            return [];
+        try {
+            const parsed = JSON.parse(payload);
+            const record = objectValue(parsed);
+            return record ? [record] : [];
+        }
+        catch {
+            return [];
+        }
+    });
+}
+function collectResponseSourcesFromContent(content) {
+    if (!Array.isArray(content))
+        return [];
+    const sources = [];
+    for (const block of content) {
+        const blockRecord = objectValue(block);
+        const annotations = Array.isArray(blockRecord?.annotations) ? blockRecord.annotations : [];
+        for (const annotation of annotations) {
+            const annotationRecord = objectValue(annotation);
+            const url = stringValue(annotationRecord?.url);
+            if (!url)
+                continue;
+            sources.push({
+                url,
+                ...(stringValue(annotationRecord?.title) ? { title: stringValue(annotationRecord?.title) } : {}),
+                ...(stringValue(annotationRecord?.snippet) ? { snippet: stringValue(annotationRecord?.snippet) } : {}),
+                kind: "citation",
+                raw: annotationRecord,
+            });
+        }
+    }
+    return sources;
+}
+function readResponseSources(raw) {
+    const dedupeSources = (sources) => {
+        const seen = new Set();
+        const deduped = [];
+        for (const source of sources) {
+            const key = `${source.kind ?? ""}:${source.url}:${source.title ?? ""}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            deduped.push(source);
+        }
+        return deduped;
+    };
+    if (typeof raw === "string") {
+        const sources = [];
+        for (const object of readProviderSseObjects(raw)) {
+            if (object.type !== "response.output_item.done")
+                continue;
+            const item = objectValue(object.item);
+            if (item?.type === "message") {
+                sources.push(...collectResponseSourcesFromContent(item.content));
+            }
+            if (item?.type === "web_search_call") {
+                const action = objectValue(item.action);
+                const query = stringValue(action?.query);
+                const actionSources = Array.isArray(action?.sources) ? action.sources : [];
+                for (const actionSource of actionSources) {
+                    const sourceRecord = objectValue(actionSource);
+                    const type = stringValue(sourceRecord?.type);
+                    const name = stringValue(sourceRecord?.name);
+                    const url = stringValue(sourceRecord?.url);
+                    const title = stringValue(sourceRecord?.title) ?? name ?? type;
+                    if (url) {
+                        sources.push({
+                            url,
+                            ...(title ? { title } : {}),
+                            kind: "provider_native",
+                            raw: sourceRecord,
+                        });
+                    }
+                    else if (name || type) {
+                        sources.push({
+                            url: `provider-native:${encodeURIComponent(name ?? type ?? "web_search")}`,
+                            title: title ? `Provider source: ${title}` : "Provider web search source",
+                            kind: "provider_native",
+                            raw: sourceRecord,
+                        });
+                    }
+                }
+                if (query) {
+                    sources.push({
+                        url: `provider-native:web_search:${encodeURIComponent(query)}`,
+                        title: `Provider web search: ${query}`,
+                        kind: "provider_native",
+                        raw: action,
+                    });
+                }
+            }
+        }
+        return dedupeSources(sources);
+    }
+    const record = objectValue(raw);
+    const output = Array.isArray(record?.output) ? record.output : [];
+    const sources = [];
+    for (const item of output) {
+        const itemRecord = objectValue(item);
+        sources.push(...collectResponseSourcesFromContent(itemRecord?.content));
+    }
+    return dedupeSources(sources);
+}
+function openAIResponsesCallerFor(liveProvider) {
+    if (liveProvider === undefined)
+        return undefined;
+    const provider = liveProvider.provider?.trim();
+    const endpointShape = liveProvider.endpointShape?.trim();
+    if (provider !== undefined && provider !== "openai")
+        return undefined;
+    if (endpointShape !== undefined && endpointShape !== "responses")
+        return undefined;
+    return liveProvider.openaiResponsesCaller ?? liveProvider.providerCaller;
+}
+function createProviderNativeSearchAdapter(input) {
+    return async (request) => {
+        if (request.provider !== "openai") {
+            return {
+                ok: false,
+                error: {
+                    code: "PROVIDER_UNAVAILABLE",
+                    message: `provider-native search adapter is not available for ${request.provider}`,
+                    publicSafe: true,
+                },
+            };
+        }
+        const result = await invokeChatGPTCodexResponses({
+            operation: "create",
+            method: "POST",
+            auth: input.auth,
+            caller: input.providerCaller,
+            runtime: {
+                runtimeId: input.runtimeId,
+                invocationId: `native-web-search:${Date.now()}`,
+                callerId: "raxode.application.nativeWebSearch",
+            },
+            requiredScopes: ["model.invoke", "chatgpt.codex.responses"],
+            governance: { accepted: true },
+            contract: { accepted: true },
+            dryRun: false,
+            headers: { "content-type": "application/json" },
+            expectResponseObject: false,
+            body: {
+                model: request.model ?? "gpt-5.5",
+                input: request.query,
+                tools: [{ type: "web_search" }],
+                tool_choice: "auto",
+                include: ["web_search_call.action.sources"],
+                store: false,
+            },
+        });
+        if (!result.ok) {
+            return {
+                ok: false,
+                error: {
+                    code: result.error.code,
+                    message: result.error.message,
+                    publicSafe: true,
+                },
+                events: result.events,
+            };
+        }
+        const raw = result.response.raw;
+        const answer = readResponseText(raw);
+        const sources = readResponseSources(raw);
+        const publicSources = sources.map((source) => ({
+            url: source.url,
+            ...(source.title ? { title: source.title } : {}),
+            ...(source.snippet ? { snippet: source.snippet } : {}),
+            ...(source.kind ? { kind: source.kind } : {}),
+        }));
+        return {
+            ok: true,
+            output: {
+                ...(answer ? { answer } : {}),
+                sources: publicSources,
+                citations: publicSources.map((source) => ({
+                    url: source.url,
+                    ...(source.title ? { title: source.title } : {}),
+                    ...(source.snippet ? { snippet: source.snippet } : {}),
+                })),
+                providerMetadata: {
+                    provider: request.provider,
+                    backend: "openai-web-search",
+                    sourceCount: sources.length,
+                },
+            },
+            events: ["raxode.application.nativeWebSearch.openai.called"],
+        };
+    };
+}
+function imageMimeTypeFromPath(imagePath, declared) {
+    if (declared !== undefined && declared !== "unknown")
+        return declared;
+    const extension = path.extname(imagePath).toLowerCase();
+    if (extension === ".jpg" || extension === ".jpeg")
+        return "image/jpeg";
+    if (extension === ".webp")
+        return "image/webp";
+    if (extension === ".gif")
+        return "image/gif";
+    return "image/png";
+}
+function responsesImageDetail(detail) {
+    return detail === "low" ? "low" : "high";
+}
+function responsesImageGenerationSize(value) {
+    if (value === undefined || value === "auto")
+        return value;
+    if (value === "1024x1024" || value === "1024x1536" || value === "1536x1024")
+        return value;
+    return undefined;
+}
+function responsesImageGenerationQuality(value) {
+    if (value === undefined)
+        return undefined;
+    return ["auto", "low", "medium", "high"].includes(value) ? value : undefined;
+}
+function responsesImageGenerationFormat(value) {
+    if (value === undefined)
+        return undefined;
+    if (value === "image/png" || value === "png")
+        return "png";
+    if (value === "image/jpeg" || value === "jpeg" || value === "jpg")
+        return "jpeg";
+    if (value === "image/webp" || value === "webp")
+        return "webp";
+    return undefined;
+}
+function imageMimeTypeFromFormat(format, outputPath) {
+    if (format === "jpeg")
+        return "image/jpeg";
+    if (format === "webp")
+        return "image/webp";
+    return imageMimeTypeFromPath(outputPath, "image/png");
+}
+function readImageGenerationCallRecord(record) {
+    if (record.type === "image_generation_call") {
+        const imageBase64 = stringValue(record.result);
+        if (imageBase64) {
+            return {
+                imageBase64,
+                revisedPrompt: stringValue(record.revised_prompt),
+                imageCallId: stringValue(record.id),
+            };
+        }
+    }
+    const item = objectValue(record.item);
+    if (item) {
+        const generated = readImageGenerationCallRecord(item);
+        if (generated)
+            return generated;
+    }
+    const response = objectValue(record.response);
+    if (response) {
+        const generated = readImageGenerationCallRecord(response);
+        if (generated)
+            return generated;
+    }
+    const output = Array.isArray(record?.output) ? record.output : [];
+    for (const outputItem of output) {
+        const itemRecord = objectValue(outputItem);
+        if (!itemRecord)
+            continue;
+        const generated = readImageGenerationCallRecord(itemRecord);
+        if (generated)
+            return generated;
+    }
+    return undefined;
+}
+function readImageGenerationCall(raw) {
+    if (typeof raw === "string") {
+        for (const object of readProviderSseObjects(raw)) {
+            const generated = readImageGenerationCallRecord(object);
+            if (generated)
+                return generated;
+        }
+        return undefined;
+    }
+    const record = objectValue(raw);
+    return record ? readImageGenerationCallRecord(record) : undefined;
+}
+function normalizeAttachmentRef(value) {
+    return value.trim().replace(/^\[|\]$/gu, "").replace(/\s+/gu, " ").toLowerCase();
+}
+function attachmentRefCandidates(attachment) {
+    return [
+        attachment.id,
+        attachment.tokenText,
+        attachment.tokenText?.replace(/^\[|\]$/gu, ""),
+        attachment.displayName,
+        attachment.localPath,
+        attachment.remoteUrl,
+    ]
+        .filter((value) => value !== undefined && value.trim().length > 0)
+        .map(normalizeAttachmentRef);
+}
+function resolveImageAttachment(input) {
+    if (!input.imageRef || !input.attachments || input.attachments.length === 0)
+        return undefined;
+    const normalizedRef = normalizeAttachmentRef(input.imageRef);
+    return input.attachments.find((attachment) => {
+        if (attachment.kind !== "image")
+            return false;
+        return attachmentRefCandidates(attachment).includes(normalizedRef);
+    });
+}
+function createOpenAIResponsesImageVisionAdapter(input) {
+    return async (request) => {
+        const parameters = request.parameters ?? {};
+        if (request.operation === "omni.generateImage.generateimage") {
+            const prompt = stringValue(parameters.prompt);
+            const outputPath = stringValue(parameters.outputPath);
+            if (prompt === undefined || outputPath === undefined) {
+                return {
+                    ok: false,
+                    error: {
+                        code: "PROVIDER_REJECTED",
+                        message: "omni.generateImage requires target.prompt and target.outputPath for Responses image_generation",
+                        publicSafe: true,
+                    },
+                };
+            }
+            const outputFormat = responsesImageGenerationFormat(stringValue(parameters.outputFormat)
+                ?? stringValue(parameters.targetFormat)
+                ?? stringValue(parameters.format)
+                ?? stringValue(parameters.mimeType));
+            const imageTool = {
+                type: "image_generation",
+            };
+            const size = responsesImageGenerationSize(stringValue(parameters.size));
+            if (size !== undefined)
+                imageTool.size = size;
+            const quality = responsesImageGenerationQuality(stringValue(parameters.quality));
+            if (quality !== undefined)
+                imageTool.quality = quality;
+            if (outputFormat !== undefined)
+                imageTool.output_format = outputFormat;
+            const result = await invokeChatGPTCodexResponses({
+                operation: "create",
+                method: "POST",
+                auth: input.auth,
+                caller: input.providerCaller,
+                runtime: {
+                    runtimeId: input.runtimeId,
+                    invocationId: `omni-generate-image:${Date.now()}`,
+                    callerId: "raxode.application.omniGenerateImage",
+                },
+                requiredScopes: ["model.invoke", "chatgpt.codex.responses", "omni.image.generate"],
+                governance: { accepted: true },
+                contract: { accepted: true },
+                dryRun: false,
+                headers: { "content-type": "application/json" },
+                expectResponseObject: false,
+                body: {
+                    model: input.model,
+                    input: prompt,
+                    tools: [imageTool],
+                    tool_choice: { type: "image_generation" },
+                    store: false,
+                    stream: true,
+                },
+            });
+            if (!result.ok) {
+                return {
+                    ok: false,
+                    error: {
+                        code: result.error.code,
+                        message: result.error.message,
+                        publicSafe: true,
+                    },
+                    events: result.events,
+                };
+            }
+            const generated = readImageGenerationCall(result.response.raw);
+            if (generated === undefined) {
+                return {
+                    ok: false,
+                    error: {
+                        code: "RESPONSE_FORMAT_DRIFT",
+                        message: "omni.generateImage Responses image_generation did not return an image_generation_call result",
+                        publicSafe: true,
+                    },
+                    events: result.events,
+                };
+            }
+            const imageBytes = Buffer.from(generated.imageBase64, "base64");
+            await mkdir(path.dirname(outputPath), { recursive: true });
+            await writeFile(outputPath, imageBytes);
+            const mimeType = imageMimeTypeFromFormat(outputFormat, outputPath);
+            return {
+                ok: true,
+                output: {
+                    artifactId: outputPath,
+                    mimeType,
+                },
+                metadata: {
+                    provider: "openai",
+                    backend: "chatgpt-codex-responses-image-generation",
+                    model: input.model,
+                    outputPath,
+                    mimeType,
+                    byteLength: imageBytes.byteLength,
+                    ...(generated.revisedPrompt ? { revisedPrompt: generated.revisedPrompt } : {}),
+                    ...(generated.imageCallId ? { imageCallId: generated.imageCallId } : {}),
+                },
+                events: ["raxode.application.omniGenerateImage.openai.called"],
+            };
+        }
+        const imageRef = stringValue(parameters.imageRef) ?? request.inputArtifactId;
+        const attachment = resolveImageAttachment({
+            imageRef,
+            attachments: input.attachments,
+        });
+        const imagePath = stringValue(parameters.imagePath) ?? attachment?.localPath;
+        if (imagePath === undefined) {
+            return {
+                ok: false,
+                error: {
+                    code: "PROVIDER_UNAVAILABLE",
+                    message: imageRef
+                        ? `omni.viewImage OpenAI vision adapter could not resolve imageRef to a local imagePath: ${imageRef}`
+                        : "omni.viewImage OpenAI vision adapter requires a local imagePath or an application image attachment reference",
+                    publicSafe: true,
+                },
+            };
+        }
+        const maxBytes = numberValue(parameters.maxBytes) ?? 20 * 1024 * 1024;
+        let bytes;
+        try {
+            bytes = await readFile(imagePath);
+        }
+        catch {
+            return {
+                ok: false,
+                error: {
+                    code: "PROVIDER_UNAVAILABLE",
+                    message: `omni.viewImage OpenAI vision adapter could not read imagePath: ${imagePath}`,
+                    publicSafe: true,
+                },
+            };
+        }
+        if (bytes.byteLength > maxBytes) {
+            return {
+                ok: false,
+                error: {
+                    code: "PROVIDER_REJECTED",
+                    message: `omni.viewImage image exceeds maxBytes (${bytes.byteLength} > ${maxBytes})`,
+                    publicSafe: true,
+                },
+            };
+        }
+        const mimeType = imageMimeTypeFromPath(imagePath, stringValue(parameters.mediaType) ?? attachment?.mimeType);
+        const detail = responsesImageDetail(stringValue(parameters.detail));
+        const result = await invokeChatGPTCodexResponses({
+            operation: "create",
+            method: "POST",
+            auth: input.auth,
+            caller: input.providerCaller,
+            runtime: {
+                runtimeId: input.runtimeId,
+                invocationId: `omni-view-image:${Date.now()}`,
+                callerId: "raxode.application.omniViewImage",
+            },
+            requiredScopes: ["model.invoke", "chatgpt.codex.responses"],
+            governance: { accepted: true },
+            contract: { accepted: true },
+            dryRun: false,
+            headers: { "content-type": "application/json" },
+            expectResponseObject: false,
+            body: {
+                model: input.model,
+                input: [{
+                        role: "user",
+                        content: [
+                            {
+                                type: "input_text",
+                                text: [
+                                    "Analyze this image for a Praxis desktop/browser automation agent.",
+                                    "Return concise visible UI facts, actionable controls, and approximate screen-relative targets only when evident.",
+                                    "Do not invent unseen buttons or coordinates.",
+                                ].join(" "),
+                            },
+                            {
+                                type: "input_image",
+                                image_url: `data:${mimeType};base64,${bytes.toString("base64")}`,
+                                detail,
+                            },
+                        ],
+                    }],
+                store: false,
+            },
+        });
+        if (!result.ok) {
+            return {
+                ok: false,
+                error: {
+                    code: result.error.code,
+                    message: result.error.message,
+                    publicSafe: true,
+                },
+                events: result.events,
+            };
+        }
+        const analysis = readResponseText(result.response.raw);
+        return {
+            ok: true,
+            output: {
+                artifactId: request.inputArtifactId ?? `artifact:vision:${Date.now()}`,
+                mimeType,
+            },
+            metadata: {
+                provider: "openai",
+                backend: "chatgpt-codex-responses-vision",
+                model: input.model,
+                imagePath,
+                mimeType,
+                detail,
+                ...(analysis ? { analysis } : {}),
+            },
+            events: ["raxode.application.omniViewImage.openai.called"],
+        };
+    };
+}
+async function withTimeout(input) {
+    let timeout;
+    try {
+        return await Promise.race([
+            input.promise,
+            new Promise((_resolve, reject) => {
+                timeout = setTimeout(() => reject(new Error(input.message)), input.timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timeout)
+            clearTimeout(timeout);
+    }
+}
+function shouldAutoApproveForProfile(profile, envelope) {
+    if (profile === "bapr")
+        return true;
+    if (profile !== "yolo" && profile !== "permissive")
+        return false;
+    const riskLevel = (stringValue(envelope.riskLevel) ?? "").toLowerCase();
+    return riskLevel !== "dangerous" && riskLevel !== "high";
+}
+function autoApprovalResolutionForProfile(profile, envelope) {
+    if (!shouldAutoApproveForProfile(profile, envelope))
+        return undefined;
+    return {
+        status: "approved",
+        resolvedBy: `application.profile.${profile}`,
+        reason: `${profile} profile auto-approves this runtime approval request`,
+        metadata: {
+            approvalId: envelope.approvalId,
+            profile,
+            riskLevel: envelope.riskLevel,
+        },
+    };
+}
+function approvalFeatureKey(envelope) {
+    const metadataToolId = stringValue(envelope.metadata.toolId);
+    if (metadataToolId)
+        return metadataToolId;
+    if (envelope.requestedScopes.length > 0)
+        return envelope.requestedScopes.join(",");
+    return envelope.source;
+}
+function approvalFeatureLabel(featureKey) {
+    if (featureKey.startsWith("computeruse."))
+        return "computer_use";
+    if (featureKey.startsWith("omni."))
+        return "omni";
+    if (featureKey.startsWith("shell."))
+        return "shell";
+    if (featureKey.startsWith("git."))
+        return "git";
+    if (featureKey.startsWith("code."))
+        return "code";
+    if (featureKey.startsWith("search."))
+        return "web_search";
+    if (featureKey.startsWith("mcp."))
+        return "mcp";
+    if (featureKey.startsWith("skill."))
+        return "skill";
+    return featureKey;
+}
+async function loadAgentExport(project, input = {}) {
+    const module = await import(pathToFileURL(input.entryPath ?? project.agentEntryPath).href);
+    if (input.exportName ?? project.exportName) {
+        return module[(input.exportName ?? project.exportName)];
+    }
+    return module.default ?? Object.values(module)[0];
+}
+function mergeToolContextUsage(current, toolCalls) {
+    const counts = new Map();
+    for (const record of current ?? []) {
+        const toolId = record.toolId.trim();
+        if (toolId.length === 0)
+            continue;
+        counts.set(toolId, (counts.get(toolId) ?? 0) + Math.max(1, Math.floor(record.count ?? 1)));
+    }
+    for (const call of toolCalls) {
+        const toolId = call.toolId.trim();
+        if (toolId.length === 0)
+            continue;
+        counts.set(toolId, (counts.get(toolId) ?? 0) + 1);
+    }
+    return [...counts.entries()]
+        .sort((left, right) => left[0].localeCompare(right[0]))
+        .map(([toolId, count]) => ({ toolId, count }));
+}
+function rememberToolContextFromRun(state, result) {
+    const sessionId = result.sessionId ?? state.sessionId;
+    state.toolContextSelections.delete(sessionId);
+    if (result.ok && result.toolCalls.length > 0) {
+        state.toolContextUsage.set(sessionId, mergeToolContextUsage(state.toolContextUsage.get(sessionId), result.toolCalls));
+    }
+}
+function applyRunResult(state, result) {
+    state.modelCalls = result.ok ? result.modelCalls.length : 0;
+    state.toolCalls = result.ok ? result.toolCalls.length : 0;
+    state.mainLoopSteps = result.mainLoopSteps?.length ?? 0;
+    state.manifest = result.manifest ?? state.manifest;
+    state.usage = result.ok ? summarizeRunUsage(result) : undefined;
+    if (result.ok) {
+        state.status = "completed";
+        state.finalOutput = result.finalOutput;
+        state.error = undefined;
+    }
+    else {
+        state.status = "failed";
+        state.error = {
+            code: result.error.code,
+            message: result.error.message,
+        };
+        state.finalOutput = undefined;
+    }
+}
+function addOptionalNumber(left, right) {
+    if (left === undefined && right === undefined) {
+        return undefined;
+    }
+    return (left ?? 0) + (right ?? 0);
+}
+function usageContextTotalTokens(usage) {
+    if (typeof usage.totalTokens === "number" && Number.isFinite(usage.totalTokens)) {
+        return usage.totalTokens;
+    }
+    if (typeof usage.inputTokens === "number"
+        && Number.isFinite(usage.inputTokens)
+        && typeof usage.outputTokens === "number"
+        && Number.isFinite(usage.outputTokens)) {
+        return usage.inputTokens + usage.outputTokens;
+    }
+    return undefined;
+}
+function summarizeRunUsage(result) {
+    const usageRecords = result.modelCalls
+        .map((call) => call.usage)
+        .filter((usage) => usage !== undefined);
+    if (usageRecords.length === 0) {
+        return undefined;
+    }
+    const summary = usageRecords.reduce((accumulator, usage) => ({
+        inputTokens: addOptionalNumber(accumulator.inputTokens, usage.inputTokens),
+        outputTokens: addOptionalNumber(accumulator.outputTokens, usage.outputTokens),
+        thinkingTokens: addOptionalNumber(accumulator.thinkingTokens, usage.thinkingTokens),
+        totalTokens: addOptionalNumber(accumulator.totalTokens, usage.totalTokens),
+        cachedInputTokens: addOptionalNumber(accumulator.cachedInputTokens, usage.cachedInputTokens),
+        source: accumulator.source ?? usage.source,
+        estimated: accumulator.estimated || usage.estimated,
+        modelCalls: accumulator.modelCalls + 1,
+    }), {
+        estimated: false,
+        modelCalls: 0,
+    });
+    const lastUsage = [...usageRecords].reverse().find((usage) => typeof usage.inputTokens === "number" && Number.isFinite(usage.inputTokens));
+    if (lastUsage?.inputTokens !== undefined) {
+        summary.lastInputTokens = lastUsage.inputTokens;
+    }
+    const lastTotalUsage = [...usageRecords].reverse().find((usage) => usageContextTotalTokens(usage) !== undefined);
+    const lastTotalTokens = lastTotalUsage === undefined ? undefined : usageContextTotalTokens(lastTotalUsage);
+    if (lastTotalTokens !== undefined) {
+        summary.lastTotalTokens = lastTotalTokens;
+    }
+    return summary.modelCalls > 0 ? summary : undefined;
+}
+export function createPraxisApplicationRuntime(options) {
+    const now = options.now ?? defaultNow;
+    const listeners = new Set();
+    const project = options.project;
+    const applicationId = options.applicationId ?? project.applicationId;
+    const state = {
+        status: "idle",
+        sessionId: options.sessionId ?? `session.${applicationId}.default`,
+        runtimeId: options.runtimeId ?? `runtime.${applicationId}`,
+        cwd: path.resolve(options.cwd ?? project.projectRoot),
+        mode: options.mode ?? "dry-run",
+        model: createApplicationModelState({
+            model: options.model,
+            reasoningEffort: options.reasoningEffort,
+            provider: options.provider,
+            endpointShape: options.endpointShape,
+            baseURL: options.baseURL,
+            providerRoute: options.providerRoute,
+            maxOutputTokens: options.maxOutputTokens,
+        }),
+        permissionProfile: options.permissionProfile ?? "standard",
+        turns: 0,
+        modelCalls: 0,
+        toolCalls: 0,
+        mainLoopSteps: 0,
+        events: [],
+        sessions: new Map(),
+        approvals: new Map(),
+        pendingApprovalResolvers: new Map(),
+        cancelledAuxiliaryTasks: new Set(),
+        conversationHistory: new Map(),
+        conversationSummaries: new Map(),
+        modelCacheDebugBySession: new Map(),
+        lastProviderResponseBySession: new Map(),
+        toolContextSelections: new Map(),
+        toolContextUsage: new Map(),
+        alwaysApprovedApprovalKeys: new Set(),
+    };
+    function publish(input) {
+        const output = event({
+            ...input,
+            createdAt: input.createdAt ?? now(),
+            sessionId: input.sessionId ?? state.sessionId,
+            runtimeId: input.runtimeId ?? state.runtimeId,
+        });
+        state.events.push(output);
+        touchSession();
+        for (const listener of listeners)
+            listener(output);
+        return output;
+    }
+    function applyCommandSession(sessionId) {
+        if (typeof sessionId === "string" && sessionId.trim().length > 0) {
+            state.sessionId = sessionId.trim();
+        }
+        touchSession();
+    }
+    function touchSession() {
+        const current = state.sessions.get(state.sessionId);
+        state.sessions.set(state.sessionId, {
+            sessionId: state.sessionId,
+            name: current?.name ?? state.sessionId.split(".").at(-1),
+            workspaceRoot: state.cwd,
+            status: state.status,
+            lastActiveAt: now(),
+            turns: state.turns,
+        });
+    }
+    function approvalResolverForRun() {
+        return async (envelope) => {
+            const profileResolution = autoApprovalResolutionForProfile(state.permissionProfile, envelope);
+            if (profileResolution)
+                return profileResolution;
+            if (options.approvalResolver)
+                return await options.approvalResolver(envelope);
+            const featureKey = approvalFeatureKey(envelope);
+            if (state.alwaysApprovedApprovalKeys.has(featureKey)) {
+                return {
+                    status: "approved",
+                    resolvedBy: "application.approval.always",
+                    reason: `always approved ${approvalFeatureLabel(featureKey)}`,
+                    metadata: {
+                        approvalId: envelope.approvalId,
+                        featureKey,
+                    },
+                };
+            }
+            const feature = approvalFeatureLabel(featureKey);
+            state.status = "awaiting-approval";
+            state.approvals.set(envelope.approvalId, {
+                approvalId: envelope.approvalId,
+                feature,
+                featureKey,
+                requestedScopes: envelope.requestedScopes,
+                riskLevel: envelope.riskLevel,
+                status: "pending",
+                note: envelope.reason,
+                updatedAt: now(),
+            });
+            publish({
+                eventId: "application.approval.requested",
+                kind: "approval",
+                status: "awaiting-approval",
+                message: `${envelope.approvalId}:${envelope.reason}`,
+                metadata: {
+                    approvalId: envelope.approvalId,
+                    feature,
+                    featureKey,
+                    reason: envelope.reason,
+                    requestedScopes: envelope.requestedScopes,
+                    riskLevel: envelope.riskLevel,
+                },
+            });
+            return await new Promise((resolve) => {
+                state.pendingApprovalResolvers.set(envelope.approvalId, resolve);
+            });
+        };
+    }
+    function view() {
+        const agentId = state.manifest?.identity.id ?? project.descriptor.agent?.id ?? "agent.unknown";
+        const context = estimateConversationContext({
+            messages: state.conversationHistory.get(state.sessionId) ?? [],
+            summary: state.conversationSummaries.get(state.sessionId),
+            usage: state.usage,
+        });
+        const lines = [
+            `application: ${applicationId}`,
+            `project: ${project.projectId}`,
+            `agent: ${agentId}`,
+            `model: ${state.model.model}/${state.model.reasoningEffort}`,
+            state.model.usableInputTokens
+                ? `input budget: ${state.model.usableInputTokens}/${state.model.maxInputTokens} tokens @ ${Math.round((state.model.inputBudgetThreshold ?? 1) * 100)}%`
+                : "input budget: unknown",
+            `permission: ${state.permissionProfile}`,
+            `workspace: ${state.cwd}`,
+            `tools: ${summarizeToolCatalog(state.manifest).mounted}/${summarizeToolCatalog(state.manifest).total}`,
+            state.finalOutput ? `final: ${state.finalOutput}` : `status: ${state.status}`,
+        ];
+        return {
+            applicationId,
+            projectId: project.projectId,
+            runtimeId: state.runtimeId,
+            sessionId: state.sessionId,
+            agentId,
+            agentEntries: summarizeAgentEntries(project),
+            status: state.status,
+            workspaceRoot: state.cwd,
+            mode: state.mode,
+            model: state.model,
+            permissionProfile: state.permissionProfile,
+            sessions: [...state.sessions.values()].sort((left, right) => right.lastActiveAt.localeCompare(left.lastActiveAt)),
+            approvals: [...state.approvals.values()].sort((left, right) => right.updatedAt.localeCompare(left.updatedAt)),
+            manifest: summarizeManifest(state.manifest),
+            tools: summarizeToolCatalog(state.manifest),
+            counters: {
+                turns: state.turns,
+                events: state.events.length,
+                modelCalls: state.modelCalls,
+                toolCalls: state.toolCalls,
+                mainLoopSteps: state.mainLoopSteps,
+            },
+            usage: state.usage,
+            context,
+            finalOutput: state.finalOutput,
+            error: state.error,
+            lines,
+            events: state.events,
+        };
+    }
+    async function compileManifest(agentKey = "primary", options = {}) {
+        try {
+            const entry = project.agentEntries[agentKey];
+            if (!entry) {
+                return { ok: false, code: "AGENT_ENTRY_NOT_FOUND", message: `agent entry was not found for ${agentKey}` };
+            }
+            const loadedSource = await loadAgentExport(project, {
+                entryPath: entry.entryPath,
+                exportName: entry.exportName,
+            });
+            const defaultAgentOptions = {
+                policyProfile: state.permissionProfile,
+                provider: state.model.provider,
+                endpointShape: state.model.endpointShape,
+                baseURL: state.model.baseURL,
+                providerRoute: state.model.providerRoute,
+                model: state.model.model,
+                reasoningEffort: state.model.reasoningEffort,
+                maxOutputTokens: state.model.maxOutputTokens,
+            };
+            const agentOptions = typeof options.agentOptions === "object" && options.agentOptions !== null
+                ? { ...defaultAgentOptions, ...options.agentOptions }
+                : defaultAgentOptions;
+            const source = typeof loadedSource === "function"
+                ? new loadedSource(agentOptions)
+                : loadedSource;
+            const compiled = praxis.compileAgent(source);
+            if (!compiled.ok) {
+                return { ok: false, code: "AGENT_COMPILE_FAILED", message: compiled.error.message };
+            }
+            const validation = praxis.validateAgentManifest(compiled.manifest);
+            if (!validation.ok) {
+                return { ok: false, code: "AGENT_MANIFEST_INVALID", message: validation.error.message };
+            }
+            if (options.updateState ?? agentKey === "primary") {
+                state.manifest = validation.manifest;
+            }
+            return { ok: true, manifest: validation.manifest };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                code: "AGENT_LOAD_FAILED",
+                message: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async function submitAuxiliaryTask(command) {
+        const parentSessionId = state.sessionId;
+        const taskSessionId = command.sessionId?.trim()
+            || `session.${applicationId}.aux.${safeSessionName(command.taskKind)}`;
+        state.sessions.set(taskSessionId, {
+            sessionId: taskSessionId,
+            name: taskSessionId.split(".").at(-1),
+            workspaceRoot: state.cwd,
+            status: "running",
+            lastActiveAt: now(),
+            turns: 0,
+        });
+        const agentKey = command.agentKey ?? "tui";
+        const agentId = command.agentId ?? project.agentEntries[agentKey]?.agentId ?? `agent.${project.projectId}.${agentKey}`;
+        const correlationId = command.correlationId ?? `aux.${Date.now()}.${Math.random().toString(16).slice(2)}`;
+        const timeoutMs = Math.max(1, command.timeoutMs ?? 1800);
+        const started = publish({
+            eventId: `${correlationId}.started`,
+            kind: "model",
+            status: state.status,
+            message: `auxiliary task started: ${command.taskKind}`,
+            sessionId: parentSessionId,
+            metadata: {
+                agentId,
+                agentKey,
+                taskKind: command.taskKind,
+                schemaVersion: command.schemaVersion,
+                correlationId,
+                auxiliarySessionId: taskSessionId,
+                timeoutMs,
+            },
+        });
+        const compiled = await compileManifest(agentKey, {
+            updateState: false,
+            agentOptions: {
+                model: command.model,
+                reasoningEffort: command.reasoningEffort,
+                timeoutMs,
+            },
+        });
+        if (!compiled.ok) {
+            const failed = publish({
+                eventId: `${correlationId}.failed`,
+                kind: "error",
+                status: state.status,
+                message: compiled.message,
+                sessionId: parentSessionId,
+                metadata: {
+                    code: compiled.code,
+                    agentId,
+                    agentKey,
+                    taskKind: command.taskKind,
+                    correlationId,
+                },
+            });
+            return { ok: false, view: view(), events: [started, failed], error: { code: compiled.code, message: compiled.message } };
+        }
+        let liveProvider;
+        if ((command.mode ?? state.mode) === "live") {
+            try {
+                liveProvider = await options.liveProviderResolver?.(compiled.manifest, {
+                    sessionId: taskSessionId,
+                    runtimeId: state.runtimeId,
+                    turnId: correlationId,
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                const failed = publish({
+                    eventId: `${correlationId}.failed`,
+                    kind: "error",
+                    status: state.status,
+                    message,
+                    sessionId: parentSessionId,
+                    metadata: {
+                        code: "AUXILIARY_PROVIDER_RESOLUTION_FAILED",
+                        agentId,
+                        agentKey,
+                        taskKind: command.taskKind,
+                        correlationId,
+                    },
+                });
+                return { ok: false, view: view(), events: [started, failed], error: { code: "AUXILIARY_PROVIDER_RESOLUTION_FAILED", message } };
+            }
+        }
+        const taskText = JSON.stringify({
+            taskKind: command.taskKind,
+            schemaVersion: command.schemaVersion,
+            input: command.input,
+        });
+        try {
+            const runtime = praxis.runtime.createPraxisRuntimeKernel({
+                runtimeId: `${state.runtimeId}.aux.${safeSessionName(command.taskKind)}`,
+            });
+            if (state.cancelledAuxiliaryTasks.has(correlationId)) {
+                throw new Error(`auxiliary task cancelled: ${correlationId}`);
+            }
+            const result = await withTimeout({
+                promise: runtime.runManifest(compiled.manifest, taskText, {
+                    runtimeId: `${state.runtimeId}.aux.${safeSessionName(command.taskKind)}`,
+                    sessionId: taskSessionId,
+                    dryRun: (command.mode ?? state.mode) !== "live",
+                    allowProviderCall: (command.mode ?? state.mode) === "live",
+                    allowToolExecution: false,
+                    auth: liveProvider?.auth,
+                    providerCaller: liveProvider?.providerCaller,
+                    openaiResponsesCaller: liveProvider?.openaiResponsesCaller,
+                    openaiChatCompletionsCaller: liveProvider?.openaiChatCompletionsCaller,
+                    anthropicMessagesCaller: liveProvider?.anthropicMessagesCaller,
+                    exposeProviderTools: false,
+                    approvalResolver: approvalResolverForRun(),
+                    storage: {
+                        cwd: state.cwd,
+                        workspaceRoot: path.join(project.projectRoot, ".raxode"),
+                        initMode: "on-run",
+                    },
+                    sandbox: { cwd: state.cwd },
+                    now,
+                }),
+                timeoutMs,
+                message: `auxiliary task timed out after ${timeoutMs}ms`,
+            });
+            if (!result.ok) {
+                const failed = publish({
+                    eventId: `${correlationId}.failed`,
+                    kind: "error",
+                    status: state.status,
+                    message: result.error.message,
+                    sessionId: parentSessionId,
+                    metadata: {
+                        code: result.error.code,
+                        agentId,
+                        agentKey,
+                        taskKind: command.taskKind,
+                        correlationId,
+                    },
+                });
+                return { ok: false, view: view(), events: [started, failed], error: result.error };
+            }
+            if (state.cancelledAuxiliaryTasks.has(correlationId)) {
+                throw new Error(`auxiliary task cancelled: ${correlationId}`);
+            }
+            const output = parseAuxiliaryTaskOutput(result.finalOutput, command.schemaVersion);
+            const completed = publish({
+                eventId: `${correlationId}.completed`,
+                kind: "model",
+                status: state.status,
+                message: `auxiliary task completed: ${command.taskKind}`,
+                sessionId: parentSessionId,
+                metadata: {
+                    agentId,
+                    agentKey,
+                    taskKind: command.taskKind,
+                    schemaVersion: command.schemaVersion,
+                    correlationId,
+                    auxiliarySessionId: taskSessionId,
+                },
+            });
+            return { ok: true, view: view(), events: [started, completed], output };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const failed = publish({
+                eventId: `${correlationId}.failed`,
+                kind: "error",
+                status: state.status,
+                message,
+                sessionId: parentSessionId,
+                metadata: {
+                    code: "AUXILIARY_TASK_FAILED",
+                    agentId,
+                    agentKey,
+                    taskKind: command.taskKind,
+                    correlationId,
+                },
+            });
+            return { ok: false, view: view(), events: [started, failed], error: { code: "AUXILIARY_TASK_FAILED", message } };
+        }
+    }
+    async function submitTurn(command) {
+        applyCommandSession(command.sessionId);
+        state.status = "running";
+        state.mode = command.mode ?? state.mode;
+        state.cwd = path.resolve(command.input.cwd ?? state.cwd);
+        state.turns += 1;
+        const turnId = `turn.${state.turns}`;
+        const historyBeforeTurn = state.conversationHistory.get(state.sessionId) ?? [];
+        const summaryBeforeTurn = state.conversationSummaries.get(state.sessionId);
+        const preparedHistory = prepareHistoryForTurn({
+            currentUserText: command.input.text,
+            history: historyBeforeTurn,
+            summary: summaryBeforeTurn,
+            attachments: command.input.attachments,
+            model: state.model,
+            previousUsage: state.usage,
+            now: now(),
+        });
+        if (preparedHistory.compacted) {
+            state.conversationHistory.set(state.sessionId, preparedHistory.history);
+            if (preparedHistory.summary !== undefined) {
+                state.conversationSummaries.set(state.sessionId, preparedHistory.summary);
+            }
+            else {
+                state.conversationSummaries.delete(state.sessionId);
+            }
+            publish({
+                eventId: `${turnId}.context.compacted`,
+                kind: "runtime",
+                status: "running",
+                message: "application context compacted before provider call",
+                turnId,
+                metadata: {
+                    phase: "pre-turn",
+                    reason: preparedHistory.reason,
+                    beforeTokens: preparedHistory.beforeTokens,
+                    afterTokens: preparedHistory.afterTokens,
+                    limit: preparedHistory.limit,
+                    keptMessages: preparedHistory.history.length,
+                    compactedMessages: preparedHistory.summary?.compactedMessages ?? 0,
+                },
+            });
+        }
+        const taskText = buildTaskTextWithSessionHistory({
+            currentUserText: command.input.text,
+            history: preparedHistory.history,
+            summary: preparedHistory.summary,
+            attachments: command.input.attachments,
+        });
+        publish({
+            eventId: `${turnId}.submitted`,
+            kind: "conversation",
+            status: "running",
+            message: command.input.text,
+            turnId,
+            metadata: {
+                attachments: command.input.attachments?.length ?? 0,
+                historyMessages: preparedHistory.history.length,
+                contextTokens: preparedHistory.afterTokens,
+                compactedBeforeTurn: preparedHistory.compacted,
+            },
+        });
+        const compiled = await compileManifest();
+        if (!compiled.ok) {
+            state.status = "failed";
+            state.error = { code: compiled.code, message: compiled.message };
+            const failed = publish({
+                eventId: `${turnId}.failed`,
+                kind: "error",
+                status: "failed",
+                message: compiled.message,
+                turnId,
+                metadata: { code: compiled.code },
+            });
+            return { ok: false, view: view(), events: [failed], error: state.error };
+        }
+        publish({
+            eventId: `${turnId}.manifest.ready`,
+            kind: "runtime",
+            status: "running",
+            message: `manifest ready: ${compiled.manifest.identity.id}`,
+            turnId,
+            metadata: {
+                manifestId: compiled.manifest.manifestId,
+                manifestHash: compiled.manifest.manifestHash,
+                mountedTools: compiled.manifest.harness.tools.length,
+            },
+        });
+        let liveProvider;
+        let emitTextDelta;
+        let emitProviderStreamEvent;
+        if (state.mode === "live") {
+            try {
+                let streamSequence = 0;
+                let emittedAssistantText = "";
+                emitTextDelta = (delta, metadata) => {
+                    if (delta.length === 0)
+                        return;
+                    if (metadata?.source === "model_tool_preamble" && emittedAssistantText.includes(delta)) {
+                        return;
+                    }
+                    emittedAssistantText += delta;
+                    streamSequence += 1;
+                    publish({
+                        eventId: `${turnId}.stream.${streamSequence}`,
+                        kind: "stream",
+                        status: "running",
+                        message: delta,
+                        turnId,
+                        metadata: {
+                            ...(metadata ?? {}),
+                            sequence: streamSequence,
+                            channel: "assistant",
+                        },
+                    });
+                };
+                emitProviderStreamEvent = (event) => {
+                    streamSequence += 1;
+                    const message = typeof event.argumentsDelta === "string"
+                        ? event.argumentsDelta
+                        : typeof event.arguments === "string"
+                            ? event.arguments
+                            : typeof event.providerToolName === "string"
+                                ? event.providerToolName
+                                : typeof event.phase === "string"
+                                    ? event.phase
+                                    : "provider stream event";
+                    publish({
+                        eventId: `${turnId}.stream.${streamSequence}`,
+                        kind: "stream",
+                        status: "running",
+                        message,
+                        turnId,
+                        metadata: {
+                            ...event,
+                            sequence: streamSequence,
+                        },
+                    });
+                };
+                liveProvider = await options.liveProviderResolver?.(compiled.manifest, {
+                    sessionId: state.sessionId,
+                    runtimeId: state.runtimeId,
+                    turnId,
+                    onTextDelta: emitTextDelta,
+                    onProviderStreamEvent: emitProviderStreamEvent,
+                });
+            }
+            catch (error) {
+                state.status = "failed";
+                state.error = {
+                    code: "LIVE_PROVIDER_RESOLUTION_FAILED",
+                    message: error instanceof Error ? error.message : String(error),
+                };
+                const failed = publish({
+                    eventId: `${turnId}.failed`,
+                    kind: "error",
+                    status: "failed",
+                    message: state.error.message,
+                    turnId,
+                    metadata: { code: state.error.code },
+                });
+                return { ok: false, view: view(), events: [failed], error: state.error };
+            }
+        }
+        const runtime = praxis.runtime.createPraxisRuntimeKernel({ runtimeId: state.runtimeId });
+        const emittedToolProgress = new Set();
+        const result = await runtime.runManifest(compiled.manifest, taskText, {
+            runtimeId: state.runtimeId,
+            sessionId: state.sessionId,
+            dryRun: state.mode !== "live",
+            allowProviderCall: state.mode === "live",
+            allowToolExecution: state.mode === "live",
+            auth: liveProvider?.auth,
+            providerCaller: liveProvider?.providerCaller,
+            openaiResponsesCaller: liveProvider?.openaiResponsesCaller,
+            openaiChatCompletionsCaller: liveProvider?.openaiChatCompletionsCaller,
+            anthropicMessagesCaller: liveProvider?.anthropicMessagesCaller,
+            previousProviderResponse: state.lastProviderResponseBySession.get(state.sessionId),
+            exposeProviderTools: true,
+            toolContextSelection: state.toolContextSelections.get(state.sessionId),
+            toolContextUsage: state.toolContextUsage.get(state.sessionId),
+            approvalResolver: approvalResolverForRun(),
+            storage: {
+                cwd: state.cwd,
+                workspaceRoot: path.join(project.projectRoot, ".raxode"),
+                initMode: "on-run",
+            },
+            sandbox: { cwd: state.cwd },
+            baseToolAdapters: openAIResponsesCallerFor(liveProvider)
+                ? {
+                    network: {
+                        nativeWebSearch: createProviderNativeSearchAdapter({
+                            auth: liveProvider.auth,
+                            providerCaller: openAIResponsesCallerFor(liveProvider),
+                            runtimeId: state.runtimeId,
+                        }),
+                    },
+                    omni: {
+                        transformMedia: createOpenAIResponsesImageVisionAdapter({
+                            auth: liveProvider.auth,
+                            providerCaller: openAIResponsesCallerFor(liveProvider),
+                            runtimeId: state.runtimeId,
+                            model: state.model.model,
+                            attachments: command.input.attachments,
+                        }),
+                    },
+                }
+                : undefined,
+            onModelCallProgress: (progress) => {
+                const comparedProgress = progressWithSessionCacheComparison(state, progress);
+                rememberProviderResponseForSession(state, comparedProgress);
+                publish(createModelProgressEvent({
+                    progress: comparedProgress,
+                    turnId,
+                    status: "running",
+                    model: state.model,
+                }));
+            },
+            onToolCallProgress: (progress) => {
+                emittedToolProgress.add(toolProgressKey(progress));
+                publish(createToolProgressEvent({
+                    progress,
+                    turnId,
+                    status: "running",
+                }));
+            },
+            onTextDelta: emitTextDelta,
+            now,
+        });
+        applyRunResult(state, result);
+        rememberToolContextFromRun(state, result);
+        const compactedHistory = compactConversationHistory({
+            messages: [
+                ...preparedHistory.history,
+                {
+                    role: "user",
+                    text: command.input.text,
+                    turnId,
+                    createdAt: now(),
+                },
+                {
+                    role: "assistant",
+                    text: result.ok ? result.finalOutput : result.error.message,
+                    turnId,
+                    createdAt: now(),
+                    status: result.ok ? "completed" : "failed",
+                },
+            ],
+            previousSummary: preparedHistory.summary,
+            now: now(),
+        });
+        state.conversationHistory.set(state.sessionId, compactedHistory.messages);
+        if (compactedHistory.summary !== undefined) {
+            state.conversationSummaries.set(state.sessionId, compactedHistory.summary);
+        }
+        else {
+            state.conversationSummaries.delete(state.sessionId);
+        }
+        if (result.ok && result.toolCalls.length > 0) {
+            for (const toolCall of result.toolCalls) {
+                const phase = toolCall.ok ? "completed" : "failed";
+                const progress = { phase, record: toolCall };
+                if (emittedToolProgress.has(toolProgressKey(progress)))
+                    continue;
+                publish(createToolProgressEvent({
+                    progress,
+                    turnId,
+                    status: state.status,
+                }));
+            }
+        }
+        const done = publish({
+            eventId: `${turnId}.${result.ok ? "completed" : "failed"}`,
+            kind: result.ok ? "final" : "error",
+            status: result.ok ? "completed" : "failed",
+            message: result.ok ? result.finalOutput : result.error.message,
+            turnId,
+            metadata: {
+                modelCalls: state.modelCalls,
+                toolCalls: state.toolCalls,
+                mainLoopSteps: state.mainLoopSteps,
+            },
+        });
+        return result.ok
+            ? { ok: true, view: view(), events: [done] }
+            : { ok: false, view: view(), events: [done], error: state.error ?? { code: "RUNTIME_FAILED", message: "runtime failed" } };
+    }
+    return {
+        applicationId,
+        projectId: project.projectId,
+        getView: view,
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+        async dispatch(command) {
+            switch (command.type) {
+                case "application.start": {
+                    applyCommandSession(command.sessionId);
+                    state.cwd = path.resolve(command.cwd ?? state.cwd);
+                    state.mode = command.mode ?? state.mode;
+                    const compiled = await compileManifest();
+                    if (!compiled.ok) {
+                        state.status = "failed";
+                        state.error = { code: compiled.code, message: compiled.message };
+                        const failed = publish({
+                            eventId: "application.start.failed",
+                            kind: "error",
+                            status: "failed",
+                            message: compiled.message,
+                            metadata: { code: compiled.code },
+                        });
+                        return { ok: false, view: view(), events: [failed], error: state.error };
+                    }
+                    state.status = "ready";
+                    const ready = publish({
+                        eventId: "application.ready",
+                        kind: "lifecycle",
+                        status: "ready",
+                        message: "application runtime is ready",
+                        metadata: {
+                            manifestId: compiled.manifest.manifestId,
+                            mountedTools: compiled.manifest.harness.tools.length,
+                        },
+                    });
+                    return { ok: true, view: view(), events: [ready] };
+                }
+                case "application.submitTurn":
+                    return await submitTurn(command);
+                case "application.invokeAuxiliaryTask":
+                    return await submitAuxiliaryTask(command);
+                case "application.cancelAuxiliaryTask": {
+                    applyCommandSession(command.sessionId);
+                    state.cancelledAuxiliaryTasks.add(command.correlationId);
+                    const cancelled = publish({
+                        eventId: `${command.correlationId}.cancelled`,
+                        kind: "runtime",
+                        status: state.status,
+                        message: command.reason ?? `auxiliary task cancelled: ${command.correlationId}`,
+                        metadata: {
+                            correlationId: command.correlationId,
+                            auxiliary: true,
+                        },
+                    });
+                    return { ok: true, view: view(), events: [cancelled] };
+                }
+                case "application.switchWorkspace": {
+                    applyCommandSession(command.sessionId);
+                    state.cwd = path.resolve(command.cwd);
+                    const switched = publish({
+                        eventId: "application.workspace.switched",
+                        kind: "workspace",
+                        status: state.status,
+                        message: state.cwd,
+                    });
+                    return { ok: true, view: view(), events: [switched] };
+                }
+                case "application.changeModel": {
+                    applyCommandSession(command.sessionId);
+                    state.model = {
+                        ...createApplicationModelState({
+                            model: command.model,
+                            reasoningEffort: command.reasoningEffort ?? state.model.reasoningEffort,
+                            provider: command.provider ?? state.model.provider,
+                            endpointShape: command.endpointShape ?? state.model.endpointShape,
+                            baseURL: command.baseURL ?? state.model.baseURL,
+                            providerRoute: command.providerRoute ?? state.model.providerRoute,
+                            maxOutputTokens: command.maxOutputTokens ?? state.model.maxOutputTokens,
+                        }),
+                    };
+                    const changed = publish({
+                        eventId: "application.model.changed",
+                        kind: "model",
+                        status: state.status,
+                        message: `${state.model.model}/${state.model.reasoningEffort}`,
+                    });
+                    return { ok: true, view: view(), events: [changed] };
+                }
+                case "application.changePermissionProfile": {
+                    applyCommandSession(command.sessionId);
+                    state.permissionProfile = command.profile;
+                    const changed = publish({
+                        eventId: "application.permission.changed",
+                        kind: "permission",
+                        status: state.status,
+                        message: command.profile,
+                    });
+                    return { ok: true, view: view(), events: [changed] };
+                }
+                case "application.interrupt": {
+                    applyCommandSession(command.sessionId);
+                    state.status = "ready";
+                    const interrupted = publish({
+                        eventId: "application.interrupted",
+                        kind: "lifecycle",
+                        status: "ready",
+                        message: command.reason ?? "interrupted",
+                    });
+                    return { ok: true, view: view(), events: [interrupted] };
+                }
+                case "application.resume": {
+                    applyCommandSession(command.sessionId);
+                    state.status = "ready";
+                    const resumed = publish({
+                        eventId: "application.resumed",
+                        kind: "lifecycle",
+                        status: "ready",
+                        message: "session resumed",
+                    });
+                    return { ok: true, view: view(), events: [resumed] };
+                }
+                case "application.createSession": {
+                    const createdSessionId = command.sessionId?.trim()
+                        || `session.${applicationId}.${safeSessionName(command.name ?? String(state.sessions.size + 1))}`;
+                    state.sessionId = createdSessionId;
+                    if (command.cwd)
+                        state.cwd = path.resolve(command.cwd);
+                    state.status = "ready";
+                    state.sessions.set(state.sessionId, {
+                        sessionId: state.sessionId,
+                        name: command.name?.trim() || state.sessionId.split(".").at(-1),
+                        workspaceRoot: state.cwd,
+                        status: state.status,
+                        lastActiveAt: now(),
+                        turns: state.turns,
+                    });
+                    const created = publish({
+                        eventId: "application.session.created",
+                        kind: "lifecycle",
+                        status: "ready",
+                        message: state.sessionId,
+                    });
+                    return { ok: true, view: view(), events: [created] };
+                }
+                case "application.renameSession": {
+                    applyCommandSession(command.sessionId);
+                    const current = state.sessions.get(state.sessionId);
+                    state.sessions.set(state.sessionId, {
+                        sessionId: state.sessionId,
+                        name: command.name.trim(),
+                        workspaceRoot: current?.workspaceRoot ?? state.cwd,
+                        status: current?.status ?? state.status,
+                        lastActiveAt: now(),
+                        turns: current?.turns ?? state.turns,
+                    });
+                    const renamed = publish({
+                        eventId: "application.session.renamed",
+                        kind: "lifecycle",
+                        status: state.status,
+                        message: `${state.sessionId}:${command.name.trim()}`,
+                    });
+                    return { ok: true, view: view(), events: [renamed] };
+                }
+                case "application.rewind": {
+                    applyCommandSession(command.sessionId);
+                    const rewound = publish({
+                        eventId: "application.rewind.planned",
+                        kind: "runtime",
+                        status: state.status,
+                        message: command.turnId ?? String(command.turnIndex ?? "latest"),
+                    });
+                    return { ok: true, view: view(), events: [rewound] };
+                }
+                case "application.approvalDecision": {
+                    applyCommandSession(command.sessionId);
+                    const existing = state.approvals.get(command.approvalId);
+                    if (command.decision === "approve_always" && existing?.featureKey) {
+                        state.alwaysApprovedApprovalKeys.add(existing.featureKey);
+                    }
+                    state.approvals.set(command.approvalId, {
+                        ...existing,
+                        approvalId: command.approvalId,
+                        decision: command.decision,
+                        status: "decided",
+                        note: command.note,
+                        updatedAt: now(),
+                    });
+                    const resolver = state.pendingApprovalResolvers.get(command.approvalId);
+                    if (resolver) {
+                        state.pendingApprovalResolvers.delete(command.approvalId);
+                        state.status = "running";
+                        resolver({
+                            status: command.decision === "reject" ? "denied" : "approved",
+                            resolvedBy: "application.approvalDecision",
+                            reason: command.note ?? command.decision,
+                            metadata: {
+                                approvalId: command.approvalId,
+                                decision: command.decision,
+                                featureKey: existing?.featureKey,
+                            },
+                        });
+                    }
+                    const approval = publish({
+                        eventId: "application.approval.decided",
+                        kind: "approval",
+                        status: state.status,
+                        message: `${command.approvalId}:${command.decision}`,
+                        metadata: {
+                            approvalId: command.approvalId,
+                            decision: command.decision,
+                            note: command.note,
+                        },
+                    });
+                    return { ok: true, view: view(), events: [approval] };
+                }
+                case "application.requestApproval": {
+                    applyCommandSession(command.sessionId);
+                    state.status = "awaiting-approval";
+                    state.approvals.set(command.approvalId, {
+                        approvalId: command.approvalId,
+                        status: "pending",
+                        note: command.reason,
+                        updatedAt: now(),
+                    });
+                    const requested = publish({
+                        eventId: "application.approval.requested",
+                        kind: "approval",
+                        status: "awaiting-approval",
+                        message: `${command.approvalId}:${command.reason}`,
+                        metadata: {
+                            approvalId: command.approvalId,
+                            reason: command.reason,
+                        },
+                    });
+                    return { ok: true, view: view(), events: [requested] };
+                }
+                case "application.close": {
+                    applyCommandSession(command.sessionId);
+                    state.status = "closed";
+                    const closed = publish({
+                        eventId: "application.closed",
+                        kind: "lifecycle",
+                        status: "closed",
+                        message: "application runtime closed",
+                    });
+                    return { ok: true, view: view(), events: [closed] };
+                }
+            }
+        },
+    };
+}
+export async function createApplicationProjectRuntime(projectRoot, options = {}) {
+    const loaded = await loadApplicationProject(projectRoot);
+    if (!loaded.ok)
+        return loaded;
+    return {
+        ok: true,
+        runtime: createPraxisApplicationRuntime({
+            ...options,
+            project: loaded.project,
+        }),
+    };
+}