@rynx-ai/daemon 0.1.11-beta.25 → 0.1.11-beta.26

package/bundled-plugins/plugins/lark/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rynx-ai/plugin-channel-lark",
-  "version": "0.1.11-beta.25",
+  "version": "0.1.11-beta.26",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rynx-ai/rynx.git",

package/dist/daemon-server.js

@@ -303,7 +303,9 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, onShut
                 "semantic.session.create.v1",
                 "semantic.session.fork.v1",
                 "semantic.session.message.v1",
-                "semantic.session.resources.v1",
+                "semantic.session.resources.v2",
+                "semantic.session.files.v1",
+                "semantic.session.workspace-files.v1",
                 "semantic.session.message-queue.v1",
                 "semantic.session.delete.v1",
                 "semantic.session.interaction.v1",
@@ -447,6 +449,7 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, onShut
             sessionContextProvider: browserRunnerSessionContexts,
             admissionOpen,
             admissionReserve: reserveAdmission,
+            materializeGeneratedImage: (input) => sessionResources.materializeGeneratedImage(input),
             onMirrorError: (error, sessionId) => warn(`Session mirror failed for ${sessionId}: ${error instanceof Error ? error.message : String(error)}`),
         });
         const sessionBrowserHost = appBrowserHostSupervisor

package/dist/db.js

@@ -109,8 +109,9 @@ function migrate(conn) {
       session_id       TEXT NOT NULL,
       client_upload_id TEXT NOT NULL,
       upload_id        TEXT NOT NULL UNIQUE,
+      kind             TEXT NOT NULL DEFAULT 'image' CHECK(kind IN ('image', 'file')),
       filename         TEXT NOT NULL,
-      media_type       TEXT NOT NULL CHECK(media_type IN ('image/png', 'image/jpeg', 'image/webp')),
+      media_type       TEXT NOT NULL,
       byte_length      INTEGER NOT NULL,
       uploaded_bytes   INTEGER NOT NULL DEFAULT 0,
       sha256           TEXT,
@@ -141,6 +142,9 @@ function migrate(conn) {
           'failed_not_started'
         )),
       error            TEXT,
+      response_id      TEXT,
+      message_item_id  TEXT,
+      execution_snapshot TEXT,
       created_at       INTEGER NOT NULL,
       updated_at       INTEGER NOT NULL,
       PRIMARY KEY(session_id, client_message_id)
