@k2b/cloud 0.23.0 → 0.24.0

package/src/ai/live-events.ts

@@ -1,5 +1,4 @@
 import { z } from "zod";
-import type { AiStreamEvent } from "./protocol";
 
 export const AI_INVALIDATION_DOMAINS = [
   "conversation-list",
@@ -17,8 +16,8 @@ export const AiInvalidationDomainSchema = z.enum(AI_INVALIDATION_DOMAINS);
 export type AiInvalidationDomain = z.infer<typeof AiInvalidationDomainSchema>;
 
 export const AiResourceIdSchema = z.string().regex(/^[0-9A-Za-z]{6}$/);
-export const AiLiveCursorSchema = z.string().regex(/^s6t\.[a-zA-Z0-9_-]+\.\d+$/);
 
+/** The data of one AI live update on the `user` channel of `/api/ai/live`: which views of the user's AI data changed. */
 export const AiInvalidationSchema = z
   .object({
     type: z.literal("ai.invalidated"),
@@ -31,263 +30,3 @@ export const AiInvalidationSchema = z
   .strict();
 
 export type AiInvalidation = z.infer<typeof AiInvalidationSchema>;
-
-export const AI_LIVE_WS_TYPE = {
-  subscribe: "ai.live.subscribe",
-  ready: "ai.live.ready",
-  event: "ai.live.event",
-  scopeChanged: "ai.live.scope_changed",
-  revoked: "ai.live.revoked",
-  error: "ai.live.error",
-  turnSubscribe: "ai.turn.subscribe",
-  turnUnsubscribe: "ai.turn.unsubscribe",
-  turnEvent: "ai.turn.event",
-  turnError: "ai.turn.error",
-} as const;
-
-const AiLiveSubscribeMessageSchema = z
-  .object({
-    type: z.literal(AI_LIVE_WS_TYPE.subscribe),
-    payload: z.object({ fromCursor: AiLiveCursorSchema.nullable(), recover: z.boolean() }).strict(),
-  })
-  .strict();
-
-const AiTurnSubscribeMessageSchema = z
-  .object({
-    type: z.literal(AI_LIVE_WS_TYPE.turnSubscribe),
-    payload: z.object({ conversationId: AiResourceIdSchema }).strict(),
-  })
-  .strict();
-
-const AiTurnUnsubscribeMessageSchema = z
-  .object({
-    type: z.literal(AI_LIVE_WS_TYPE.turnUnsubscribe),
-    payload: z.object({ conversationId: AiResourceIdSchema }).strict(),
-  })
-  .strict();
-
-export const AiLiveClientMessageSchema = z.discriminatedUnion("type", [
-  AiLiveSubscribeMessageSchema,
-  AiTurnSubscribeMessageSchema,
-  AiTurnUnsubscribeMessageSchema,
-]);
-export type AiLiveClientMessage = z.infer<typeof AiLiveClientMessageSchema>;
-
-const AiLiveRevocationCodeSchema = z.enum(["login_required", "access_denied"]);
-const AiLiveErrorCodeSchema = z.enum(["invalid_json", "invalid_message", "backpressure", "internal_error", "stream_failed"]);
-const AiTurnErrorCodeSchema = z.enum(["not_found", "access_denied", "stream_failed"]);
-
-export type AiLiveRevocationCode = z.infer<typeof AiLiveRevocationCodeSchema>;
-export type AiLiveErrorCode = z.infer<typeof AiLiveErrorCodeSchema>;
-export type AiTurnErrorCode = z.infer<typeof AiTurnErrorCodeSchema>;
-
-const AiTurnBlockSchema = z.discriminatedUnion("kind", [
-  z.object({ id: z.string(), kind: z.literal("text"), text: z.string() }).strict(),
-  z.object({ id: z.string(), kind: z.literal("thinking"), text: z.string() }).strict(),
-  z
-    .object({
-      id: z.string(),
-      kind: z.literal("steer_message"),
-      steerId: z.string(),
-      text: z.string(),
-      status: z.enum(["pending", "consumed", "failed"]),
-    })
-    .strict(),
-  z.object({ id: z.string(), kind: z.literal("steer_applied"), steerId: z.string() }).strict(),
-  z
-    .object({
-      id: z.string(),
-      kind: z.literal("tool"),
-      callId: z.string(),
-      name: z.string(),
-      args: z.unknown().optional(),
-      status: z.enum(["running", "awaiting_approval", "awaiting_client", "completed", "failed", "rejected"]),
-      result: z.unknown().optional(),
-      isError: z.boolean().optional(),
-      approval: z.unknown().optional(),
-      frontendMode: z.enum(["client", "client_view", "client_interaction"]).optional(),
-      presentation: z.unknown().optional(),
-    })
-    .strict(),
-  z
-    .object({
-      id: z.string(),
-      kind: z.literal("compaction"),
-      status: z.enum(["running", "completed", "skipped", "failed"]),
-      result: z.unknown().optional(),
-    })
-    .strict(),
-]);
-
-const AiConversationSchema = z
-  .object({
-    id: AiResourceIdSchema,
-    shortId: AiResourceIdSchema,
-    title: z.string(),
-    titleSource: z.enum(["default", "auto", "user"]),
-    description: z.string(),
-    descriptionSource: z.enum(["default", "auto", "user"]),
-    keywords: z.array(z.string()),
-    pinnedAt: z.string().nullable(),
-    archivedAt: z.string().nullable(),
-    done: z.boolean().nullable(),
-    isDone: z.boolean(),
-    lastUsedAt: z.string(),
-    runStatus: z.enum(["idle", "queued", "running", "needs_attention", "waiting_for_browser", "failed"]),
-    runError: z.string().nullable(),
-    unreadCompletion: z.boolean(),
-    projectId: z.string().nullable(),
-    draft: z.object({ content: z.array(z.unknown()), revision: z.number().int(), updatedAt: z.string().nullable() }).strict(),
-    createdByUserId: z.string().nullable(),
-    createdAt: z.string(),
-    updatedAt: z.string(),
-  })
-  .strict();
-
-const AiStoredMessageSchema = z
-  .object({
-    id: AiResourceIdSchema,
-    shortId: AiResourceIdSchema,
-    conversationId: AiResourceIdSchema,
-    seq: z.number().int().nonnegative(),
-    kind: z.enum(["message", "summary"]),
-    message: z.unknown(),
-    loopId: AiResourceIdSchema.nullable(),
-    modelProfileId: z.string().nullable(),
-    providerModel: z.string().nullable(),
-    usage: z.unknown().nullable(),
-    stopReason: z.string().nullable(),
-    loopAggregate: z.unknown().nullable(),
-    loopDoneReason: z.string().nullable(),
-    compactedAt: z.string().nullable(),
-    meta: z.unknown().nullable(),
-    createdAt: z.string(),
-  })
-  .strict();
-
-const AiTurnSnapshotSchema = z
-  .object({
-    turnId: AiResourceIdSchema,
-    attempt: z.number().int().nonnegative(),
-    status: z.enum(["queued", "running", "waiting_for_action", "completed", "failed", "aborted"]),
-    seq: z.number().int().nonnegative(),
-    blocks: z.array(AiTurnBlockSchema),
-    modelProfileId: z.string().nullable(),
-    createdAt: z.string(),
-  })
-  .strict();
-
-const AiWireEventBaseSchema = {
-  v: z.literal(1),
-  conversationId: AiResourceIdSchema,
-  turnId: AiResourceIdSchema,
-  attempt: z.number().int().nonnegative(),
-  seq: z.number().int().nonnegative(),
-} as const;
-
-const AiStreamEventWireSchema = z.union([
-  z
-    .object({
-      type: z.literal("state"),
-      conversation: AiConversationSchema,
-      messages: z.array(AiStoredMessageSchema),
-      hasMoreMessages: z.boolean().optional(),
-      activeTurn: AiTurnSnapshotSchema.nullable(),
-    })
-    .strict(),
-  z
-    .object({
-      ...AiWireEventBaseSchema,
-      type: z.literal("turn_started"),
-      modelProfileId: z.string(),
-      providerModel: z.string(),
-      blocks: z.array(AiTurnBlockSchema).optional(),
-    })
-    .strict(),
-  z.object({ ...AiWireEventBaseSchema, type: z.literal("block_set"), block: AiTurnBlockSchema }).strict(),
-  z
-    .object({
-      ...AiWireEventBaseSchema,
-      type: z.literal("block_delta"),
-      blockId: z.string(),
-      blockKind: z.enum(["text", "thinking"]),
-      delta: z.string(),
-    })
-    .strict(),
-  z
-    .object({
-      ...AiWireEventBaseSchema,
-      type: z.literal("turn_finished"),
-      status: z.enum(["completed", "failed", "aborted"]),
-      error: z.string().nullable(),
-      messages: z.array(AiStoredMessageSchema).optional(),
-    })
-    .strict(),
-]);
-
-export const AiStreamEventSchema = z.custom<AiStreamEvent>((value) => AiStreamEventWireSchema.safeParse(value).success);
-
-export const AiLiveServerMessageSchema = z.discriminatedUnion("type", [
-  z
-    .object({
-      type: z.literal(AI_LIVE_WS_TYPE.ready),
-      payload: z.object({ cursor: AiLiveCursorSchema, recovered: z.boolean() }).strict(),
-    })
-    .strict(),
-  z
-    .object({
-      type: z.literal(AI_LIVE_WS_TYPE.event),
-      payload: z.object({ cursor: AiLiveCursorSchema, event: AiInvalidationSchema }).strict(),
-    })
-    .strict(),
-  z
-    .object({
-      type: z.literal(AI_LIVE_WS_TYPE.scopeChanged),
-      payload: z.object({ at: z.string().datetime() }).strict(),
-    })
-    .strict(),
-  z
-    .object({
-      type: z.literal(AI_LIVE_WS_TYPE.revoked),
-      payload: z.object({ code: AiLiveRevocationCodeSchema, message: z.string().min(1).max(500) }).strict(),
-    })
-    .strict(),
-  z
-    .object({
-      type: z.literal(AI_LIVE_WS_TYPE.error),
-      payload: z.object({ code: AiLiveErrorCodeSchema, message: z.string().min(1).max(500) }).strict(),
-    })
-    .strict(),
-  z
-    .object({
-      type: z.literal(AI_LIVE_WS_TYPE.turnEvent),
-      payload: z.object({ conversationId: AiResourceIdSchema, event: AiStreamEventSchema }).strict(),
-    })
-    .strict(),
-  z
-    .object({
-      type: z.literal(AI_LIVE_WS_TYPE.turnError),
-      payload: z.object({ conversationId: AiResourceIdSchema, code: AiTurnErrorCodeSchema, message: z.string().min(1).max(500) }).strict(),
-    })
-    .strict(),
-]);
-
-export type AiLiveServerMessage = z.infer<typeof AiLiveServerMessageSchema>;
-
-export const aiTurnEventMessage = (conversationId: string, event: AiStreamEvent): AiLiveServerMessage => ({
-  type: AI_LIVE_WS_TYPE.turnEvent,
-  payload: { conversationId, event },
-});
-
-export const parseAiLiveServerMessage = (raw: string): AiLiveServerMessage | null => {
-  try {
-    const parsed = AiLiveServerMessageSchema.safeParse(JSON.parse(raw));
-    if (!parsed.success) return null;
-    if (parsed.data.type !== AI_LIVE_WS_TYPE.turnEvent) return parsed.data;
-    const eventConversationId =
-      parsed.data.payload.event.type === "state" ? parsed.data.payload.event.conversation.id : parsed.data.payload.event.conversationId;
-    return eventConversationId === parsed.data.payload.conversationId ? parsed.data : null;
-  } catch {
-    return null;
-  }
-};

package/src/ai/live.ts

@@ -1,2 +1,31 @@
-export { latestAiInvalidationCursor } from "./live-outbox";
-export { type AiLiveRoutes, type AiLiveRoutesConfig, aiLiveRoutes } from "./live-routes";
+import { z } from "zod";
+import { defineLive, type LiveViewer } from "../events/live";
+import { AiInvalidationSchema } from "./live-events";
+
+/**
+ * Live updates of a user's AI data. Core publishes and serves them at
+ * `/api/ai/live`; the AI's database triggers write them, keyed `u:<user ID>`,
+ * in the transaction of every change. Other applications, such as Assistant,
+ * read `cursor()` before their snapshot.
+ */
+export const aiLive = defineLive({ appId: "core", event: AiInvalidationSchema });
+
+/** The user an AI request acts for: the user, or the user a credential is delegated by. */
+const ownerOf = (viewer: LiveViewer): string | null => (viewer.accessSubject.type === "user" ? viewer.accessSubject.userId : null);
+
+/**
+ * `user` follows the viewer's own AI data: conversations, their files, tasks and
+ * dictations, and the Projects the viewer can read. Its single key admits only
+ * that user; who receives a Project change was decided when it was written.
+ */
+export const aiLiveChannels = {
+  user: {
+    scope: z.object({}).strict(),
+    keys: async (_scope: unknown, viewer: LiveViewer) => {
+      const owner = ownerOf(viewer);
+      return owner ? [`u:${owner}`] : null;
+    },
+    authorize: async (key: string, viewers: readonly LiveViewer[]) =>
+      new Set(viewers.filter((viewer) => `u:${ownerOf(viewer)}` === key).map((viewer) => viewer.id)),
+  },
+};

package/src/ai/migrate.ts

@@ -13,6 +13,14 @@ const backfillAiShortIds = async (
 };
 
 export const migrateCloudAi = async (): Promise<void> => {
+  // AI writes its live updates to Core's platform outbox, in the transaction of every
+  // AI write: without events.enqueue(), every one of them would fail.
+  const [outbox] = await sql<{ ready: boolean }[]>`
+    SELECT to_regprocedure('events.enqueue(uuid,text,text,text,jsonb,text)') IS NOT NULL AS ready
+  `;
+  if (!outbox?.ready) {
+    throw new Error("AI live updates write to events.outbox, which does not exist. Run Core's events migration before the AI migration.");
+  }
   await sql`CREATE SCHEMA IF NOT EXISTS ai`.simple();
   console.log("  ✓ ai schema");
 
@@ -1722,10 +1730,12 @@ export const migrateCloudAi = async (): Promise<void> => {
     WHERE project_id IS NOT NULL AND archived_at IS NULL
   `.simple();
 
-  // Durable Realtime UI invalidations. Triggers live at the persistence seam so
-  // route, worker, tool, enrichment, and scheduler writes cannot bypass them.
-  // The outbox row commits or rolls back with the authoritative domain write;
-  // publishing remains an after-commit runtime responsibility.
+  // Live updates. Triggers live at the persistence seam so route, worker, tool,
+  // enrichment, and scheduler writes cannot bypass them. They write to Core's
+  // platform outbox in the transaction of the domain write (see the start of this migration).
+
+  // The previous outbox. Nothing writes it anymore; an older Core that still runs during
+  // an update finds it empty. The cleanup release drops it with the topic cloud-ai-invalidations.
   await sql`
     CREATE TABLE IF NOT EXISTS ai.live_invalidation_outbox (
       id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
@@ -1786,6 +1796,10 @@ export const migrateCloudAi = async (): Promise<void> => {
     DROP FUNCTION IF EXISTS ai.enqueue_live_for_user(UUID, TEXT, UUID, TEXT, TEXT, TEXT[])
   `.simple();
 
+  // Every AI live update goes through this function: one update for one user,
+  // keyed `u:<user>`, on Core's live topic. Its data is an `AiInvalidation`.
+  // No coalesce key: the last payload would win and drop the domains of earlier ones.
+  // Gateway health reports a body without events.enqueue: an older Core restored its own.
   await sql`
     CREATE OR REPLACE FUNCTION ai.enqueue_live_for_user(
       p_change_id UUID,
@@ -1796,11 +1810,23 @@ export const migrateCloudAi = async (): Promise<void> => {
     ) RETURNS void AS $$
     BEGIN
       IF p_user_id IS NULL OR cardinality(p_domains) = 0 THEN RETURN; END IF;
-      INSERT INTO ai.live_invalidation_outbox (
-        change_id, audience_user_id, conversation_short_id, project_short_id, domains
-      ) VALUES (
-        p_change_id, p_user_id, p_conversation_short_id, p_project_short_id,
-        ARRAY(SELECT DISTINCT domain FROM unnest(p_domains) domain ORDER BY domain)
+      PERFORM events.enqueue(
+        gen_random_uuid(),
+        'core',
+        'live',
+        'u:' || p_user_id::text,
+        jsonb_build_object(
+          'v', 1,
+          'k', 'u:' || p_user_id::text,
+          'd', jsonb_build_object(
+            'type', 'ai.invalidated',
+            'changeId', p_change_id,
+            'conversationId', p_conversation_short_id,
+            'projectId', p_project_short_id,
+            'domains', to_jsonb(ARRAY(SELECT DISTINCT domain FROM unnest(p_domains) domain ORDER BY domain)),
+            'at', to_char(now() AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')
+          )
+        )
       );
     END
     $$ LANGUAGE plpgsql
@@ -2213,13 +2239,6 @@ export const migrateCloudAi = async (): Promise<void> => {
   )`.simple();
   await sql`CREATE INDEX IF NOT EXISTS ai_dictations_pending ON ai.dictations(conversation_id, created_at, id) WHERE disposition = 'pending'`.simple();
   await sql`CREATE INDEX IF NOT EXISTS ai_dictations_recovery ON ai.dictations(status, next_attempt_at, lease_until) WHERE status IN ('queued', 'running')`.simple();
-  await sql.begin(async (tx) => {
-    await tx`ALTER TABLE ai.live_invalidation_outbox DROP CONSTRAINT IF EXISTS ai_live_invalidation_domains_check`;
-    await tx`ALTER TABLE ai.live_invalidation_outbox ADD CONSTRAINT ai_live_invalidation_domains_check CHECK (
-      domains <@ ARRAY['conversation-list', 'conversation-detail', 'conversation-sources', 'conversation-files', 'conversation-tasks',
-        'conversation-dictations', 'project-list', 'project-detail', 'project-context']::text[] AND cardinality(domains) > 0
-    )`;
-  });
   await sql`DROP TRIGGER IF EXISTS ai_live_dictations_changed ON ai.dictations`.simple();
   await sql`DROP TRIGGER IF EXISTS ai_live_dictations_state_changed ON ai.dictations`.simple();
   await sql`CREATE TRIGGER ai_live_dictations_changed AFTER INSERT OR DELETE ON ai.dictations

package/src/ai/runtime.ts

@@ -12,7 +12,6 @@ import { aiChatAccessSubject, selectAssistantAiModelId } from "./assistant-model
 import { startAiDictationRuntime } from "./dictation-runtime";
 import { AiTurnExecutor } from "./executor";
 import { canonicalizeAiConversationAttachments, snapshotAiConversationFiles } from "./file-context";
-import { startAiInvalidationRuntime, stopAiInvalidationRuntime } from "./live-outbox";
 import { drainQueuedMessages } from "./message-queue";
 import { aiQuotas } from "./quotas";
 import { parseAiResourceMarker } from "./resource-markers";
@@ -577,7 +576,6 @@ export const startAiRuntime = (
     },
   };
   running = state;
-  startAiInvalidationRuntime();
   log.info("AI runtime started", { workerId: AI_WORKER_ID, concurrency });
   return releaseAiRuntime(listener);
 };
@@ -591,10 +589,7 @@ const releaseAiRuntime = (listener: ((event: AiTurnFinalizedEvent) => Promise<vo
     if (!state) return;
     if (listener) state.listeners.delete(listener);
     refCount = Math.max(0, refCount - 1);
-    if (refCount === 0) {
-      state.stop();
-      void stopAiInvalidationRuntime();
-    }
+    if (refCount === 0) state.stop();
   };
 };
 

package/src/ai/solid.ts

@@ -7,11 +7,6 @@ export {
   createAiChatController,
 } from "./client/controller";
 export { conversationFileSource } from "./client/file-source";
-export {
-  type AiLiveConnection,
-  type CreateAiLiveConnectionOptions,
-  createAiLiveConnection,
-} from "./client/live-connection";
 export {
   type AiActiveTurn,
   type AiChatProjection,

package/src/api/help.ts

@@ -8,7 +8,7 @@ import { helpApiMessages } from "./help-messages";
 export type HelpRouteDependencies = {
   help?: HelpReaderFactory;
   authenticate?: MiddlewareHandler<AuthContext>;
-  renderMarkdown?: (markdown: string) => string;
+  renderMarkdown?: (markdown: string, locale: string) => string;
 };
 
 export const createHelpRoutes = (dependencies: HelpRouteDependencies = {}) => {
@@ -34,7 +34,7 @@ export const createHelpRoutes = (dependencies: HelpRouteDependencies = {}) => {
         id: document.documentId,
         title: document.title,
         markdown: document.markdown,
-        html: (dependencies.renderMarkdown ?? renderHelpMarkdown)(document.markdown),
+        html: (dependencies.renderMarkdown ?? renderHelpMarkdown)(document.markdown, document.locale),
       };
       return c.json(payload);
     });

package/src/api/pwa-phone.ts

@@ -2,8 +2,8 @@ import { type Context, Hono } from "hono";
 import { deleteCookie, getCookie, setCookie } from "hono/cookie";
 import { env } from "../config/env";
 import { PWA_AUTH_PATH, PWA_COOKIES, PWA_LIMITS, PWA_SCOPE, PwaClaimSchema, type PwaLaunchState, PwaRenameSchema } from "../contracts/pwa";
-import { type AuthContext, auth, rateLimit, v } from "../server";
-import { type PwaCredentials, PwaError, pwaDevices } from "../services/pwa-devices";
+import { type AuthContext, auth, getLocale, rateLimit, v } from "../server";
+import { type PwaCredentials, type PwaDeviceNotifier, PwaError, pwaDevices } from "../services/pwa-devices";
 import { defaultShellAvailable, handlePwaError, type PwaRouteOptions, pwaErrorResponse, pwaInvalidRequest, pwaTransport } from "./pwa";
 
 const PAIRING_COOKIE_PATH = `${PWA_AUTH_PATH}/pairings`;
@@ -58,12 +58,17 @@ export const launchTarget = (to: string | undefined): string => {
 
 const stateUrl = (state: PwaLaunchState) => `${PWA_SCOPE}?pwa=${state}`;
 
+export type PwaPhoneRouteOptions = PwaRouteOptions & {
+  /** Sends the "new phone paired" notice; completion awaits it before the phone gets its credentials. */
+  notify: PwaDeviceNotifier;
+};
+
 /**
  * Phone side of the mobile app (preview), mounted by Core at `/pwa/_auth` before its page
  * catch-all. The device key and the completion secret use cookie paths below `/pwa/_auth`,
  * which only Core serves; other applications see only the 24-hour app session.
  */
-export const createPwaPhoneRoutes = (options: PwaRouteOptions = {}) => {
+export const createPwaPhoneRoutes = (options: PwaPhoneRouteOptions) => {
   const service = options.service ?? pwaDevices;
   const shellAvailable = options.shellAvailable ?? defaultShellAvailable;
   const limit = rateLimit({ keyBy: "ip" });
@@ -102,6 +107,8 @@ export const createPwaPhoneRoutes = (options: PwaRouteOptions = {}) => {
           deviceKey: getCookie(c, PWA_COOKIES.device),
           appSession: await appSession(c),
           webUserId: web?.user.id ?? null,
+          locale: getLocale(c),
+          notify: options.notify,
         });
         if (result.state === "waiting") return c.json(result, 202);
         if (result.credentials) setAppCredentials(c, result.credentials);

package/src/api/search/schemas.ts

@@ -85,6 +85,40 @@ export const SearchResponseSchema = z.object({
   failedApps: z.array(z.string()).optional(),
 });
 
+/** Media type a client sends in `Accept` to receive one NDJSON line per app as soon as it finishes. */
+export const SEARCH_STREAM_CONTENT_TYPE = "application/x-ndjson";
+
+export const SearchProviderStatusSchema = z.enum(["ok", "empty", "timeout", "error"]);
+
+/**
+ * One line of a streamed search: `start` names the apps that search, one `provider` line follows per app in the
+ * order the apps finish, and `done` closes the search. Apps without a line before `done` do not exist: every app
+ * named in `start` gets exactly one line.
+ */
+export const SearchStreamLineSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("start"),
+    query: z.string(),
+    apps: z.array(SearchAppSchema),
+    providers: z.array(z.string()),
+    unsupportedTags: z.array(z.string()).optional(),
+  }),
+  z.object({
+    type: z.literal("provider"),
+    provider: z.string(),
+    status: SearchProviderStatusSchema,
+    results: z.array(SearchItemSchema),
+    ms: z.number().int().nonnegative(),
+  }),
+  z.object({
+    type: z.literal("done"),
+    status: z.enum(["complete", "partial"]),
+    count: z.number().int().nonnegative(),
+  }),
+]);
+
 export type SearchApp = z.infer<typeof SearchAppSchema>;
 export type SearchItem = z.infer<typeof SearchItemSchema>;
 export type SearchResponse = z.infer<typeof SearchResponseSchema>;
+export type SearchProviderStatus = z.infer<typeof SearchProviderStatusSchema>;
+export type SearchStreamLine = z.infer<typeof SearchStreamLineSchema>;