narraeon 0.7.10 → 0.8.1

package/dist/node/protocol/modelConnections.js

@@ -6,6 +6,15 @@ export function hasCLIProxyThinkingSuffix(modelId) {
 export function modelReasoningPolicyIssue(input) {
     const thinking = input.thinking ?? "provider_default";
     const thinkingBudgetTokens = input.thinkingBudgetTokens ?? null;
+    if (input.provider === "google_interactions") {
+        if (input.dialect !== "standard")
+            return "Google Interactions requires the standard dialect";
+        if (input.effort !== "provider_default" ||
+            input.summary !== "provider_default" ||
+            thinking !== "provider_default" ||
+            thinkingBudgetTokens !== null)
+            return "Google Interactions model capabilities are unverified; use provider defaults";
+    }
     const thinkingControlledByCLIProxySuffix = input.provider === "anthropic_messages" &&
         input.dialect === "cliproxyapi" &&
         hasCLIProxyThinkingSuffix(input.modelId);
@@ -54,6 +63,12 @@ export const modelProviderPresets = [
         provider: "chat_completions",
         baseUrl: "",
     },
+    {
+        id: "google-interactions",
+        name: "Google Gemini · Interactions",
+        provider: "google_interactions",
+        baseUrl: "https://generativelanguage.googleapis.com/v1beta",
+    },
     {
         id: "openai",
         name: "OpenAI · Responses API",

package/dist/node/protocol/modelUsage.js

@@ -24,6 +24,10 @@ export function aggregateModelUsage(current, next) {
     }
     return {
         ...result,
+        ...(next?.accounting === "google_interactions" ||
+            current.accounting === "google_interactions"
+            ? { accounting: "google_interactions" }
+            : {}),
         provenance: Object.fromEntries(modelUsageKeys.map((key) => [
             key,
             result[key] === null ? "unavailable" : "derived_provider_fields",

package/dist/node/protocol/sillyTavernContent.js

@@ -0,0 +1 @@
+export {};

package/dist/node/protocol/v1.js

@@ -73,6 +73,14 @@ const requiredFields = {
         message: "string",
         continuation: "object",
     },
+    "setting-improvement.message.edit": {
+        packageId: "string",
+        sessionId: "string",
+        requestId: "string",
+        messageId: "string",
+        message: "string",
+        filePolicy: "string",
+    },
     "setting-improvement.cancel": { sessionId: "string" },
     "setting-improvement.resume": {
         packageId: "string",
@@ -89,6 +97,28 @@ const requiredFields = {
     "play.select": { presetId: "string" },
     "play.export": { presetId: "string" },
     "play.import": { name: "string", files: "array" },
+    "content.sillytavern.inspect": { source: "string" },
+    "content.sillytavern.preview": {
+        source: "string",
+        name: "string",
+        selection: "object",
+    },
+    "content.sillytavern.import": {
+        source: "string",
+        name: "string",
+        selection: "object",
+    },
+    "play.sillytavern.inspect": { source: "string" },
+    "play.sillytavern.preview": {
+        source: "string",
+        selected: "array",
+        name: "string",
+    },
+    "play.sillytavern.import": {
+        source: "string",
+        selected: "array",
+        name: "string",
+    },
     "play.workbench.read": {},
     "prompt.preview": {
         packageId: "string",
@@ -130,6 +160,14 @@ const requiredFields = {
         message: "string",
         continuation: "object",
     },
+    "world.revision.message.edit": {
+        worldId: "string",
+        sessionId: "string",
+        requestId: "string",
+        messageId: "string",
+        message: "string",
+        filePolicy: "string",
+    },
     "world.revision.cancel": { sessionId: "string" },
     "world.revision.resume": {
         worldId: "string",
@@ -229,6 +267,10 @@ function validateRequestFields(request) {
         if (!valid || (kind === "string" && value === "" && !allowsEmptyString))
             throw new V1ProtocolError("invalid_request", `${String(request.type)}.${field} is invalid`);
     }
+    if (request.type === "setting-improvement.message.edit" &&
+        request.filePolicy !== "keep" &&
+        request.filePolicy !== "revert")
+        throw new V1ProtocolError("invalid_request", "setting-improvement.message.edit.filePolicy is invalid");
     if (request.type === "world.story.export" &&
         request.format !== "markdown" &&
         request.format !== "text")
@@ -326,6 +368,53 @@ function validateRequestFields(request) {
         if (request.revision !== undefined && request.presetId === undefined)
             throw new V1ProtocolError("invalid_request", "play.workbench.read.revision must be provided with presetId");
     }
+    if (typeof request.type === "string" &&
+        request.type.startsWith("content.sillytavern.")) {
+        const inspect = request.type === "content.sillytavern.inspect";
+        const allowed = inspect
+            ? ["type", "source"]
+            : ["type", "source", "name", "selection"];
+        if (Object.keys(request).some((key) => !allowed.includes(key)))
+            throw new V1ProtocolError("invalid_request", "Invalid SillyTavern content fields");
+        if (!inspect) {
+            const selection = request.selection;
+            if (!isRecord(selection) ||
+                Object.keys(selection).some((key) => ![
+                    "character",
+                    "scenario",
+                    "opening",
+                    "example",
+                    "systemPrompt",
+                    "attachments",
+                    "entries",
+                ].includes(key)) ||
+                (!Array.isArray(selection.attachments) &&
+                    selection.attachments !== undefined) ||
+                (Array.isArray(selection.attachments) &&
+                    !selection.attachments.every((value) => typeof value === "string")) ||
+                !isRecord(selection.entries) ||
+                Object.values(selection.entries).some((value) => value !== "world" && value !== "attachment") ||
+                ["character", "scenario", "example", "systemPrompt"].some((key) => selection[key] !== undefined && typeof selection[key] !== "boolean") ||
+                (selection.opening !== undefined &&
+                    typeof selection.opening !== "string"))
+                throw new V1ProtocolError("invalid_request", "Invalid SillyTavern content selection");
+        }
+    }
+    if (typeof request.type === "string" &&
+        request.type.startsWith("play.sillytavern.")) {
+        const inspect = request.type === "play.sillytavern.inspect";
+        const allowed = inspect
+            ? ["type", "source", "groupId"]
+            : ["type", "source", "groupId", "selected", "name"];
+        if (Object.keys(request).some((key) => !allowed.includes(key)) ||
+            (request.groupId !== undefined &&
+                (typeof request.groupId !== "string" ||
+                    request.groupId.length === 0)) ||
+            (!inspect &&
+                (!Array.isArray(request.selected) ||
+                    !request.selected.every((value) => typeof value === "string" && value.length > 0))))
+            throw new V1ProtocolError("invalid_request", `${request.type} has invalid fields`);
+    }
     if (request.type === "play.import") {
         if (!request.files.every((file) => isRecord(file) &&
             typeof file.path === "string" &&
@@ -441,6 +530,7 @@ const requestTypes = new Set([
     "setting-improvement.session.delete",
     "setting-improvement.rollback",
     "setting-improvement.message",
+    "setting-improvement.message.edit",
     "setting-improvement.cancel",
     "setting-improvement.resume",
     "play.read",
@@ -454,6 +544,12 @@ const requestTypes = new Set([
     "play.select",
     "play.export",
     "play.import",
+    "content.sillytavern.inspect",
+    "content.sillytavern.preview",
+    "content.sillytavern.import",
+    "play.sillytavern.inspect",
+    "play.sillytavern.preview",
+    "play.sillytavern.import",
     "play.workbench.read",
     "prompt.preview",
     "world.create",
@@ -476,6 +572,7 @@ const requestTypes = new Set([
     "world.revision.session.read",
     "world.revision.session.delete",
     "world.revision.message",
+    "world.revision.message.edit",
     "world.revision.cancel",
     "world.revision.resume",
     "world.revision.files.replace",

package/dist/node/runtime/V1Runtime.js

@@ -1,3 +1,5 @@
+import { inspectSillyTavernContent, convertSillyTavernContent, } from "./content/SillyTavernContent.js";
+import { inspectSillyTavernPreset, convertSillyTavernPreset, } from "../shared/sillytavern-preset.js";
 import { WorldArchives } from "./archive/WorldArchives.js";
 import { WorldArchiveError } from "./archive/WorldArchiveZip.js";
 import { FileNativeWorldCreationError } from "./world/FileNativeWorldStore.js";
@@ -16,14 +18,14 @@ import { ModelConnectionStore } from "./model/ModelConnectionStore.js";
 import { FileNativeContinuityCorrection } from "./play/FileNativeContinuityCorrection.js";
 import { fingerprintControl } from "./play/PlayDocumentTools.js";
 import { PlayCallChain, PlayCallChainError, } from "./play/PlayCallChain.js";
-import { FileNativePlayPresetError, FileNativePlayPresetStore, presetHostBinding, } from "./play/FileNativePlayPresetStore.js";
+import { FileNativePlayPresetError, FileNativePlayPresetStore, presetHostBinding, parsePlayPresetFiles, toPlayPresetStructuredEditor, } from "./play/FileNativePlayPresetStore.js";
 import { buildPlayPresetWorkbenchSnapshot } from "./play/PlayPresetWorkbench.js";
 import { FileNativeArtifactStore } from "./artifact/FileNativeArtifactStore.js";
 import { projectArtifactForFrontend, projectDebugArtifactForFrontend, } from "./extension/FrontendExtensionBundle.js";
 import { projectPlayerViewPanels, } from "./extension/PlayerViewPanelProjector.js";
 import { FileNativePromptCompiler } from "./prompt/FileNativePromptCompiler.js";
 import { FileNativeSettingImprovementStore } from "./setting/FileNativeSettingImprovementStore.js";
-import { SettingImprovementRollbackError, SettingImprovementSession, } from "./setting/SettingImprovementSession.js";
+import { SettingImprovementRollbackError, SettingImprovementSession, SettingMessageEditError, } from "./setting/SettingImprovementSession.js";
 import { FileNativeWorldStore } from "./world/FileNativeWorldStore.js";
 import { WorldDocumentStore } from "./world/WorldDocumentStore.js";
 import { FileNativeAiFailureLog } from "./model/AiFailureLog.js";
@@ -31,7 +33,7 @@ import { FileNativeRuntimeErrorLog } from "./RuntimeErrorLog.js";
 import { ProtagonistTemplateStore } from "./config/ProtagonistTemplateStore.js";
 import { AppPreferencesStore } from "./config/AppPreferencesStore.js";
 import { FileNativeWorldRevisionStore } from "./world-revision/FileNativeWorldRevisionStore.js";
-import { WorldRevisionSession } from "./world-revision/WorldRevisionSession.js";
+import { WorldRevisionSession, WorldRevisionMessageEditError, } from "./world-revision/WorldRevisionSession.js";
 import { WorldRevisionWorkspace, WorldRevisionWorkspaceError, } from "./world-revision/WorldRevisionWorkspace.js";
 import { ConversationChanges } from "./ConversationChanges.js";
 // 先取得当前端点再按它读取的请求，在端点被回退丢弃时最多重做这么多次（#94）。
@@ -363,6 +365,33 @@ export class V1Runtime {
                     throw error;
                 }
             }
+            case "content.sillytavern.inspect":
+            case "content.sillytavern.preview":
+            case "content.sillytavern.import": {
+                try {
+                    if (request.source.length > 12 * 1024 * 1024 ||
+                        !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u.test(request.source))
+                        throw new Error("Invalid source encoding");
+                    const source = Buffer.from(request.source, "base64");
+                    if (source.toString("base64") !== request.source)
+                        throw new Error("Invalid source encoding");
+                    if (request.type === "content.sillytavern.inspect")
+                        return inspectSillyTavernContent(source);
+                    const converted = convertSillyTavernContent(source, request.selection, this.#locale);
+                    this.#content.validateCurrentTreeContentPackage(converted.files);
+                    if (request.type === "content.sillytavern.preview")
+                        return {
+                            ...converted,
+                            inspection: this.#content.inspectCurrentTreeContentPackage(converted.files),
+                        };
+                    return await this.#content.importSillyTavernContent(request.name, converted.files);
+                }
+                catch (error) {
+                    throw new V1ProtocolError("invalid_request", error instanceof Error
+                        ? error.message
+                        : "Invalid SillyTavern content");
+                }
+            }
             case "content.export": {
                 const exported = await this.#content.exportCurrentTreeContentPackage(request.packageId);
                 return {
@@ -395,6 +424,22 @@ export class V1Runtime {
                 }
             case "setting-improvement.message":
                 return this.#settingImprovements.send(request);
+            case "setting-improvement.message.edit":
+                try {
+                    return await this.#settingImprovements.editMessage(request);
+                }
+                catch (error) {
+                    if (error instanceof SettingMessageEditError)
+                        throw new V1ProtocolError("invalid_request", error.message, {
+                            cause: error,
+                            details: {
+                                kind: "setting_message_edit",
+                                reason: error.reason,
+                                paths: error.paths,
+                            },
+                        });
+                    throw error;
+                }
             case "setting-improvement.cancel":
                 return this.#settingImprovements.cancel(request.sessionId);
             case "setting-improvement.resume":
@@ -423,6 +468,47 @@ export class V1Runtime {
                 };
             case "play.import":
                 return this.#playPresets.importPortable(request);
+            case "play.sillytavern.inspect":
+            case "play.sillytavern.preview":
+            case "play.sillytavern.import": {
+                // Do not trust the browser to enforce the import limit or supply
+                // already-converted files. Preview and import both parse from source.
+                if (Buffer.byteLength(request.source, "utf8") > 2 * 1024 * 1024)
+                    throw new V1ProtocolError("invalid_request", "SillyTavern source exceeds the size limit");
+                if (request.type !== "play.sillytavern.inspect" &&
+                    (request.selected.length > 4096 ||
+                        request.selected.reduce((bytes, id) => bytes + Buffer.byteLength(id, "utf8"), 0) >
+                            2 * 1024 * 1024))
+                    throw new V1ProtocolError("invalid_request", "SillyTavern selection exceeds the size limit");
+                try {
+                    if (request.type === "play.sillytavern.inspect")
+                        return inspectSillyTavernPreset(request.source, request.groupId);
+                    const converted = convertSillyTavernPreset(request.source, {
+                        groupId: request.groupId,
+                        selected: request.selected,
+                        name: request.name,
+                        locale: this.#locale,
+                    });
+                    if (request.type === "play.sillytavern.preview") {
+                        const parsed = parsePlayPresetFiles(converted.files);
+                        if (parsed.kind === "invalid")
+                            throw parsed.error;
+                        toPlayPresetStructuredEditor(parsed.definition);
+                        return converted;
+                    }
+                    return await this.#playPresets.importPortable({
+                        name: request.name,
+                        files: converted.files,
+                    });
+                }
+                catch (error) {
+                    if (error instanceof V1ProtocolError)
+                        throw error;
+                    throw new V1ProtocolError("invalid_request", error instanceof Error
+                        ? error.message
+                        : "Invalid SillyTavern preset");
+                }
+            }
             case "play.workbench.read": {
                 const binding = request.presetId === undefined
                     ? await this.#playPresets.bindCurrent()
@@ -638,6 +724,22 @@ export class V1Runtime {
                 return this.#worldRevisionCall(() => this.#worldRevisions.deleteSession(request.worldId, request.sessionId));
             case "world.revision.message":
                 return this.#worldRevisionCall(() => this.#worldRevisions.send(request));
+            case "world.revision.message.edit":
+                try {
+                    return await this.#worldRevisionCall(() => this.#worldRevisions.editMessage(request));
+                }
+                catch (error) {
+                    if (error instanceof WorldRevisionMessageEditError)
+                        throw new V1ProtocolError("invalid_request", error.message, {
+                            cause: error,
+                            details: {
+                                kind: "world_revision_message_edit",
+                                reason: error.reason,
+                                paths: error.paths,
+                            },
+                        });
+                    throw error;
+                }
             case "world.revision.cancel":
                 return this.#worldRevisionCall(() => this.#worldRevisions.cancel(request.sessionId));
             case "world.revision.resume":

package/dist/node/runtime/authoring/AuthoringEditPlan.js

@@ -0,0 +1,79 @@
+import { validAuthoringNativeContinuation } from "../model/FileNativeModelAdapters.js";
+/** Checks idempotency before a target claims its own publication lease. */
+export function completedAuthoringEdit(session, edit) {
+    const prior = session.editReceipts?.find(({ requestId }) => requestId === edit.requestId);
+    if (prior !== undefined &&
+        (prior.messageId !== edit.messageId ||
+            prior.message !== edit.message ||
+            prior.filePolicy !== edit.filePolicy))
+        throw new Error("This edit request ID was already used for different content");
+    if (!session.completedRequestIds.includes(edit.requestId))
+        return false;
+    if (prior === undefined)
+        throw new Error("This request ID was already used for another authoring operation");
+    return true;
+}
+/** Locates and validates the native prefix and prepares the replacement transcript. */
+export function planAuthoringEdit(session, edit) {
+    const messageIndex = session.messages.findIndex((entry) => entry.role === "user" && entry.id === edit.messageId);
+    if (messageIndex < 0)
+        throw new Error("The selected authoring message no longer exists");
+    const userIndex = session.messages
+        .slice(0, messageIndex)
+        .filter((entry) => entry.role === "user").length;
+    const itemIndex = session.modelItems
+        .map((item, index) => (item.kind === "user" ? index : -1))
+        .filter((index) => index >= 0)[userIndex];
+    if (itemIndex === undefined ||
+        session.modelItems[itemIndex]?.kind !== "user" ||
+        session.modelItems[itemIndex].text !== session.messages[messageIndex].text)
+        throw new Error("The selected authoring message cannot be matched to the native transcript");
+    const prefix = session.modelItems.slice(0, itemIndex);
+    if (!validAuthoringNativeContinuation(prefix, session.modelBinding.provider))
+        throw new Error("The native continuation before this message is damaged; start a fresh context");
+    const next = structuredClone(session);
+    next.editReceipts = [...(next.editReceipts ?? []), edit];
+    delete next.retryDispatch;
+    next.modelItems = prefix;
+    next.messages = next.messages.slice(0, messageIndex);
+    next.requests = (next.requests ?? []).filter((entry) => entry.modelItemStart < itemIndex);
+    return {
+        itemIndex,
+        tail: session.modelItems.slice(itemIndex),
+        next: { ...next, requests: next.requests },
+    };
+}
+/** Returns a candidate tree and conflicts; the target validates and publishes it. */
+export function revertAuthoringChanges(files, items) {
+    const result = new Map(files.map((file) => [file.path, structuredClone(file)]));
+    const conflicts = new Set();
+    const changes = items.flatMap((item) => item.kind === "tool" && !item.isError ? item.changes : []);
+    for (const change of changes.reverse()) {
+        if (conflicts.has(change.path))
+            continue;
+        const malformed = (change.kind === "create" &&
+            (change.before !== null || change.after === null)) ||
+            (change.kind === "delete" &&
+                (change.before === null || change.after !== null)) ||
+            (change.kind === "modify" &&
+                (change.before === null ||
+                    change.after === null ||
+                    change.before === change.after));
+        const current = result.get(change.path);
+        if (malformed ||
+            (change.after === null
+                ? current !== undefined
+                : current?.contents !== change.after || current.encoding !== undefined)) {
+            conflicts.add(change.path);
+            continue;
+        }
+        if (change.before === null)
+            result.delete(change.path);
+        else
+            result.set(change.path, { path: change.path, contents: change.before });
+    }
+    return {
+        files: [...result.values()].sort((a, b) => a.path.localeCompare(b.path)),
+        conflicts: [...conflicts].sort(),
+    };
+}

package/dist/node/runtime/authoring/AuthoringRequestSnapshot.js

@@ -1,4 +1,5 @@
 import { isPlayPresetBinding, } from "../play/FileNativePlayPresetStore.js";
+import { isSafeGoogleWireRequest } from "../model/GoogleRequestPreview.js";
 export function isAuthoringPreloadRecord(value) {
     if (typeof value !== "object" || value === null || Array.isArray(value))
         return false;
@@ -25,9 +26,17 @@ export function validAuthoringRequests(value, validPrompt, session) {
         if (typeof raw !== "object" || raw === null || Array.isArray(raw))
             return false;
         const item = raw;
-        const keys = Object.keys(item).length;
-        if ((keys !== 4 && !(keys === 5 && "preload" in item)) ||
+        if (!Object.keys(item).every((key) => [
+            "requestId",
+            "modelItemStart",
+            "bootstrap",
+            "playPreset",
+            "preload",
+            "wireRequest",
+        ].includes(key)) ||
             (item.preload !== undefined && !isAuthoringPreloadRecord(item.preload)) ||
+            (item.wireRequest !== undefined &&
+                !isSafeGoogleWireRequest(item.wireRequest)) ||
             typeof item.requestId !== "string" ||
             !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,159}$/u.test(item.requestId) ||
             ids.has(item.requestId) ||
@@ -67,9 +76,12 @@ export function authoringRequestPreviews(session) {
                 },
             ]
             : []),
-        ...requests.map(({ requestId, bootstrap }) => ({
+        ...requests.map(({ requestId, bootstrap, wireRequest }) => ({
             requestId,
             compilation: structuredClone(bootstrap),
+            ...(wireRequest === undefined
+                ? {}
+                : { wireRequest: structuredClone(wireRequest) }),
             legacyBootstrap: false,
         })),
     ];

package/dist/node/runtime/authoring/AuthoringRetry.js

@@ -0,0 +1,59 @@
+import { validAuthoringNativeContinuation } from "../model/FileNativeModelAdapters.js";
+import { dispatchRequiresFreshContext } from "../model/DispatchFailure.js";
+export function prepareAuthoringDispatch(session, request) {
+    const retry = session.retryDispatch;
+    if (retry?.state === "retryable") {
+        session.retryDispatch = { ...retry, state: "dispatching" };
+        return { ...request, requestId: retry.requestId, exchange: retry.exchange };
+    }
+    session.retryDispatch = {
+        requestId: request.requestId,
+        exchange: request.exchange,
+        modelItemCount: session.modelItems.length,
+        state: "dispatching",
+    };
+    return request;
+}
+export function checkpointNextAuthoringDispatch(session, state) {
+    const request = session.requests?.at(-1);
+    if (session.modelBinding.provider !== "google_interactions" &&
+        request !== undefined)
+        session.retryDispatch = {
+            requestId: request.requestId,
+            exchange: session.exchange + 1,
+            modelItemCount: session.modelItems.length,
+            state,
+        };
+}
+export function failAuthoringDispatch(session, error, phase) {
+    const checkpoint = session.retryDispatch;
+    if (checkpoint === undefined)
+        return;
+    // Acceptance clears the previous checkpoint. During settlement only a
+    // completed tool receipt can create the next one, before its final save.
+    const settledNextRequest = phase === "settling" &&
+        session.pendingSettlement === null &&
+        checkpoint.state === "dispatching" &&
+        checkpoint.modelItemCount === session.modelItems.length;
+    checkpoint.state =
+        session.modelBinding.provider !== "google_interactions" &&
+            (phase === "preparing" || phase === "dispatched" || settledNextRequest) &&
+            !dispatchRequiresFreshContext(error, false)
+            ? "retryable"
+            : "blocked";
+}
+export function recoverAuthoringDispatch(session) {
+    if (session.retryDispatch?.state === "dispatching")
+        session.retryDispatch.state =
+            session.modelBinding.provider === "google_interactions"
+                ? "blocked"
+                : "retryable";
+}
+export function canRetryAuthoringDispatch(session) {
+    return (session.runStatus === "interrupted" &&
+        session.modelBinding.provider !== "google_interactions" &&
+        session.googleOutcomeUnknown !== true &&
+        session.pendingSettlement === null &&
+        session.retryDispatch?.state === "retryable" &&
+        validAuthoringNativeContinuation(session.modelItems, session.modelBinding.provider));
+}

package/dist/node/runtime/authoring/DamagedGoogleContinuation.js

@@ -0,0 +1,68 @@
+import { validGoogleInteractionsContinuation } from "../model/ProviderExchangeState.js";
+export function hasDamagedGoogleSteps(value) {
+    return (isRecord(value) &&
+        isRecord(value.modelBinding) &&
+        value.modelBinding.provider === "google_interactions" &&
+        Array.isArray(value.modelItems) &&
+        value.modelItems.some((item) => isRecord(item) &&
+            item.kind === "assistant" &&
+            damagedGoogleState(item.providerState)));
+}
+/** A disposable copy for discovery only. Callers must still validate the complete schema. */
+export function withoutDamagedGoogleSteps(value) {
+    if (!isRecord(value) ||
+        !isRecord(value.modelBinding) ||
+        value.modelBinding.provider !== "google_interactions" ||
+        value.pendingSettlement !== null ||
+        value.googleOutcomeUnknown === true ||
+        value.activeRequestId !== null ||
+        (value.runStatus !== "ready" && value.runStatus !== "interrupted") ||
+        !Array.isArray(value.modelItems))
+        return null;
+    const copy = structuredClone(value);
+    if (!Array.isArray(copy.modelItems))
+        return null;
+    const items = copy.modelItems;
+    for (const [index, item] of items.entries()) {
+        if (isRecord(item) &&
+            item.kind === "assistant" &&
+            isRecord(item.providerState) &&
+            item.providerState.protocol !== "google_interactions")
+            return null;
+        if (!isRecord(item) ||
+            item.kind !== "assistant" ||
+            !Array.isArray(item.toolCalls))
+            continue;
+        for (const [offset, call] of item.toolCalls.entries()) {
+            const result = items[index + offset + 1];
+            if (!isRecord(call) ||
+                typeof call.id !== "string" ||
+                !isRecord(result) ||
+                result.kind !== "tool" ||
+                result.toolCallId !== call.id)
+                return null;
+        }
+    }
+    let damaged = false;
+    for (const item of items) {
+        if (!isRecord(item) ||
+            item.kind !== "assistant" ||
+            !damagedGoogleState(item.providerState))
+            continue;
+        if (isRecord(item.providerState))
+            item.providerState.steps = [];
+        else
+            item.providerState = { protocol: "google_interactions", steps: [] };
+        damaged = true;
+    }
+    return damaged ? copy : null;
+}
+function damagedGoogleState(value) {
+    return (value == null ||
+        (isRecord(value) &&
+            value.protocol === "google_interactions" &&
+            !validGoogleInteractionsContinuation(value.steps)));
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}