narraeon 0.7.10 → 0.8.0

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

@@ -89,6 +89,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",
@@ -326,6 +348,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" &&
@@ -454,6 +523,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",

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,7 +18,7 @@ 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";
@@ -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 {
@@ -423,6 +452,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()

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/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);
+}

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

@@ -1,8 +1,28 @@
 import { randomUUID } from "node:crypto";
 import { aggregateModelUsage, } from "../../protocol/modelUsage.js";
 import { ModelHostCancelledError } from "../model/ModelHost.js";
+import { withGoogleHop } from "../model/GoogleRequestPreview.js";
 const maximumExchangesPerMessage = 64;
 const maximumStreamTailCharacters = 240;
+export function authoringExchange(session, requestId, boundaries) {
+    const bootstrap = session.requests?.at(-1)?.bootstrap ?? session.bootstrap;
+    return {
+        bootstrap,
+        toolUniverse: bootstrap.toolUniverse,
+        allowedTools: bootstrap.toolUniverse.map(({ name }) => name),
+        toolStrategy: bootstrap.toolStrategy,
+        tools: bootstrap.tools,
+        appended: session.modelItems,
+        ...(boundaries === undefined
+            ? {}
+            : { worldRevisionBoundaries: boundaries }),
+        requestId,
+        operationId: session.sessionId,
+        requestAttempt: 1,
+        exchange: session.exchange + 1,
+        maxOutputTokens: session.modelBinding.maxOutputTokens,
+    };
+}
 /**
  * Deep Module for the shared authoring-conversation loop. Its Interface leaves
  * content-package and world-revision publication behind the settlement seam.
@@ -56,28 +76,25 @@ export class ModelToolConversation {
     }
     async #execute(input, live) {
         const { session } = input;
-        const bootstrap = session.requests?.at(-1)?.bootstrap ?? session.bootstrap;
         try {
             for (let round = 0; round < maximumExchangesPerMessage; round += 1) {
+                const request = authoringExchange(session, live.requestId, input.worldRevisionBoundaries);
                 session.exchange += 1;
+                if (session.modelBinding.provider === "google_interactions")
+                    session.googleOutcomeUnknown = true;
                 live.streaming = emptyStreaming();
                 session.updatedAt = Date.now();
                 await input.save(session);
                 input.changed?.(true);
-                const response = await input.host.exchange({
-                    bootstrap,
-                    toolUniverse: bootstrap.toolUniverse,
-                    allowedTools: bootstrap.toolUniverse.map(({ name }) => name),
-                    toolStrategy: bootstrap.toolStrategy,
-                    tools: bootstrap.tools,
-                    appended: session.modelItems,
-                    requestId: live.requestId,
-                    operationId: session.sessionId,
-                    requestAttempt: 1,
-                    exchange: session.exchange,
-                    maxOutputTokens: session.modelBinding.maxOutputTokens,
-                }, {
+                const response = await input.host.exchange(request, {
                     signal: live.controller.signal,
+                    onGoogleHop: (hop) => {
+                        const snapshot = session.requests?.findLast((entry) => entry.requestId === live.requestId);
+                        if (snapshot?.wireRequest === undefined)
+                            return;
+                        snapshot.wireRequest = withGoogleHop(snapshot.wireRequest, hop);
+                        return input.recordGoogleHop?.(live.requestId, hop);
+                    },
                     onDelta: (delta) => {
                         recordDelta(live, delta);
                         input.changed?.(false);
@@ -100,6 +117,8 @@ export class ModelToolConversation {
                     providerState: response.providerState,
                     toolCalls: structuredClone(toolCalls),
                 });
+                if (session.modelBinding.provider === "google_interactions")
+                    session.googleOutcomeUnknown = false;
                 session.updatedAt = Date.now();
                 if (toolCalls.length === 0) {
                     session.messages.push({
@@ -134,13 +153,15 @@ export class ModelToolConversation {
             session.activeRequestId = null;
             session.completedRequestIds = rememberRequest(session.completedRequestIds, live.requestId);
             session.lastFailure =
-                error instanceof ModelHostCancelledError
-                    ? (input.failure?.cancelled ??
-                        "The authoring response was cancelled. Complete tool responses already settled were retained.")
-                    : error instanceof Error
-                        ? error.message
-                        : (input.failure?.interrupted ??
-                            "The authoring response was interrupted");
+                session.googleOutcomeUnknown === true
+                    ? "The Google request outcome is unknown; start a fresh model context before sending again."
+                    : error instanceof ModelHostCancelledError
+                        ? (input.failure?.cancelled ??
+                            "The authoring response was cancelled. Complete tool responses already settled were retained.")
+                        : error instanceof Error
+                            ? error.message
+                            : (input.failure?.interrupted ??
+                                "The authoring response was interrupted");
             session.updatedAt = Date.now();
             await input.save(session);
             return input.view(session);
@@ -170,7 +191,11 @@ export function appendAuthoringUserMessage(session, message, requestId) {
 export function resumePausedAuthoringConversation(session) {
     if (session.runStatus !== "paused")
         throw new Error("Only a paused authoring conversation can be continued");
-    if (session.modelItems.at(-1)?.kind !== "tool")
+    const last = session.modelItems.at(-1);
+    if (last?.kind !== "tool" &&
+        !(session.modelBinding.provider === "google_interactions" &&
+            session.googleOutcomeUnknown === false &&
+            last?.kind === "user"))
         throw new Error("The paused authoring conversation does not end with settled tool results");
     session.runStatus = "running";
     session.activeRequestId = session.requests?.at(-1)?.requestId ?? null;

package/dist/node/runtime/content/ContentWorkspace.js

@@ -96,6 +96,9 @@ export class ContentWorkspace {
             }, options.signal === undefined ? {} : { signal: options.signal });
         });
     }
+    importSillyTavernContent(title, files) {
+        return this.#mutate(() => this.#currentTreeLibrary.importPackage({ title, files }));
+    }
     copyCurrentTreeContentPackage(localId, options = {}) {
         return this.#mutate(() => this.#currentTreeLibrary.copyPackage(localId, options.signal === undefined ? {} : { signal: options.signal }));
     }