feat: add live model and thinking option preferences UI (#8)

* feat: add live model and thinking option preferences UI

* refactor: remove agent variant support and clean up thinking options

* feat: live model + thinking presets (RPC)

packages/app/src/utils/agent-initialization.ts

@@ -0,0 +1,44 @@
+export interface DeferredInit {
+  promise: Promise<void>;
+  resolve: () => void;
+  reject: (error: Error) => void;
+}
+
+const initPromises = new Map<string, DeferredInit>();
+
+export function getInitKey(serverId: string, agentId: string): string {
+  return `${serverId}:${agentId}`;
+}
+
+export function getInitDeferred(key: string): DeferredInit | undefined {
+  return initPromises.get(key);
+}
+
+export function createInitDeferred(key: string): DeferredInit {
+  let resolve!: () => void;
+  let reject!: (error: Error) => void;
+
+  const promise = new Promise<void>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+
+  const deferred: DeferredInit = { promise, resolve, reject };
+  initPromises.set(key, deferred);
+  return deferred;
+}
+
+export function resolveInitDeferred(key: string): void {
+  const deferred = initPromises.get(key);
+  deferred?.resolve();
+}
+
+export function rejectInitDeferred(key: string, error: Error): void {
+  const deferred = initPromises.get(key);
+  if (!deferred) {
+    return;
+  }
+  initPromises.delete(key);
+  deferred.reject(error);
+}
+

packages/app/src/utils/agent-snapshots.ts

@@ -0,0 +1,56 @@
+import type { AgentLifecycleStatus } from "@server/shared/agent-lifecycle";
+import type { AgentSnapshotPayload } from "@server/shared/messages";
+import type { AgentPermissionRequest } from "@server/server/agent/agent-sdk-types";
+
+export function derivePendingPermissionKey(
+  agentId: string,
+  request: AgentPermissionRequest
+): string {
+  const fallbackId =
+    request.id ||
+    (typeof request.metadata?.id === "string" ? request.metadata.id : undefined) ||
+    request.name ||
+    request.title ||
+    `${request.kind}:${JSON.stringify(request.input ?? request.metadata ?? {})}`;
+
+  return `${agentId}:${fallbackId}`;
+}
+
+export function normalizeAgentSnapshot(snapshot: AgentSnapshotPayload, serverId: string) {
+  const createdAt = new Date(snapshot.createdAt);
+  const updatedAt = new Date(snapshot.updatedAt);
+  const lastUserMessageAt = snapshot.lastUserMessageAt ? new Date(snapshot.lastUserMessageAt) : null;
+  const attentionTimestamp = snapshot.attentionTimestamp
+    ? new Date(snapshot.attentionTimestamp)
+    : null;
+  const archivedAt = snapshot.archivedAt ? new Date(snapshot.archivedAt) : null;
+
+  return {
+    serverId,
+    id: snapshot.id,
+    provider: snapshot.provider,
+    status: snapshot.status as AgentLifecycleStatus,
+    createdAt,
+    updatedAt,
+    lastUserMessageAt,
+    lastActivityAt: updatedAt,
+    capabilities: snapshot.capabilities,
+    currentModeId: snapshot.currentModeId,
+    availableModes: snapshot.availableModes ?? [],
+    pendingPermissions: snapshot.pendingPermissions ?? [],
+    persistence: snapshot.persistence ?? null,
+    runtimeInfo: snapshot.runtimeInfo,
+    lastUsage: snapshot.lastUsage,
+    lastError: snapshot.lastError ?? null,
+    title: snapshot.title ?? null,
+    cwd: snapshot.cwd,
+    model: snapshot.model ?? null,
+    thinkingOptionId: snapshot.thinkingOptionId ?? null,
+    requiresAttention: snapshot.requiresAttention ?? false,
+    attentionReason: snapshot.attentionReason ?? null,
+    attentionTimestamp,
+    archivedAt,
+    labels: snapshot.labels,
+  };
+}
+

packages/app/src/utils/encode-images.ts

@@ -0,0 +1,68 @@
+import { Platform } from "react-native";
+import { File } from "expo-file-system";
+
+type ImageInput = { uri: string; mimeType?: string };
+
+export async function encodeImages(
+  images?: ImageInput[]
+): Promise<Array<{ data: string; mimeType: string }> | undefined> {
+  if (!images || images.length === 0) {
+    return undefined;
+  }
+
+  const encodedImages = await Promise.all(
+    images.map(async ({ uri, mimeType }) => {
+      try {
+        const data = await (async () => {
+          if (Platform.OS === "web") {
+            if (uri.startsWith("data:")) {
+              const [, base64] = uri.split(",", 2);
+              if (!base64) {
+                throw new Error("Malformed data URI for image.");
+              }
+              return base64;
+            }
+            const response = await fetch(uri);
+            const blob = await response.blob();
+            const base64 = await new Promise<string>((resolve, reject) => {
+              const reader = new FileReader();
+              reader.onload = () => {
+                if (typeof reader.result !== "string") {
+                  reject(new Error("Unexpected FileReader result type."));
+                  return;
+                }
+                const [, resultBase64] = reader.result.split(",", 2);
+                if (!resultBase64) {
+                  reject(new Error("Failed to read image data as base64."));
+                  return;
+                }
+                resolve(resultBase64);
+              };
+              reader.onerror = () => {
+                reject(reader.error ?? new Error("Failed to read image data."));
+              };
+              reader.readAsDataURL(blob);
+            });
+            return base64;
+          }
+
+          const file = new File(uri);
+          return await file.base64();
+        })();
+
+        return {
+          data,
+          mimeType: mimeType ?? "image/jpeg",
+        };
+      } catch (error) {
+        console.error("[encodeImages] Failed to convert image:", error);
+        return null;
+      }
+    })
+  );
+
+  const validImages = encodedImages.filter(
+    (entry): entry is { data: string; mimeType: string } => entry !== null
+  );
+  return validImages.length > 0 ? validImages : undefined;
+}