@dinoxx/dinox-cli 2.2.0 → 2.4.0

package/dist/vendor/electron/shared/powersync-read-models.js

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

package/dist/vendor/electron/shared/remote-device-agent.d.ts

@@ -0,0 +1,373 @@
+import type { ChatUIMessage } from "./external-types.js";
+import type { ThreadRunCreateThreadRequest, ThreadRunEventStatus, ThreadRunUsageSnapshot } from "./external-types.js";
+export declare const REMOTE_DEVICE_PROTOCOL_VERSION: 2;
+export declare const REMOTE_DEVICE_PROTOCOL_NAME: "dinox.remote-device.v2";
+export declare const REMOTE_DEVICE_PROTOCOL_CONTRACT: {
+    readonly version: 2;
+    readonly name: "dinox.remote-device.v2";
+    readonly messageTypes: readonly ["device.discover", "device.discovered", "device.presence", "device.info", "device.info.result", "skills.list", "skills.list.result", "workspace.list", "workspace.list.result", "workspace.file.read", "workspace.file.read.result", "query.cancel", "run.request", "run.ack", "run.status", "run.status.result", "run.cancel", "run.cancel.ack", "tool.approval.respond", "tool.approval.ack", "run.event"];
+    readonly ackCodes: readonly ["accepted", "attachment_unavailable", "busy", "delivery_unknown", "disabled", "invalid_request", "thread_not_found", "enqueue_failed"];
+    readonly subjectActions: readonly ["request", "cancel", "info", "query", "query-cancel", "approve"];
+    readonly messageFields: {
+        readonly "device.discover": "requestId,clientDeviceId";
+        readonly "device.discovered": "requestId,device";
+        readonly "device.presence": "status,sequence,emittedAt,device";
+        readonly "device.info": "requestId";
+        readonly "device.info.result": "requestId,device";
+        readonly "skills.list": "requestId,clientDeviceId,threadId;projectId,deadlineAt";
+        readonly "skills.list.result": "requestId,threadId,ok,skills,fetchedAt;error";
+        readonly "workspace.list": "requestId,clientDeviceId,threadId;parentPath,cursor,limit,deadlineAt";
+        readonly "workspace.list.result": "requestId,threadId,parentPath,ok,entries,nextCursor,truncated,fetchedAt;error";
+        readonly "workspace.file.read": "requestId,clientDeviceId,threadId,path;deadlineAt";
+        readonly "workspace.file.read.result": "requestId,threadId,path,ok,preview,size,fetchedAt;modifiedAt,error";
+        readonly "query.cancel": "requestId,clientDeviceId,queryRequestId";
+        readonly "run.request": "requestId,runId,threadId,clientDeviceId,createdAt,prompt,userMessage,assistantMessage;parentMessageId,createThread";
+        readonly "run.ack": "requestId,runId,threadId,accepted,code;status,error";
+        readonly "run.status": "requestId,runId,threadId,clientDeviceId";
+        readonly "run.status.result": "requestId,runId,threadId,found;status,updatedAt,assistant,pendingApprovals,error";
+        readonly "run.cancel": "requestId,runId,threadId,clientDeviceId";
+        readonly "run.cancel.ack": "requestId,runId,threadId,cancelled;error";
+        readonly "tool.approval.respond": "requestId,clientDeviceId,runId,threadId,approvalId,approved;reason";
+        readonly "tool.approval.ack": "requestId,runId,threadId,approvalId,accepted,code;status,pendingApprovals,error";
+        readonly "run.event": "runId,threadId,sequence,emittedAt,revision,status,assistant;pendingApprovals,usage";
+    };
+};
+export declare const REMOTE_DEVICE_PRESENCE_INTERVAL_MS = 15000;
+export declare const REMOTE_DEVICE_PRESENCE_TTL_MS = 45000;
+export declare const REMOTE_DEVICE_REQUEST_TIMEOUT_MS = 5000;
+export declare const REMOTE_DEVICE_MAX_EVENT_BYTES = 900000;
+export declare const REMOTE_WORKSPACE_FILE_PREVIEW_MAX_BYTES: number;
+export declare const REMOTE_WORKSPACE_PREVIEW_RETENTION_MS: number;
+export type RemoteDeviceConnectionStatus = "disabled" | "signed_out" | "connecting" | "connected" | "reconnecting" | "error";
+export interface RemoteDeviceCapabilities {
+    threadRun: true;
+    cancel: true;
+    stream: "assistant-snapshot";
+    toolApproval: "desktop";
+    remoteToolApproval?: {
+        respond: true;
+        decisions: readonly ["approve_once", "deny"];
+        recovery: "run-status";
+    };
+    skills?: {
+        list: true;
+        explicitSelection: true;
+        maxSelected: number;
+    };
+    workspace?: {
+        list: true;
+        scope: "thread";
+        filePreview: false | {
+            read: true;
+            maxBytes: number;
+            kinds: readonly ["text", "image"];
+            delivery: "signed-url";
+        };
+    };
+}
+export interface RemoteDeviceInfo {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    protocol: typeof REMOTE_DEVICE_PROTOCOL_NAME;
+    deviceId: string;
+    deviceName: string;
+    platform: string;
+    appVersion: string;
+    connectedAt: string;
+    busyThreadIds: string[];
+    capabilities: RemoteDeviceCapabilities;
+}
+export interface RemoteDeviceDiscoverRequest {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: "device.discover";
+    requestId: string;
+    clientDeviceId: string;
+}
+export interface RemoteDeviceDiscoverResponse {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: "device.discovered";
+    requestId: string;
+    device: RemoteDeviceInfo;
+}
+export interface RemoteDevicePresenceEvent {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: "device.presence";
+    status: "online" | "offline";
+    sequence: number;
+    emittedAt: string;
+    device: RemoteDeviceInfo;
+}
+export interface RemoteDeviceInfoRequest {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: "device.info";
+    requestId: string;
+}
+export interface RemoteDeviceInfoResponse {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: "device.info.result";
+    requestId: string;
+    device: RemoteDeviceInfo;
+}
+export type RemoteDeviceQueryErrorCode = "invalid_request" | "thread_not_found" | "unsupported" | "file_too_large" | "not_previewable" | "query_failed";
+export interface RemoteDeviceQueryError {
+    code: RemoteDeviceQueryErrorCode;
+    message: string;
+}
+export interface RemoteDeviceSkillSummary {
+    skillKey: string;
+    name: string;
+    description: string;
+}
+export interface RemoteDeviceSkillsListRequest {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: "skills.list";
+    requestId: string;
+    clientDeviceId: string;
+    threadId: string;
+    projectId?: string | null;
+    deadlineAt?: string;
+}
+export interface RemoteDeviceSkillsListResponse {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: "skills.list.result";
+    requestId: string;
+    threadId: string;
+    ok: boolean;
+    skills: RemoteDeviceSkillSummary[];
+    fetchedAt: string;
+    error?: RemoteDeviceQueryError;
+}
+export type RemoteWorkspaceEntryKind = "directory" | "file" | "symlink";
+export interface RemoteWorkspaceEntry {
+    path: string;
+    name: string;
+    kind: RemoteWorkspaceEntryKind;
+    hasChildren: boolean;
+    size?: number;
+    modifiedAt?: string;
+}
+export interface RemoteDeviceWorkspaceListRequest {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: "workspace.list";
+    requestId: string;
+    clientDeviceId: string;
+    threadId: string;
+    parentPath?: string;
+    cursor?: string | null;
+    limit?: number;
+    deadlineAt?: string;
+}
+export interface RemoteDeviceWorkspaceListResponse {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: "workspace.list.result";
+    requestId: string;
+    threadId: string;
+    parentPath: string;
+    ok: boolean;
+    entries: RemoteWorkspaceEntry[];
+    nextCursor: string | null;
+    truncated: boolean;
+    fetchedAt: string;
+    error?: RemoteDeviceQueryError;
+}
+export interface RemoteDeviceWorkspaceFileReadRequest {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: "workspace.file.read";
+    requestId: string;
+    clientDeviceId: string;
+    threadId: string;
+    path: string;
+    deadlineAt?: string;
+}
+export interface RemoteDeviceQueryCancelRequest {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: "query.cancel";
+    requestId: string;
+    clientDeviceId: string;
+    queryRequestId: string;
+}
+export type RemoteWorkspaceImageMediaType = "image/png" | "image/jpeg" | "image/gif" | "image/webp";
+export type RemoteWorkspaceFilePreview = {
+    kind: "text";
+    mediaType: "text/plain";
+    delivery: "signed-url";
+    downloadUrl: string;
+} | {
+    kind: "image";
+    mediaType: RemoteWorkspaceImageMediaType;
+    delivery: "signed-url";
+    downloadUrl: string;
+};
+export interface RemoteDeviceWorkspaceFileReadResponse {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: "workspace.file.read.result";
+    requestId: string;
+    threadId: string;
+    path: string;
+    ok: boolean;
+    preview: RemoteWorkspaceFilePreview | null;
+    size: number | null;
+    modifiedAt?: string;
+    fetchedAt: string;
+    error?: RemoteDeviceQueryError;
+}
+export type RemoteDeviceQueryRequest = RemoteDeviceSkillsListRequest | RemoteDeviceWorkspaceListRequest | RemoteDeviceWorkspaceFileReadRequest;
+export type RemoteDeviceQueryResponse = RemoteDeviceSkillsListResponse | RemoteDeviceWorkspaceListResponse | RemoteDeviceWorkspaceFileReadResponse;
+export interface RemoteDeviceRunRequest {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: "run.request";
+    requestId: string;
+    runId: string;
+    threadId: string;
+    clientDeviceId: string;
+    createdAt: string;
+    prompt: string;
+    userMessage: ChatUIMessage;
+    assistantMessage: ChatUIMessage;
+    parentMessageId?: string | null;
+    createThread?: ThreadRunCreateThreadRequest | null;
+}
+export type RemoteDeviceRunAckCode = "accepted" | "attachment_unavailable" | "busy" | "delivery_unknown" | "disabled" | "invalid_request" | "thread_not_found" | "enqueue_failed";
+export interface RemoteDeviceRunAck {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: "run.ack";
+    requestId: string;
+    runId: string;
+    threadId: string;
+    accepted: boolean;
+    code: RemoteDeviceRunAckCode;
+    threadDisposition?: RemoteDeviceThreadDisposition;
+    status?: ThreadRunEventStatus;
+    error?: string;
+}
+export type RemoteDeviceThreadDisposition = "created_desktop_local" | "already_present_desktop_local";
+export interface RemoteDeviceRunStatusRequest {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: "run.status";
+    requestId: string;
+    runId: string;
+    threadId: string;
+    clientDeviceId: string;
+}
+export interface RemoteDeviceRunStatusResponse {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: "run.status.result";
+    requestId: string;
+    runId: string;
+    threadId: string;
+    found: boolean;
+    status?: ThreadRunEventStatus;
+    updatedAt?: string;
+    assistant?: RemoteDeviceAssistantSnapshot;
+    pendingApprovals?: RemoteToolApprovalPrompt[];
+    error?: string;
+}
+export interface RemoteToolApprovalPrompt {
+    approvalId: string;
+    runId: string;
+    threadId: string;
+    toolCallId: string;
+    toolName: string;
+    inputPreview: string;
+    requestedAt: string;
+    expiresAt: string;
+}
+export interface RemoteDeviceToolApprovalRequest {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: "tool.approval.respond";
+    requestId: string;
+    clientDeviceId: string;
+    runId: string;
+    threadId: string;
+    approvalId: string;
+    approved: boolean;
+    reason?: string;
+}
+export type RemoteDeviceToolApprovalAckCode = "applied" | "already_applied" | "invalid_request" | "stale" | "failed";
+export interface RemoteDeviceToolApprovalAck {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: "tool.approval.ack";
+    requestId: string;
+    runId: string;
+    threadId: string;
+    approvalId: string;
+    accepted: boolean;
+    code: RemoteDeviceToolApprovalAckCode;
+    status?: ThreadRunEventStatus;
+    pendingApprovals?: RemoteToolApprovalPrompt[];
+    error?: string;
+}
+export interface RemoteDeviceCancelRequest {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: "run.cancel";
+    requestId: string;
+    runId: string;
+    threadId: string;
+    clientDeviceId: string;
+}
+export interface RemoteDeviceCancelAck {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: "run.cancel.ack";
+    requestId: string;
+    runId: string;
+    threadId: string;
+    cancelled: boolean;
+    error?: string;
+}
+export interface RemoteDeviceAssistantSnapshot {
+    message: ChatUIMessage;
+    truncated?: boolean;
+}
+export interface RemoteDeviceRunStreamEvent {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: "run.event";
+    runId: string;
+    threadId: string;
+    sequence: number;
+    emittedAt: string;
+    revision: number;
+    status: ThreadRunEventStatus;
+    assistant: RemoteDeviceAssistantSnapshot;
+    pendingApprovals?: RemoteToolApprovalPrompt[];
+    usage?: ThreadRunUsageSnapshot | null;
+}
+export interface NatsDeviceCredentials {
+    account: string;
+    credentials: string;
+    deviceId: string;
+    expiresAt: string;
+    inboxPrefix: string;
+    protocolVersion: number;
+    role: "mobile" | "desktop";
+    url: string;
+    userNo: string;
+}
+export interface NatsDeviceCredentialsEnvelope {
+    code: string;
+    msg?: string;
+    data?: NatsDeviceCredentials;
+}
+export interface RemoteDeviceHostConfig {
+    enabled: boolean;
+    deviceName: string;
+}
+export interface RemoteDeviceHostStatus {
+    config: RemoteDeviceHostConfig;
+    deviceId: string;
+    connectionStatus: RemoteDeviceConnectionStatus;
+    connectedAt: string | null;
+    credentialsExpireAt: string | null;
+    lastError: string | null;
+}
+export interface RemoteDeviceHostConfigUpdate {
+    enabled?: boolean;
+    deviceName?: string;
+}
+export declare function normalizeRemoteSubjectToken(value: string, field: "userNo" | "threadId" | "runId" | "deviceId"): string;
+export declare function remoteDiscoverSubject(userNo: string): string;
+export declare function remotePresenceSubject(userNo: string, deviceId: string): string;
+export declare function remoteDeviceSubject(userNo: string, deviceId: string, action: "request" | "cancel" | "info" | "query" | "query-cancel" | "approve"): string;
+export declare function remoteRunStreamSubject(userNo: string, threadId: string, runId: string): string;
+export declare function isRemoteProtocolMessage(value: unknown): value is {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: string;
+};

