@rynx-ai/daemon 0.1.11-beta.4 → 0.1.11-beta.41

package/dist/session-launch-operations.js

@@ -1,5 +1,6 @@
 import { newSessionId } from "@rynx-ai/core";
 import { db } from "./db.js";
+import { scalar, transaction } from "./sqlite.js";
 import { createSessionMeta } from "./session-meta-store.js";
 const MAX_ID_LENGTH = 512;
 const SHA256_PATTERN = /^[a-fA-F0-9]{64}$/;
@@ -58,7 +59,7 @@ export function replayPluginSessionLaunch(input) {
         throw new SessionLaunchOperationTargetDeletedError(pluginId, scopeId, operationId, existing.session_id);
     }
     if (!sessionExists(existing.session_id)) {
-        db().transaction(() => {
+        transaction(db(), () => {
             tombstoneOperations(existing.session_id, new Date().toISOString());
         }).immediate();
         throw new SessionLaunchOperationTargetDeletedError(pluginId, scopeId, operationId, existing.session_id);
@@ -81,7 +82,7 @@ export function ensurePluginSessionLaunch(input) {
     const rawRequestHash = input.rawRequestHash
         ? requiredRequestHash(input.rawRequestHash)
         : requestHash;
-    const ensure = db().transaction(() => {
+    const ensure = transaction(db(), () => {
         const existing = readOperation(pluginId, scopeId, operationId);
         if (existing) {
             if (existing.request_hash !== requestHash &&
@@ -139,14 +140,14 @@ function readOperation(pluginId, scopeId, operationId) {
         .get(pluginId, scopeId, operationId);
 }
 function sessionExists(sessionId) {
-    return Boolean(db().prepare("SELECT 1 FROM sessions WHERE id = ?").pluck().get(sessionId));
+    return Boolean(scalar(db().prepare("SELECT 1 FROM sessions WHERE id = ?")).get(sessionId));
 }
 function tombstoneOperations(sessionId, now) {
-    return db()
+    return Number(db()
         .prepare(`UPDATE plugin_session_launch_operations
        SET state = 'deleted', updated_at = ?, deleted_at = ?
        WHERE session_id = ? AND state = 'active'`)
-        .run(now, now, sessionId).changes;
+        .run(now, now, sessionId).changes);
 }
 function requiredId(value, label) {
     const normalized = value?.trim();

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

@@ -1,4 +1,6 @@
+import { SessionLogAppendError } from "@rynx-ai/core";
 import { db } from "./db.js";
+import { hasSqlitePrimaryCode, SQLITE_CONSTRAINT, transaction } from "./sqlite.js";
 function toItem(row) {
     return {
         id: row.id,
@@ -8,6 +10,9 @@ function toItem(row) {
         status: row.status,
         createdAt: row.created_at,
         ...(row.created_by ? { createdBy: row.created_by } : {}),
+        ...(row.parent_tool_call_id
+            ? { parentToolCallId: row.parent_tool_call_id }
+            : {}),
         type: row.type,
         data: JSON.parse(row.data),
     };
@@ -18,10 +23,12 @@ export class SqliteSessionLogStore {
             return [];
         const conn = db();
         const insert = conn.prepare(`INSERT INTO session_items
-         (id, session_id, position, response_id, type, status, data, created_by, created_at)
-       VALUES (@id, @session_id, @position, @response_id, @type, @status, @data, @created_by, @created_at)`);
+         (id, session_id, position, response_id, type, status, data, created_by,
+          parent_tool_call_id, created_at)
+       VALUES (@id, @session_id, @position, @response_id, @type, @status, @data,
+               @created_by, @parent_tool_call_id, @created_at)`);
         const maxStmt = conn.prepare("SELECT MAX(position) AS max FROM session_items WHERE session_id = ?");
-        const tx = conn.transaction((batch) => {
+        const tx = transaction(conn, (batch) => {
             const { max } = maxStmt.get(sessionId);
             let next = (max ?? -1) + 1;
             return batch.map((item) => {
@@ -35,41 +42,54 @@ export class SqliteSessionLogStore {
                     status: stored.status,
                     data: JSON.stringify(stored.data),
                     created_by: stored.createdBy ?? null,
+                    parent_tool_call_id: stored.parentToolCallId ?? 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
                 WHERE id = ? AND session_id = ?`).get(resourceId, sessionId);
-                        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`);
+                        if (!resource) {
+                            throw new SessionLogAppendError(`Session resource ${resourceId} does not exist`, 422, "session_resource_missing");
+                        }
+                        if (resource.state === "uploading") {
+                            throw new SessionLogAppendError(`Session resource ${resourceId} is still uploading`, 409, "session_resource_not_ready");
+                        }
+                        if (resource.message_item_id && resource.message_item_id !== stored.id) {
+                            throw new SessionLogAppendError(`Session resource ${resourceId} is already committed to another item`, 422, "session_resource_already_committed");
                         }
                         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;
             });
         });
-        return tx(items);
+        try {
+            return tx(items);
+        }
+        catch (error) {
+            if (error instanceof SessionLogAppendError)
+                throw error;
+            if (hasSqlitePrimaryCode(error, SQLITE_CONSTRAINT)) {
+                throw new SessionLogAppendError(error instanceof Error ? error.message : "Session log constraint rejected the item", 422, "session_log_constraint", { cause: error });
+            }
+            throw error;
+        }
     }
     async list(sessionId, opts = {}) {
         const conn = db();
@@ -92,6 +112,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")

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

@@ -18,6 +18,11 @@ export declare function listSessionMetas(): StoredSessionMeta[];
 export declare function getSessionMeta(id: string): StoredSessionMeta | undefined;
 export declare function createSessionMeta(meta: StoredSessionMeta): void;
 export declare function setSessionTitle(id: string, title: string): void;
+export declare function setSessionExecution(id: string, execution: MachineSessionRecord["execution"]): void;
 export declare function removeSessionMeta(id: string): void;
 /** {@link SessionRegistry} over the same `sessions` table. */
 export declare const sessionRegistry: SessionRegistry;
+/** Generic plugin-principal ownership, including descendants forked from a
+ * plugin-created Session. Portal authorization calls this on every request so
+ * a grant cannot cross into console or another plugin's Sessions. */
+export declare function sessionBelongsToPlugin(pluginId: string, sessionId: string): boolean;

package/dist/session-meta-store.js

@@ -13,6 +13,7 @@
  */
 import { normalizeSessionTitle, resolvedExecutionSnapshotSchema, sessionWorkspaceSnapshotSchema, } from "@rynx-ai/core";
 import { db } from "./db.js";
+import { transaction } from "./sqlite.js";
 const COLS = "id, workspace, execution, title, forked_from_session_id, source, created_at, updated_at";
 export function listSessionMetas() {
     return db()
@@ -46,10 +47,15 @@ export function createSessionMeta(meta) {
 export function setSessionTitle(id, title) {
     db()
         .prepare("UPDATE sessions SET title = ?, updated_at = ? WHERE id = ?")
-        .run(normalizeSessionTitle(title), new Date().toISOString(), id);
+        .run(normalizeSessionTitle(title) ?? null, new Date().toISOString(), id);
+}
+export function setSessionExecution(id, execution) {
+    db()
+        .prepare("UPDATE sessions SET execution = ?, updated_at = ? WHERE id = ?")
+        .run(JSON.stringify(resolvedExecutionSnapshotSchema.parse(execution)), new Date().toISOString(), id);
 }
 export function removeSessionMeta(id) {
-    db().transaction(() => {
+    transaction(db(), () => {
         const now = new Date().toISOString();
         db()
             .prepare(`UPDATE plugin_session_launch_operations
@@ -70,8 +76,25 @@ export const sessionRegistry = {
     get: getSessionMeta,
     list: listSessionMetas,
     setTitle: setSessionTitle,
+    setExecution: setSessionExecution,
     remove: removeSessionMeta,
 };
+/** Generic plugin-principal ownership, including descendants forked from a
+ * plugin-created Session. Portal authorization calls this on every request so
+ * a grant cannot cross into console or another plugin's Sessions. */
+export function sessionBelongsToPlugin(pluginId, sessionId) {
+    const seen = new Set();
+    let current = sessionRegistry.get(sessionId);
+    while (current && !seen.has(current.id)) {
+        if (current.source === `plugin:${pluginId}`)
+            return true;
+        seen.add(current.id);
+        current = current.forkedFromSessionId
+            ? sessionRegistry.get(current.forkedFromSessionId)
+            : undefined;
+    }
+    return false;
+}
 function rowToMeta(row) {
     return {
         id: row.id,

package/dist/session-portal-grant-store.d.ts

@@ -0,0 +1,55 @@
+export type SessionPortalScope = "plugin_sessions" | "single_session";
+export type SessionPortalAccess = "read_only" | "read_write";
+export interface SessionPortalAuthorization {
+    portalId: string;
+    pluginId: string;
+    scope: SessionPortalScope;
+    access: SessionPortalAccess;
+    embedOrigin?: string;
+    sessionId?: string;
+    expiresAt: string;
+}
+/** Issue a browser handoff into the native Session workbench. The Host knows
+ * only the generic Session scope and access level; product/user policy stays in
+ * the plugin that asks for the ticket. */
+export declare function issueSessionPortalTicket(input: {
+    pluginId: string;
+    scope: SessionPortalScope;
+    access: SessionPortalAccess;
+    sessionId?: string;
+    embedOrigin?: string;
+    grantHandle?: string;
+    now?: Date;
+}): {
+    path: string;
+    expiresAt: string;
+    grantHandle: string;
+};
+/** Atomically consume a one-use ticket and mint a fixed-lifetime browser grant. */
+export declare function redeemSessionPortalTicket(ticket: string, now?: Date, embedOrigin?: string): (SessionPortalAuthorization & {
+    secret: string;
+}) | undefined;
+/** Read the public, still-active half of a grant without accepting its secret.
+ * Used only to bind an embedded SPA bootstrap and transport lifecycle to the
+ * exact grant that was issued; it does not authorize an API call. */
+export declare function inspectSessionPortalGrant(portalId: string, now?: Date): SessionPortalAuthorization | undefined;
+export declare function authorizeSessionPortalGrant(portalId: string, secret: string, now?: Date): SessionPortalAuthorization | undefined;
+/** Revoke one issued Portal link, whether its ticket is still unused or it has
+ * already become a browser grant. The opaque handle carries no product meaning. */
+export declare function revokeSessionPortalGrant(input: {
+    pluginId: string;
+    grantHandle: string;
+    now?: Date;
+}): Promise<{
+    revoked: boolean;
+}>;
+/** Subscribe to committed grant revocations. The notification is emitted only
+ * after SQLite commits, so a listener may synchronously tear down every
+ * transport admitted under the revoked portal id. */
+export declare function onSessionPortalGrantRevoked(listener: (portalIds: readonly string[]) => void | Promise<void>): () => void;
+/** Embedded writable grants are process-generation capabilities. A daemon
+ * restart has no surviving transport to drain and Plugin recovery may fail, so
+ * fail closed before the Portal listener is reopened; ordinary non-embedded
+ * Portal links retain their historical fixed-lifetime behavior. */
+export declare function revokeEmbeddedWritableSessionPortalGrants(now?: Date): void;
+export declare function pruneSessionPortalAuthorization(now?: Date): void;

package/dist/session-portal-grant-store.js

@@ -0,0 +1,160 @@
+import { createHash, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
+import { db } from "./db.js";
+import { transaction } from "./sqlite.js";
+const TICKET_TTL_MS = 5 * 60 * 1_000;
+const GRANT_TTL_MS = 30 * 60 * 1_000;
+const revocationListeners = new Set();
+/** Issue a browser handoff into the native Session workbench. The Host knows
+ * only the generic Session scope and access level; product/user policy stays in
+ * the plugin that asks for the ticket. */
+export function issueSessionPortalTicket(input) {
+    if ((input.scope === "single_session") !== Boolean(input.sessionId)) {
+        throw new Error("single_session Portal tickets require exactly one Session id");
+    }
+    const now = input.now ?? new Date();
+    const expiresAt = new Date(now.getTime() + TICKET_TTL_MS).toISOString();
+    const ticket = randomToken();
+    const grantHandle = input.grantHandle ?? randomUUID();
+    pruneSessionPortalAuthorization(now);
+    db().prepare(`INSERT INTO session_portal_tickets
+       (ticket_hash, plugin_id, scope, access, session_id, created_at, expires_at, used_at,
+        grant_handle, embed_origin)
+     VALUES (?, ?, ?, ?, ?, ?, ?, NULL, ?, ?)`).run(hash(ticket), input.pluginId, input.scope, input.access, input.sessionId ?? null, now.toISOString(), expiresAt, grantHandle, input.embedOrigin ?? null);
+    const redeem = new URL("/session-portal/redeem", "http://session-portal.invalid");
+    if (input.embedOrigin)
+        redeem.searchParams.set("embed_origin", input.embedOrigin);
+    return {
+        path: `${redeem.pathname}${redeem.search}#ticket=${encodeURIComponent(ticket)}`,
+        expiresAt,
+        grantHandle,
+    };
+}
+/** Atomically consume a one-use ticket and mint a fixed-lifetime browser grant. */
+export function redeemSessionPortalTicket(ticket, now = new Date(), embedOrigin) {
+    const connection = db();
+    return transaction(connection, () => {
+        const ticketHash = hash(ticket);
+        const row = connection.prepare(`SELECT plugin_id, scope, access, session_id, expires_at, used_at,
+              grant_handle, embed_origin
+         FROM session_portal_tickets
+        WHERE ticket_hash = ?`).get(ticketHash);
+        if (!row ||
+            row.used_at !== null ||
+            row.expires_at <= now.toISOString() ||
+            (row.embed_origin ?? "") !== (embedOrigin ?? ""))
+            return undefined;
+        const consumed = connection.prepare(`UPDATE session_portal_tickets SET used_at = ?
+        WHERE ticket_hash = ? AND used_at IS NULL AND expires_at > ?`).run(now.toISOString(), ticketHash, now.toISOString());
+        if (consumed.changes !== 1)
+            return undefined;
+        const portalId = randomUUID();
+        const secret = randomToken();
+        const expiresAt = new Date(now.getTime() + GRANT_TTL_MS).toISOString();
+        connection.prepare(`INSERT INTO session_portal_grants
+         (portal_id, secret_hash, plugin_id, scope, access, session_id, created_at, expires_at,
+          revoked_at, grant_handle, embed_origin)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?)`).run(portalId, hash(secret), row.plugin_id, row.scope, row.access, row.session_id, now.toISOString(), expiresAt, row.grant_handle, row.embed_origin);
+        return {
+            portalId,
+            secret,
+            pluginId: row.plugin_id,
+            scope: row.scope,
+            access: row.access,
+            ...(row.embed_origin ? { embedOrigin: row.embed_origin } : {}),
+            ...(row.session_id ? { sessionId: row.session_id } : {}),
+            expiresAt,
+        };
+    })();
+}
+/** Read the public, still-active half of a grant without accepting its secret.
+ * Used only to bind an embedded SPA bootstrap and transport lifecycle to the
+ * exact grant that was issued; it does not authorize an API call. */
+export function inspectSessionPortalGrant(portalId, now = new Date()) {
+    const row = db().prepare(`SELECT portal_id, secret_hash, plugin_id, scope, access, session_id, expires_at, revoked_at,
+            grant_handle, embed_origin
+       FROM session_portal_grants
+      WHERE portal_id = ?`).get(portalId);
+    if (!row || row.revoked_at !== null || row.expires_at <= now.toISOString())
+        return undefined;
+    return publicGrant(row);
+}
+export function authorizeSessionPortalGrant(portalId, secret, now = new Date()) {
+    const row = db().prepare(`SELECT portal_id, secret_hash, plugin_id, scope, access, session_id, expires_at, revoked_at,
+            grant_handle, embed_origin
+       FROM session_portal_grants
+      WHERE portal_id = ?`).get(portalId);
+    if (!row || row.revoked_at !== null || row.expires_at <= now.toISOString())
+        return undefined;
+    const actual = Buffer.from(hash(secret), "hex");
+    const expected = Buffer.from(row.secret_hash, "hex");
+    if (actual.length !== expected.length || !timingSafeEqual(actual, expected))
+        return undefined;
+    return publicGrant(row);
+}
+/** Revoke one issued Portal link, whether its ticket is still unused or it has
+ * already become a browser grant. The opaque handle carries no product meaning. */
+export async function revokeSessionPortalGrant(input) {
+    const now = input.now ?? new Date();
+    const connection = db();
+    const result = transaction(connection, () => {
+        const portalIds = connection.prepare(`SELECT portal_id FROM session_portal_grants
+        WHERE plugin_id = ? AND grant_handle = ? AND revoked_at IS NULL`).all(input.pluginId, input.grantHandle);
+        const tickets = connection.prepare(`UPDATE session_portal_tickets SET used_at = ?
+        WHERE plugin_id = ? AND grant_handle = ? AND used_at IS NULL`).run(now.toISOString(), input.pluginId, input.grantHandle);
+        const grants = connection.prepare(`UPDATE session_portal_grants SET revoked_at = ?
+        WHERE plugin_id = ? AND grant_handle = ? AND revoked_at IS NULL`).run(now.toISOString(), input.pluginId, input.grantHandle);
+        return {
+            revoked: tickets.changes > 0 || grants.changes > 0,
+            portalIds: portalIds.map((row) => row.portal_id),
+        };
+    })();
+    if (result.portalIds.length > 0) {
+        // Revocation is a barrier, not merely a database flag. Host RPC returns
+        // only after every Portal transport admitted under the committed grant has
+        // been aborted and drained.
+        await Promise.all([...revocationListeners].map((listener) => listener(result.portalIds)));
+    }
+    return { revoked: result.revoked };
+}
+/** Subscribe to committed grant revocations. The notification is emitted only
+ * after SQLite commits, so a listener may synchronously tear down every
+ * transport admitted under the revoked portal id. */
+export function onSessionPortalGrantRevoked(listener) {
+    revocationListeners.add(listener);
+    return () => revocationListeners.delete(listener);
+}
+/** Embedded writable grants are process-generation capabilities. A daemon
+ * restart has no surviving transport to drain and Plugin recovery may fail, so
+ * fail closed before the Portal listener is reopened; ordinary non-embedded
+ * Portal links retain their historical fixed-lifetime behavior. */
+export function revokeEmbeddedWritableSessionPortalGrants(now = new Date()) {
+    const connection = db();
+    transaction(connection, () => {
+        connection.prepare(`UPDATE session_portal_tickets SET used_at=?
+        WHERE access='read_write' AND embed_origin IS NOT NULL AND used_at IS NULL`).run(now.toISOString());
+        connection.prepare(`UPDATE session_portal_grants SET revoked_at=?
+        WHERE access='read_write' AND embed_origin IS NOT NULL AND revoked_at IS NULL`).run(now.toISOString());
+    })();
+}
+export function pruneSessionPortalAuthorization(now = new Date()) {
+    const connection = db();
+    connection.prepare("DELETE FROM session_portal_tickets WHERE expires_at <= ? OR used_at IS NOT NULL").run(now.toISOString());
+    connection.prepare("DELETE FROM session_portal_grants WHERE expires_at <= ? OR revoked_at IS NOT NULL").run(now.toISOString());
+}
+function randomToken() {
+    return randomBytes(32).toString("base64url");
+}
+function hash(value) {
+    return createHash("sha256").update(value, "utf8").digest("hex");
+}
+function publicGrant(row) {
+    return {
+        portalId: row.portal_id,
+        pluginId: row.plugin_id,
+        scope: row.scope,
+        access: row.access,
+        ...(row.embed_origin ? { embedOrigin: row.embed_origin } : {}),
+        ...(row.session_id ? { sessionId: row.session_id } : {}),
+        expiresAt: row.expires_at,
+    };
+}

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

@@ -1,6 +1,6 @@
-import { type UserContentPart } from "@rynx-ai/core";
+import { type SessionImageFileReference, type UserContentPart } from "@rynx-ai/core";
 import { type RemoteRuntimeSessionResourceDeleteParams, type RemoteRuntimeSessionResourceDeleteResult, type RemoteRuntimeSessionResourceGetParams, type RemoteRuntimeSessionResourceGetResult, type RemoteRuntimeSessionResourcePolicyResult, type RemoteRuntimeSessionResourceReadParams, type RemoteRuntimeSessionResourceReadResult, type RemoteRuntimeSessionResourceUploadBeginParams, type RemoteRuntimeSessionResourceUploadBeginResult, type RemoteRuntimeSessionResourceUploadChunkParams, type RemoteRuntimeSessionResourceUploadChunkResult, type RemoteRuntimeSessionResourceUploadCommitParams, type RemoteRuntimeSessionResourceUploadCommitResult } from "@rynx-ai/protocol/remote-runtime-rpc";
-import { type MachineSessionPreparedInput, type MachineSessionResourcePort } from "@rynx-ai/server";
+import { type MachineSessionPreparedInput, type MachineSessionResourcePort, type MachineSessionRunExecutionSelection, type MachineSessionRunExecutionSnapshot } from "@rynx-ai/server";
 export declare class SqliteSessionResourceStore implements MachineSessionResourcePort {
     private readonly root;
     constructor(root?: string);
@@ -9,18 +9,36 @@ export declare class SqliteSessionResourceStore implements MachineSessionResourc
     writeUploadChunk(input: RemoteRuntimeSessionResourceUploadChunkParams): Promise<RemoteRuntimeSessionResourceUploadChunkResult>;
     commitUpload(input: RemoteRuntimeSessionResourceUploadCommitParams): Promise<RemoteRuntimeSessionResourceUploadCommitResult>;
     getResource(input: RemoteRuntimeSessionResourceGetParams): Promise<RemoteRuntimeSessionResourceGetResult>;
+    resolveCommittedLocalPath(sessionId: string, resourceId: string): string;
     readResource(input: RemoteRuntimeSessionResourceReadParams): Promise<RemoteRuntimeSessionResourceReadResult>;
     deleteResource(input: RemoteRuntimeSessionResourceDeleteParams): Promise<RemoteRuntimeSessionResourceDeleteResult>;
-    prepareInput(sessionId: string, content: UserContentPart[], clientMessageId?: string): Promise<MachineSessionPreparedInput>;
-    markMessageInjecting(sessionId: string, clientMessageId: string): void;
-    markMessageInjected(sessionId: string, clientMessageId: string): void;
+    materializeGeneratedImage(input: {
+        sessionId: string;
+        sourceId: string;
+        result: string;
+    }): Promise<SessionImageFileReference>;
+    prepareInput(sessionId: string, content: UserContentPart[], clientMessageId?: string, operationExecution?: {
+        selection: MachineSessionRunExecutionSelection;
+        snapshot: MachineSessionRunExecutionSnapshot;
+    }): Promise<MachineSessionPreparedInput>;
+    markMessageInjecting(sessionId: string, clientMessageId: string, identity?: {
+        responseId: string;
+        messageItemId: string;
+    }): void;
+    markMessageInjected(sessionId: string, clientMessageId: string, identity?: {
+        responseId: string;
+    }): void;
+    markMessageMirrored(sessionId: string, clientMessageId: string, identity: {
+        responseId: string;
+        messageItemId: string;
+    }): void;
     markMessageOutcomeUnknown(sessionId: string, clientMessageId: string, reason: string): void;
     markMessageFailedNotStarted(sessionId: string, clientMessageId: string, reason: string): void;
     deleteSession(sessionId: string): void;
     private prepareMessageOperation;
     private bindOperationResources;
     private transitionOperation;
-    private finalizeUpload;
+    private finalizeStoredFile;
     private reconcileUploadOffset;
     private rowByUpload;
     private requireUpload;