@@ -341,6 +345,7 @@ function migrate(conn) {
     CREATE INDEX IF NOT EXISTS idx_runtime_pending_enrollments_expires
       ON runtime_pending_enrollments(expires_at);
   `);
+    migrateSessionResourceFiles(conn);
     migratePluginCapabilityDeclarations(conn);
     migrateSessionSnapshots(conn);
     // Breaking plugin-runtime cutover: remove obsolete core-owned state.
@@ -351,6 +356,80 @@ function migrate(conn) {
     addColumnIfMissing(conn, "plugin_marketplaces", "built_in", "INTEGER NOT NULL DEFAULT 0");
     addColumnIfMissing(conn, "sessions", "forked_from_session_id", "TEXT");
     addColumnIfMissing(conn, "plugin_session_launch_operations", "raw_request_hash", "TEXT");
+    addColumnIfMissing(conn, "session_message_operations", "response_id", "TEXT");
+    addColumnIfMissing(conn, "session_message_operations", "message_item_id", "TEXT");
+    addColumnIfMissing(conn, "session_message_operations", "execution_snapshot", "TEXT");
+}
+/** Rebuild the original image-only table without losing committed resources. */
+function migrateSessionResourceFiles(conn) {
+    const columns = conn
+        .prepare("PRAGMA table_info(session_resources)")
+        .all();
+    if (columns.some((column) => column.name === "kind"))
+        return;
+    conn.exec("PRAGMA foreign_keys = OFF");
+    try {
+        transaction(conn, () => {
+            conn.exec(`
+        ALTER TABLE session_message_operation_resources
+          RENAME TO session_message_operation_resources_image_v1;
+        ALTER TABLE session_resources RENAME TO session_resources_image_v1;
+
+        CREATE TABLE session_resources (
+          id               TEXT PRIMARY KEY,
+          session_id       TEXT NOT NULL,
+          client_upload_id TEXT NOT NULL,
+          upload_id        TEXT NOT NULL UNIQUE,
+          kind             TEXT NOT NULL DEFAULT 'image' CHECK(kind IN ('image', 'file')),
+          filename         TEXT NOT NULL,
+          media_type       TEXT NOT NULL,
+          byte_length      INTEGER NOT NULL,
+          uploaded_bytes   INTEGER NOT NULL DEFAULT 0,
+          sha256           TEXT,
+          width            INTEGER,
+          height           INTEGER,
+          state            TEXT NOT NULL DEFAULT 'uploading'
+            CHECK(state IN ('uploading', 'staged', 'committed')),
+          message_item_id  TEXT,
+          created_at       INTEGER NOT NULL,
+          committed_at     INTEGER,
+          UNIQUE(session_id, client_upload_id)
+        );
+        INSERT INTO session_resources (
+          id, session_id, client_upload_id, upload_id, kind, filename, media_type,
+          byte_length, uploaded_bytes, sha256, width, height, state,
+          message_item_id, created_at, committed_at
+        )
+        SELECT
+          id, session_id, client_upload_id, upload_id, 'image', filename, media_type,
+          byte_length, uploaded_bytes, sha256, width, height, state,
+          message_item_id, created_at, committed_at
+        FROM session_resources_image_v1;
+
+        CREATE TABLE session_message_operation_resources (
+          session_id        TEXT NOT NULL,
+          client_message_id TEXT NOT NULL,
+          resource_id       TEXT NOT NULL UNIQUE REFERENCES session_resources(id) ON DELETE CASCADE,
+          PRIMARY KEY(session_id, client_message_id, resource_id),
+          FOREIGN KEY(session_id, client_message_id)
+            REFERENCES session_message_operations(session_id, client_message_id)
+            ON DELETE CASCADE
+        );
+        INSERT INTO session_message_operation_resources
+        SELECT * FROM session_message_operation_resources_image_v1;
+
+        DROP TABLE session_message_operation_resources_image_v1;
+        DROP TABLE session_resources_image_v1;
+        CREATE INDEX idx_session_resources_session
+          ON session_resources(session_id, created_at);
+        CREATE INDEX idx_session_resources_message
+          ON session_resources(message_item_id);
+      `);
+        })();
+    }
+    finally {
+        conn.exec("PRAGMA foreign_keys = ON");
+    }
 }
 /** Remove the inert permission-declaration columns left by older installations. */
 function migratePluginCapabilityDeclarations(conn) {

package/dist/plugin-host-rpc.d.ts

@@ -1,6 +1,7 @@
-import { type AdmissionReservation, type AgentSpec, type AgentCapabilities, type AgentRuntimeId, type AgentSessionStore, type ConversationRuntime, type ResolvedExecutionSnapshot, type SessionRegistry, type SessionWorkspaceSnapshot } from "@rynx-ai/core";
+import { type AdmissionReservation, type AgentSpec, type AgentCapabilities, type AgentRuntimeId, type AgentSessionStore, type ResolvedExecutionSnapshot, type RuntimeCollaborationMode, type SessionRegistry, type SessionWorkspaceSnapshot, type SteerSignal } from "@rynx-ai/core";
 import { type PluginAgentSummary, type PluginHostEvent, type PluginSessionActivitySnapshot, type PluginResolvedSessionExecution, type PluginSessionExecutionSnapshot, type PluginSessionInteractionResolveDisposition } from "@rynx-ai/plugin-sdk";
 import type { SessionInteractionResolution } from "@rynx-ai/protocol";
+import type { MachineSessionMessageInput, StartedMachineSessionRun } from "@rynx-ai/server";
 import { PluginRunnerError } from "@rynx-ai/plugin-runner";
 /** Leaves ample room for the RPC envelope below the runner's 1 MiB line cap. */
 export declare const MAX_PLUGIN_HOST_EVENT_BYTES: number;
@@ -37,7 +38,16 @@ export interface PluginHostServices {
         publicKey: string;
         sign(pluginId: string, challenge: string): string;
     };
-    conversationRuntime: ConversationRuntime;
+    sessionRuns: {
+        startRun: (sessionId: string, input: string | MachineSessionMessageInput, options?: {
+            signal?: AbortSignal;
+            steer?: SteerSignal;
+            collaborationMode?: RuntimeCollaborationMode;
+        }) => Promise<StartedMachineSessionRun>;
+    };
+    sessionFiles: {
+        resolveResourcePath(sessionId: string, resourceId: string): Promise<string>;
+    };
     capabilities: AgentCapabilities;
     sessionStore: AgentSessionStore;
     sessionRegistry: SessionRegistry;
@@ -124,6 +134,7 @@ export declare class PluginHostRpc {
     private runSession;
     private runSessionAdmitted;
     private pumpRun;
+    private projectSessionFileEvent;
     private releaseRun;
     private interruptRun;
     private sessionActivity;

package/dist/plugin-host-rpc.js

@@ -116,6 +116,10 @@ export class PluginHostRpc {
                     publicKey: this.services.installationProof.publicKey,
                 },
                 protocolVersion: 1,
+                capabilities: {
+                    sessionRunContent: true,
+                    sessionRunFiles: true,
+                },
                 ...(this.services.sessionPortal
                     ? { sessionPortal: { ...this.services.sessionPortal } }
                     : {}),
@@ -352,7 +356,14 @@ export class PluginHostRpc {
         const input = record(params);
         const sessionId = requiredSessionId(input);
         const operationId = optionalString(input.operationId, "operationId", 512);
-        const message = requiredText(input.message, "message", MAX_MESSAGE_LENGTH);
+        const hasMessage = input.message !== undefined;
+        const hasContent = input.content !== undefined;
+        if (hasMessage === hasContent) {
+            throw new PluginHostCallError("INVALID_PARAMS", "provide exactly one of message or content");
+        }
+        const message = hasMessage
+            ? requiredText(input.message, "message", MAX_MESSAGE_LENGTH)
+            : undefined;
         const collaborationMode = optionalCollaborationMode(input.collaborationMode);
         let session = this.ownedSession(sessionId);
         if (operationId) {
@@ -366,6 +377,13 @@ export class PluginHostRpc {
         }
         const active = this.activeSessionRuns.get(sessionId);
         if (active) {
+            if (hasContent) {
+                // Native steering currently accepts text only. Preserve the attachment
+                // as a new Turn after the active response reaches its terminal edge.
+                await waitForHostPromise(active.settled, signal);
+                throwIfHostCallAborted(signal);
+                return await this.runSessionAdmitted(params, signal);
+            }
             const queued = active.input.enqueue(message);
             if (!queued.accepted) {
                 // The response reached its terminal boundary before Host cleanup won
@@ -417,6 +435,7 @@ export class PluginHostRpc {
             });
             session = this.ownedSession(sessionId);
         }
+        const content = hasContent ? await pluginRunContent(input.content) : undefined;
         const abort = new AbortController();
         const cancel = () => abort.abort(signal?.reason);
         if (signal?.aborted) {
@@ -458,16 +477,20 @@ export class PluginHostRpc {
         this.activeSessionRuns.set(sessionId, run);
         if (operationId)
             this.activeRunsByOperation.set(operationId, run);
-        let startedExecution;
+        let started;
         try {
-            startedExecution = await this.services.conversationRuntime.runLive({
-                message,
-                threadId: sessionId,
-                workspace: session.workspace,
-                execution: session.execution,
+            started = await this.services.sessionRuns.startRun(sessionId, message !== undefined
+                ? {
+                    message,
+                    clientMessageId: operationId ?? `plugin_run_${runId}`,
+                }
+                : {
+                    content: content,
+                    clientMessageId: operationId ?? `plugin_run_${runId}`,
+                }, {
                 signal: abort.signal,
-                ...(collaborationMode ? { collaborationMode } : {}),
                 steer: runInput,
+                ...(collaborationMode ? { collaborationMode } : {}),
             });
         }
         catch (error) {
@@ -490,18 +513,20 @@ export class PluginHostRpc {
             throwIfHostCallAborted(signal);
             throw error;
         }
+        run.responseId = started.responseId;
         const result = {
             runId,
+            responseId: started.responseId,
             sessionId,
-            provider: startedExecution.provider,
-            model: startedExecution.model,
-            authSource: startedExecution.authSource,
+            provider: started.provider,
+            model: started.model,
+            authSource: started.authSource,
         };
         run.startupSettled = true;
         run.resolveStarted(result);
         // Let the RPC transport write the request response before stream events are
         // emitted. `runLive` has already subscribed, so no agent event is lost.
-        setImmediate(() => void this.pumpRun(run, startedExecution.generator));
+        setImmediate(() => void this.pumpRun(run, started.generator));
         return result;
     }
     async pumpRun(run, generator) {
@@ -521,6 +546,16 @@ export class PluginHostRpc {
                 for (const projected of projectSessionEvent(run, event)) {
                     await this.emit(projected);
                 }
+                try {
+                    const fileEvent = await this.projectSessionFileEvent(run, event);
+                    if (fileEvent)
+                        await this.emit(fileEvent);
+                }
+                catch {
+                    // File delivery is an optional projection of a canonical event. A
+                    // missing borrowed path must not turn an otherwise successful native
+                    // Turn into session.run.failed or stop consuming its event stream.
+                }
                 terminalFailure = sessionRunFailure(event);
                 if (terminalFailure)
                     break;
@@ -583,6 +618,44 @@ export class PluginHostRpc {
             this.releaseRun(run);
         }
     }
+    async projectSessionFileEvent(run, event) {
+        const input = jsonRecord(event);
+        if (input?.type !== "response.output_item.done")
+            return undefined;
+        const item = jsonRecord(input.item);
+        if (item?.type !== "function_call_output")
+            return undefined;
+        const data = jsonRecord(item.data);
+        const image = jsonRecord(data?.generatedImage);
+        if (!image || typeof image.mediaType !== "string")
+            return undefined;
+        let filePath;
+        if (typeof image.path === "string" && path.isAbsolute(image.path)) {
+            filePath = image.path;
+        }
+        else if (typeof image.resourceId === "string") {
+            filePath = await this.services.sessionFiles.resolveResourcePath(run.sessionId, image.resourceId);
+        }
+        else {
+            return undefined;
+        }
+        return {
+            event: "session.run.file",
+            payload: {
+                runId: run.runId,
+                responseId: typeof item.responseId === "string"
+                    ? item.responseId
+                    : run.responseId,
+                sessionId: run.sessionId,
+                itemId: typeof item.id === "string" ? item.id : "unknown",
+                filename: typeof image.filename === "string" && image.filename
+                    ? image.filename
+                    : path.basename(filePath),
+                mediaType: image.mediaType,
+                path: filePath,
+            },
+        };
+    }
     releaseRun(run) {
         run.input.close();
         if (!run.startupSettled) {
@@ -943,6 +1016,93 @@ function sessionExecutionSnapshot(value) {
 function requiredSessionId(params) {
     return requiredString(record(params).sessionId, "sessionId", 512);
 }
+async function pluginRunContent(value) {
+    if (!Array.isArray(value) || value.length === 0 || value.length > 256) {
+        throw new PluginHostCallError("INVALID_PARAMS", "content must be a non-empty array with at most 256 parts");
+    }
+    return Promise.all(value.map(async (entry, index) => {
+        const input = record(entry);
+        if (input.type === "input_text") {
+            return {
+                type: "input_text",
+                text: requiredText(input.text, `content[${index}].text`, MAX_MESSAGE_LENGTH),
+            };
+        }
+        if (input.type !== "input_image" && input.type !== "input_file") {
+            throw new PluginHostCallError("INVALID_PARAMS", `content[${index}].type is invalid`);
+        }
+        const suppliedPath = requiredPathString(input.path, `content[${index}].path`, 16_384);
+        if (!path.isAbsolute(suppliedPath)) {
+            throw new PluginHostCallError("INVALID_PARAMS", `content[${index}].path must be absolute`);
+        }
+        let resolvedPath;
+        let fileSize;
+        try {
+            resolvedPath = await realpath(suppliedPath);
+            const metadata = await stat(resolvedPath);
+            if (!metadata.isFile())
+                throw new Error("not a regular file");
+            fileSize = metadata.size;
+        }
+        catch (error) {
+            throw new PluginHostCallError("INVALID_PARAMS", `content[${index}].path is not a readable regular file: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const filename = input.type === "input_file"
+            ? requiredString(input.filename, `content[${index}].filename`, 255)
+            : optionalString(input.filename, `content[${index}].filename`, 255) ??
+                path.basename(resolvedPath);
+        if (input.type === "input_image") {
+            return {
+                type: "input_image",
+                path: resolvedPath,
+                filename,
+                mediaType: pluginImageMediaType(input.mediaType, resolvedPath, `content[${index}].mediaType`),
+                byteLength: fileSize,
+            };
+        }
+        return {
+            type: "input_file",
+            path: resolvedPath,
+            filename,
+            mediaType: pluginMediaType(input.mediaType ?? "application/octet-stream", `content[${index}].mediaType`),
+            byteLength: fileSize,
+        };
+    }));
+}
+function pluginImageMediaType(value, filePath, label) {
+    const inferred = (() => {
+        switch (path.extname(filePath).toLowerCase()) {
+            case ".png": return "image/png";
+            case ".jpg":
+            case ".jpeg": return "image/jpeg";
+            case ".webp": return "image/webp";
+            case ".gif": return "image/gif";
+            case ".svg": return "image/svg+xml";
+            default: return undefined;
+        }
+    })();
+    const mediaType = value === undefined ? inferred : pluginMediaType(value, label);
+    if (mediaType !== "image/png" &&
+        mediaType !== "image/jpeg" &&
+        mediaType !== "image/webp" &&
+        mediaType !== "image/gif" &&
+        mediaType !== "image/svg+xml") {
+        throw new PluginHostCallError("INVALID_PARAMS", `${label} is not a supported image type`);
+    }
+    return mediaType;
+}
+function pluginMediaType(value, label) {
+    if (typeof value !== "string") {
+        throw new PluginHostCallError("INVALID_PARAMS", `${label} must be a media type`);
+    }
+    const mediaType = value.trim().toLowerCase();
+    if (mediaType.length === 0 ||
+        mediaType.length > 255 ||
+        !/^[a-z0-9!#$&^_.+-]+\/[a-z0-9!#$&^_.+-]+$/.test(mediaType)) {
+        throw new PluginHostCallError("INVALID_PARAMS", `${label} is invalid`);
+    }
+    return mediaType;
+}
 function requiredSessionPortalAccess(params) {
     const access = record(params).access;
     if (access === "read_only" || access === "read_write")

package/dist/session-fork-store.d.ts

@@ -30,6 +30,7 @@ export declare class SqliteSessionForkStore implements MachineSessionForkStorePo
         items: SessionItem[];
     }): void;
     private publishTarget;