package/dist/vendor/electron/shared/remote-device-agent.js

@@ -0,0 +1,191 @@
+export const REMOTE_DEVICE_PROTOCOL_VERSION = 2;
+export const REMOTE_DEVICE_PROTOCOL_NAME = "dinox.remote-device.v2";
+export const REMOTE_DEVICE_PROTOCOL_CONTRACT = {
+    version: REMOTE_DEVICE_PROTOCOL_VERSION,
+    name: REMOTE_DEVICE_PROTOCOL_NAME,
+    messageTypes: [
+        "device.discover",
+        "device.discovered",
+        "device.presence",
+        "device.info",
+        "device.info.result",
+        "skills.list",
+        "skills.list.result",
+        "workspace.list",
+        "workspace.list.result",
+        "workspace.file.read",
+        "workspace.file.read.result",
+        "query.cancel",
+        "run.request",
+        "run.ack",
+        "run.status",
+        "run.status.result",
+        "run.cancel",
+        "run.cancel.ack",
+        "tool.approval.respond",
+        "tool.approval.ack",
+        "run.event",
+    ],
+    ackCodes: [
+        "accepted",
+        "attachment_unavailable",
+        "busy",
+        "delivery_unknown",
+        "disabled",
+        "invalid_request",
+        "thread_not_found",
+        "enqueue_failed",
+    ],
+    subjectActions: ["request", "cancel", "info", "query", "query-cancel", "approve"],
+    messageFields: {
+        "device.discover": "requestId,clientDeviceId",
+        "device.discovered": "requestId,device",
+        "device.presence": "status,sequence,emittedAt,device",
+        "device.info": "requestId",
+        "device.info.result": "requestId,device",
+        "skills.list": "requestId,clientDeviceId,threadId;projectId,deadlineAt",
+        "skills.list.result": "requestId,threadId,ok,skills,fetchedAt;error",
+        "workspace.list": "requestId,clientDeviceId,threadId;parentPath,cursor,limit,deadlineAt",
+        "workspace.list.result": "requestId,threadId,parentPath,ok,entries,nextCursor,truncated,fetchedAt;error",
+        "workspace.file.read": "requestId,clientDeviceId,threadId,path;deadlineAt",
+        "workspace.file.read.result": "requestId,threadId,path,ok,preview,size,fetchedAt;modifiedAt,error",
+        "query.cancel": "requestId,clientDeviceId,queryRequestId",
+        "run.request": "requestId,runId,threadId,clientDeviceId,createdAt,prompt,userMessage,assistantMessage;parentMessageId,createThread",
+        "run.ack": "requestId,runId,threadId,accepted,code;status,error",
+        "run.status": "requestId,runId,threadId,clientDeviceId",
+        "run.status.result": "requestId,runId,threadId,found;status,updatedAt,assistant,pendingApprovals,error",
+        "run.cancel": "requestId,runId,threadId,clientDeviceId",
+        "run.cancel.ack": "requestId,runId,threadId,cancelled;error",
+        "tool.approval.respond": "requestId,clientDeviceId,runId,threadId,approvalId,approved;reason",
+        "tool.approval.ack": "requestId,runId,threadId,approvalId,accepted,code;status,pendingApprovals,error",
+        "run.event": "runId,threadId,sequence,emittedAt,revision,status,assistant;pendingApprovals,usage",
+    },
+};
+export const REMOTE_DEVICE_PRESENCE_INTERVAL_MS = 15_000;
+export const REMOTE_DEVICE_PRESENCE_TTL_MS = 45_000;
+export const REMOTE_DEVICE_REQUEST_TIMEOUT_MS = 5_000;
+export const REMOTE_DEVICE_MAX_EVENT_BYTES = 900_000;
+export const REMOTE_WORKSPACE_FILE_PREVIEW_MAX_BYTES = 5 * 1024 * 1024;
+export const REMOTE_WORKSPACE_PREVIEW_RETENTION_MS = 24 * 60 * 60_000;
+const SUBJECT_TOKEN_PATTERN = /^[a-z0-9][a-z0-9_-]{0,127}$/;
+const DEVICE_TOKEN_PATTERN = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+export function normalizeRemoteSubjectToken(value, field) {
+    const normalized = value.trim().toLowerCase();
+    const pattern = field === "deviceId" ? DEVICE_TOKEN_PATTERN : SUBJECT_TOKEN_PATTERN;
+    if (!pattern.test(normalized)) {
+        throw new Error(`${field} 不是合法的 NATS subject token`);
+    }
+    return normalized;
+}
+export function remoteDiscoverSubject(userNo) {
+    return `dinox.${normalizeRemoteSubjectToken(userNo, "userNo")}.discover`;
+}
+export function remotePresenceSubject(userNo, deviceId) {
+    return `dinox.${normalizeRemoteSubjectToken(userNo, "userNo")}.presence.${normalizeRemoteSubjectToken(deviceId, "deviceId")}`;
+}
+export function remoteDeviceSubject(userNo, deviceId, action) {
+    return `dinox.${normalizeRemoteSubjectToken(userNo, "userNo")}.device.${normalizeRemoteSubjectToken(deviceId, "deviceId")}.${action}`;
+}
+export function remoteRunStreamSubject(userNo, threadId, runId) {
+    return `dinox.${normalizeRemoteSubjectToken(userNo, "userNo")}.thread.${normalizeRemoteSubjectToken(threadId, "threadId")}.stream.${normalizeRemoteSubjectToken(runId, "runId")}`;
+}
+export function isRemoteProtocolMessage(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const record = value;
+    if (record.protocolVersion !== REMOTE_DEVICE_PROTOCOL_VERSION ||
+        typeof record.type !== "string" ||
+        !REMOTE_DEVICE_PROTOCOL_CONTRACT.messageTypes.includes(record.type)) {
+        return false;
+    }
+    const descriptor = REMOTE_DEVICE_PROTOCOL_CONTRACT.messageFields[record.type];
+    const [required = ""] = descriptor.split(";");
+    return required
+        .split(",")
+        .filter(Boolean)
+        .every((field) => Object.prototype.hasOwnProperty.call(record, field) && record[field] !== undefined) && hasValidRemoteFieldShapes(record);
+}
+function hasValidRemoteFieldShapes(record) {
+    for (const field of [
+        "requestId",
+        "runId",
+        "threadId",
+        "clientDeviceId",
+        "queryRequestId",
+        "approvalId",
+    ]) {
+        if (field in record && (typeof record[field] !== "string" || !record[field]))
+            return false;
+    }
+    for (const field of ["found", "ok", "accepted", "cancelled", "approved", "truncated"]) {
+        if (field in record && typeof record[field] !== "boolean")
+            return false;
+    }
+    for (const field of ["sequence", "revision", "size"]) {
+        if (field in record &&
+            record[field] !== null &&
+            (typeof record[field] !== "number" || !Number.isFinite(record[field]))) {
+            return false;
+        }
+    }
+    for (const field of ["skills", "entries", "busyThreadIds", "pendingApprovals"]) {
+        if (field in record && !Array.isArray(record[field]))
+            return false;
+    }
+    if ("device" in record && !isRemoteDeviceInfoShape(record.device))
+        return false;
+    if ("assistant" in record && !isRemoteAssistantSnapshotShape(record.assistant))
+        return false;
+    if ("status" in record &&
+        record.type !== "device.presence" &&
+        !isRemoteRunStatusValue(record.status)) {
+        return false;
+    }
+    if (record.type === "device.presence" &&
+        record.status !== "online" &&
+        record.status !== "offline") {
+        return false;
+    }
+    return true;
+}
+function isRemoteDeviceInfoShape(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const device = value;
+    return (device.protocolVersion === REMOTE_DEVICE_PROTOCOL_VERSION &&
+        device.protocol === REMOTE_DEVICE_PROTOCOL_NAME &&
+        typeof device.deviceId === "string" &&
+        Boolean(device.deviceId) &&
+        typeof device.deviceName === "string" &&
+        Array.isArray(device.busyThreadIds) &&
+        Boolean(device.capabilities) &&
+        typeof device.capabilities === "object");
+}
+function isRemoteAssistantSnapshotShape(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const snapshot = value;
+    const message = snapshot.message;
+    if (!message || typeof message !== "object" || Array.isArray(message))
+        return false;
+    const candidate = message;
+    return (typeof candidate.id === "string" &&
+        Boolean(candidate.id) &&
+        candidate.role === "assistant" &&
+        Array.isArray(candidate.parts) &&
+        (snapshot.truncated === undefined || typeof snapshot.truncated === "boolean"));
+}
+function isRemoteRunStatusValue(value) {
+    return (typeof value === "string" &&
+        [
+            "queued",
+            "running",
+            "waiting_approval",
+            "finalizing",
+            "succeeded",
+            "failed",
+            "cancelled",
+            "interrupted",
+            "expired",
+        ].includes(value));
+}