+    private publishTargetUnchecked;
     markError(operationId: string, error: string): void;
     listReserved(): MachineSessionForkOperationRecord[];
     hasReservedSource(sessionId: string): boolean;

package/dist/session-fork-store.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
-import { chmodSync, copyFileSync, existsSync, mkdirSync, } from "node:fs";
-import { join } from "node:path";
+import { chmodSync, copyFileSync, existsSync, mkdirSync, rmSync, } from "node:fs";
+import { extname, join } from "node:path";
 import { newSessionId, newSessionItemId, normalizeSessionTitle, resolvedExecutionSnapshotSchema, rynxHome, sessionWorkspaceSnapshotSchema, } from "@rynx-ai/core";
 import { MachineSessionServiceFailure, } from "@rynx-ai/server";
 import { db } from "./db.js";
@@ -94,6 +94,19 @@ export class SqliteSessionForkStore {
         this.publishTarget(input);
     }
     publishTarget(input) {
+        try {
+            this.publishTargetUnchecked(input);
+        }
+        catch (error) {
+            const published = scalar(db().prepare("SELECT 1 FROM sessions WHERE id = ?"))
+                .get(input.target.id);
+            if (!published) {
+                rmSync(this.sessionDirectory(input.target.id), { recursive: true, force: true });
+            }
+            throw error;
+        }
+    }
+    publishTargetUnchecked(input) {
         const itemIds = new Map();
         for (const item of input.items)
             itemIds.set(item.id, newSessionItemId(item.type));
@@ -152,11 +165,11 @@ export class SqliteSessionForkStore {
            source, created_at, updated_at
          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(input.target.id, JSON.stringify(sessionWorkspaceSnapshotSchema.parse(input.target.workspace)), JSON.stringify(resolvedExecutionSnapshotSchema.parse(input.target.execution)), normalizeSessionTitle(input.target.title) ?? null, input.target.forkedFromSessionId ?? null, input.target.source, input.target.createdAt, input.target.updatedAt ?? input.target.createdAt);
             const insertResource = conn.prepare(`INSERT INTO session_resources (
-           id, session_id, client_upload_id, upload_id, filename, media_type,
+           id, session_id, client_upload_id, upload_id, kind, filename, media_type,
            byte_length, uploaded_bytes, sha256, width, height, state,
            message_item_id, created_at, committed_at
          ) VALUES (
-           @id, @session_id, @client_upload_id, @upload_id, @filename, @media_type,
+           @id, @session_id, @client_upload_id, @upload_id, @kind, @filename, @media_type,
            @byte_length, @uploaded_bytes, @sha256, @width, @height, 'committed',
            @message_item_id, @created_at, @committed_at
          )`);
@@ -166,6 +179,7 @@ export class SqliteSessionForkStore {
                     session_id: resource.session_id,
                     client_upload_id: resource.client_upload_id,
                     upload_id: resource.upload_id,
+                    kind: resource.kind,
                     filename: resource.filename,
                     media_type: resource.media_type,
                     byte_length: resource.byte_length,
@@ -250,7 +264,7 @@ export class SqliteSessionForkStore {
         return join(this.resourceRoot, key);
     }
     resourcePath(row) {
-        return join(this.sessionDirectory(row.session_id), `${row.id}.${extension(row.media_type)}`);
+        return join(this.sessionDirectory(row.session_id), `${row.id}.${extension(row)}`);
     }
 }
 function toOperation(row) {
@@ -268,22 +282,40 @@ function toOperation(row) {
 function referencedResourceIds(items) {
     const ids = new Set();
     for (const item of items) {
-        if (item.type !== "message" || item.data.role !== "user")
-            continue;
-        for (const part of item.data.content) {
-            if (part.type === "input_image")
-                ids.add(part.resourceId);
+        if (item.type === "message" && item.data.role === "user") {
+            for (const part of item.data.content) {
+                if ((part.type === "input_image" || part.type === "input_file") &&
+                    typeof part.resourceId === "string")
+                    ids.add(part.resourceId);
+            }
         }
+        if (item.type === "function_call_output" &&
+            item.data.generatedImage &&
+            typeof item.data.generatedImage.resourceId === "string")
+            ids.add(item.data.generatedImage.resourceId);
     }
     return [...ids];
 }
 function remapItemResources(item, resources) {
     const cloned = structuredClone(item);
-    if (cloned.type !== "message" || cloned.data.role !== "user")
-        return cloned;
-    cloned.data.content = cloned.data.content.map((part) => part.type === "input_image"
-        ? { ...part, resourceId: resources.get(part.resourceId) ?? part.resourceId }
-        : part);
+    if (cloned.type === "message" && cloned.data.role === "user") {
+        cloned.data.content = cloned.data.content.map((part) => {
+            if ((part.type === "input_image" || part.type === "input_file") &&
+                typeof part.resourceId === "string") {
+                return { ...part, resourceId: resources.get(part.resourceId) ?? part.resourceId };
+            }
+            return part;
+        });
+    }
+    if (cloned.type === "function_call_output" &&
+        cloned.data.generatedImage &&
+        typeof cloned.data.generatedImage.resourceId === "string") {
+        const resourceId = cloned.data.generatedImage.resourceId;
+        cloned.data.generatedImage = {
+            ...cloned.data.generatedImage,
+            resourceId: resources.get(resourceId) ?? resourceId,
+        };
+    }
     return cloned;
 }
 function deterministicId(prefix, targetSessionId, sourceId) {
@@ -292,13 +324,19 @@ function deterministicId(prefix, targetSessionId, sourceId) {
         .digest("hex");
     return `${prefix}_${digest.slice(0, 40)}`;
 }
-function extension(mediaType) {
-    switch (mediaType) {
-        case "image/png":
+function extension(row) {
+    if (row.kind === "image") {
+        if (row.media_type === "image/png")
             return "png";
-        case "image/jpeg":
+        if (row.media_type === "image/jpeg")
             return "jpg";
-        case "image/webp":
+        if (row.media_type === "image/webp")
             return "webp";
+        if (row.media_type === "image/gif")
+            return "gif";
+        if (row.media_type === "image/svg+xml")
+            return "svg";
     }
+    const value = extname(row.filename).slice(1).toLowerCase();
+    return /^[a-z0-9][a-z0-9._-]{0,15}$/.test(value) ? value : "bin";
 }

package/dist/session-log-store.d.ts

@@ -14,6 +14,7 @@ export declare class SqliteSessionLogStore implements SessionLogStore {
         afterId?: string;
         limit?: number;
     }): Promise<SessionItem[]>;
+    get(sessionId: string, itemId: string): Promise<SessionItem | undefined>;
     snapshot(sessionId: string): Promise<SessionItem[]>;
     listSessions(opts?: {
         limit?: number;

package/dist/session-log-store.js

@@ -38,9 +38,18 @@ export class SqliteSessionLogStore {
                     created_by: stored.createdBy ?? null,
                     created_at: stored.createdAt,
                 });
-                if (stored.type === "message" && stored.data.role === "user") {
-                    const resourceIds = stored.data.content.flatMap((part) => part.type === "input_image" ? [part.resourceId] : []);
-                    const operationIds = new Set();
+                const resourceIds = stored.type === "message" && stored.data.role === "user"
+                    ? stored.data.content.flatMap((part) => (part.type === "input_image" || part.type === "input_file") &&
+                        "resourceId" in part && part.resourceId
+                        ? [part.resourceId]
+                        : [])
+                    : stored.type === "function_call_output" &&
+                        stored.data.generatedImage &&
+                        "resourceId" in stored.data.generatedImage &&
+                        stored.data.generatedImage.resourceId
+                        ? [stored.data.generatedImage.resourceId]
+                        : [];
+                if (resourceIds.length > 0) {
                     for (const resourceId of resourceIds) {
                         const resource = conn.prepare(`SELECT state, message_item_id
                  FROM session_resources
@@ -48,23 +57,12 @@ export class SqliteSessionLogStore {
                         if (!resource ||
                             resource.state === "uploading" ||
                             (resource.message_item_id && resource.message_item_id !== stored.id)) {
-                            throw new Error(`Session image resource ${resourceId} is not committable`);
+                            throw new Error(`Session resource ${resourceId} is not committable`);
                         }
                         conn.prepare(`UPDATE session_resources
                   SET state = 'committed', message_item_id = ?,
                       committed_at = COALESCE(committed_at, ?)
                 WHERE id = ? AND session_id = ?`).run(stored.id, stored.createdAt, resourceId, sessionId);
-                        const operation = conn.prepare(`SELECT client_message_id
-                 FROM session_message_operation_resources
-                WHERE session_id = ? AND resource_id = ?`).get(sessionId, resourceId);
-                        if (operation)
-                            operationIds.add(operation.client_message_id);
-                    }
-                    for (const clientMessageId of operationIds) {
-                        conn.prepare(`UPDATE session_message_operations
-                  SET state = 'mirrored', error = NULL, updated_at = ?
-                WHERE session_id = ? AND client_message_id = ?
-                  AND state IN ('injecting', 'injected', 'outcome_unknown')`).run(stored.createdAt, sessionId, clientMessageId);
                     }
                 }
                 return stored;
@@ -93,6 +91,10 @@ export class SqliteSessionLogStore {
             .all(sessionId, afterPosition, limit);
         return rows.map(toItem);
     }
+    async get(sessionId, itemId) {
+        const row = db().prepare("SELECT * FROM session_items WHERE session_id = ? AND id = ?").get(sessionId, itemId);
+        return row ? toItem(row) : undefined;
+    }
     async snapshot(sessionId) {
         const rows = db()
             .prepare("SELECT * FROM session_items WHERE session_id = ? ORDER BY position ASC")