spiracha 1.5.0 → 2.1.0

package/apps/ui/src/lib/grok-server.ts

@@ -0,0 +1,169 @@
+import { createServerFn } from '@tanstack/react-start';
+import { z } from 'zod';
+import { renderSourceSessionDownload, renderSourceSessionsDownload } from './source-session-export-server';
+
+const workspaceSchema = z.object({
+    workspaceKey: z.string().min(1),
+});
+
+const sessionSchema = z.object({
+    sessionId: z.string().min(1),
+});
+
+const exportSessionSchema = z.object({
+    includeCommentary: z.boolean().default(true),
+    includeMetadata: z.boolean().default(true),
+    includeTools: z.boolean().default(true),
+    outputFormat: z.enum(['md', 'txt']).default('md'),
+    sessionId: z.string().min(1),
+    zipArchive: z.boolean().default(false),
+});
+
+const exportSessionsSchema = z.object({
+    includeCommentary: z.boolean().default(true),
+    includeMetadata: z.boolean().default(true),
+    includeTools: z.boolean().default(true),
+    outputFormat: z.enum(['md', 'txt']).default('md'),
+    sessionIds: z.array(z.string().min(1)).min(1),
+    zipArchive: z.boolean().default(true),
+});
+
+const deleteSessionsSchema = z.object({
+    sessionIds: z.array(z.string().min(1)).min(1),
+});
+
+export const listGrokWorkspacesFn = createServerFn({ method: 'GET' }).handler(async () => {
+    const { listGrokWorkspaceGroups } = await import('@spiracha/lib/grok-db');
+    return listGrokWorkspaceGroups();
+});
+
+export const listGrokSessionsFn = createServerFn({ method: 'GET' })
+    .validator(workspaceSchema)
+    .handler(async ({ data }) => {
+        const { listGrokSessionsForGroup } = await import('@spiracha/lib/grok-db');
+        return listGrokSessionsForGroup(data.workspaceKey);
+    });
+
+const loadGrokSessionTranscript = async (sessionId: string) => {
+    const { runWithTranscriptLoadLimit } = await import('@spiracha/lib/transcript-load-limiter');
+    const { readGrokSessionTranscript, resolveGrokSessionsDir } = await import('@spiracha/lib/grok-db');
+    const sessionsDir = resolveGrokSessionsDir();
+    return runWithTranscriptLoadLimit(
+        async () => {
+            const transcript = await readGrokSessionTranscript(sessionsDir, sessionId, {
+                includeRawPayloads: false,
+            });
+            if (!transcript) {
+                throw new Error(`Grok session not found: ${sessionId}`);
+            }
+
+            return transcript;
+        },
+        {
+            id: sessionId,
+            path: sessionsDir,
+            source: 'grok-ui',
+        },
+    );
+};
+
+export const getGrokSessionDetailFn = createServerFn({ method: 'GET' })
+    .validator(sessionSchema)
+    .handler(async ({ data }) => {
+        return loadGrokSessionTranscript(data.sessionId);
+    });
+
+export const exportGrokSessionFn = createServerFn({ method: 'POST' })
+    .validator(exportSessionSchema)
+    .handler(async ({ data }) => {
+        const { renderGrokTranscript } = await import('@spiracha/lib/grok-transcript');
+        const transcript = await loadGrokSessionTranscript(data.sessionId);
+        const content = renderGrokTranscript(transcript, {
+            includeCommentary: data.includeCommentary,
+            includeMetadata: data.includeMetadata,
+            includeTools: data.includeTools,
+            outputFormat: data.outputFormat,
+        });
+
+        if (!content) {
+            throw new Error(`Grok session has no exportable content: ${data.sessionId}`);
+        }
+
+        return renderSourceSessionDownload({
+            content,
+            cwd: transcript.session.cwd ?? transcript.session.worktree,
+            fallbackBaseName: 'grok-session',
+            outputFormat: data.outputFormat,
+            sessionId: transcript.session.sessionId,
+            updatedAtMs: transcript.session.lastActiveAtMs,
+            zipArchive: data.zipArchive,
+        });
+    });
+
+export const exportGrokSessionsFn = createServerFn({ method: 'POST' })
+    .validator(exportSessionsSchema)
+    .handler(async ({ data }) => {
+        const { renderGrokTranscript } = await import('@spiracha/lib/grok-transcript');
+        const entries = await Promise.all(
+            data.sessionIds.map(async (sessionId) => {
+                const transcript = await loadGrokSessionTranscript(sessionId);
+                const content = renderGrokTranscript(transcript, {
+                    includeCommentary: data.includeCommentary,
+                    includeMetadata: data.includeMetadata,
+                    includeTools: data.includeTools,
+                    outputFormat: data.outputFormat,
+                });
+
+                if (!content) {
+                    throw new Error(`Grok session has no exportable content: ${sessionId}`);
+                }
+
+                return {
+                    content,
+                    cwd: transcript.session.cwd ?? transcript.session.worktree,
+                    fallbackBaseName: 'grok-session',
+                    fileBaseName: transcript.session.title || transcript.session.sessionId,
+                    sessionId: transcript.session.sessionId,
+                    updatedAtMs: transcript.session.lastActiveAtMs,
+                };
+            }),
+        );
+
+        return renderSourceSessionsDownload({
+            entries,
+            fallbackBaseName: 'grok-sessions',
+            outputFormat: data.outputFormat,
+            zipArchive: data.zipArchive,
+        });
+    });
+
+export const deleteGrokSessionFn = createServerFn({ method: 'POST' })
+    .validator(sessionSchema)
+    .handler(async ({ data }) => {
+        const { deleteGrokSession, resolveGrokSessionsDir } = await import('@spiracha/lib/grok-db');
+        const result = await deleteGrokSession(resolveGrokSessionsDir(), data.sessionId);
+        if (result.deletedSessionIds.length === 0) {
+            throw new Error(`Grok session not found: ${data.sessionId}`);
+        }
+
+        return result;
+    });
+
+export const deleteGrokSessionsFn = createServerFn({ method: 'POST' })
+    .validator(deleteSessionsSchema)
+    .handler(async ({ data }) => {
+        const { deleteGrokSession, resolveGrokSessionsDir } = await import('@spiracha/lib/grok-db');
+        const sessionsDir = resolveGrokSessionsDir();
+        const results = await Promise.all(
+            data.sessionIds.map((sessionId) => deleteGrokSession(sessionsDir, sessionId)),
+        );
+        const deletedSessionIds = results.flatMap((result) => result.deletedSessionIds);
+        if (deletedSessionIds.length === 0) {
+            throw new Error('No Grok sessions were deleted');
+        }
+
+        return {
+            deletedFiles: results.flatMap((result) => result.deletedFiles),
+            deletedSessionIds,
+        };
+    });

package/apps/ui/src/lib/grok-transcript-events.ts

@@ -0,0 +1,149 @@
+import type { ThreadEvent, ThreadTranscriptStats } from '@spiracha/lib/codex-browser-types';
+import type { GrokSessionTranscript, GrokTranscriptEntry, GrokTranscriptPart } from '@spiracha/lib/grok-exporter-types';
+import { getFinalGrokAssistantTextPartIds, getGrokTextPartPhase } from '@spiracha/lib/grok-transcript-phase';
+import type { JsonValue } from '@spiracha/lib/shared';
+import { getThreadTranscriptStats } from './thread-transcript-stats';
+
+const buildRaw = (
+    entry: GrokTranscriptEntry,
+    part: GrokTranscriptPart,
+    eventType: string,
+): Record<string, JsonValue> => ({
+    entryId: entry.entryId,
+    eventType,
+    role: entry.role,
+    source: 'grok_local_session',
+    type: part.type,
+    ...part.raw,
+});
+
+const buildMessageEvent = (
+    entry: GrokTranscriptEntry,
+    part: GrokTranscriptPart,
+    sequence: number,
+    text: string,
+    finalTextPartIds: Set<string>,
+): ThreadEvent => ({
+    isHiddenByDefault: entry.role !== 'assistant' && entry.role !== 'user',
+    kind: 'message',
+    memoryCitation: null,
+    model: entry.modelId ?? null,
+    phase: getGrokTextPartPhase(entry, part, finalTextPartIds),
+    raw: buildRaw(entry, part, 'message'),
+    role: entry.role,
+    sequence,
+    text,
+    timestamp: entry.timestamp,
+    variant: entry.role === 'user' ? 'user_message' : entry.role === 'assistant' ? 'agent_message' : 'message',
+});
+
+const buildReasoningEvent = (
+    entry: GrokTranscriptEntry,
+    part: GrokTranscriptPart,
+    sequence: number,
+): ThreadEvent | null => {
+    const text = part.text?.trim();
+    if (!text) {
+        return null;
+    }
+
+    return {
+        content: text,
+        hasEncryptedContent: false,
+        kind: 'reasoning',
+        raw: buildRaw(entry, part, 'reasoning'),
+        sequence,
+        summary: [text],
+        timestamp: entry.timestamp,
+    };
+};
+
+const buildToolCallCommand = (part: GrokTranscriptPart): string => {
+    const toolName = part.toolName ?? 'unknown';
+    if (!part.argumentsText?.trim()) {
+        return toolName;
+    }
+
+    return `${toolName}\n${part.argumentsText}`;
+};
+
+const buildToolCallEvent = (entry: GrokTranscriptEntry, part: GrokTranscriptPart, sequence: number): ThreadEvent => ({
+    argumentsParseFailed: false,
+    argumentsText: part.argumentsText ?? null,
+    callId: part.toolCallId ?? null,
+    command: buildToolCallCommand(part),
+    kind: 'tool_call',
+    name: part.toolName ?? 'unknown',
+    raw: buildRaw(entry, part, 'tool_call'),
+    sequence,
+    timestamp: entry.timestamp,
+    workdir: null,
+});
+
+const buildToolOutputEvent = (
+    entry: GrokTranscriptEntry,
+    part: GrokTranscriptPart,
+    sequence: number,
+): ThreadEvent | null => {
+    const outputText = part.outputText?.trim();
+    if (!outputText) {
+        return null;
+    }
+
+    return {
+        callId: part.toolCallId ?? null,
+        exitCode: null,
+        kind: 'tool_output',
+        outputText,
+        raw: buildRaw(entry, part, 'tool_output'),
+        sequence,
+        summary: outputText,
+        timestamp: entry.timestamp,
+        wallTime: null,
+    };
+};
+
+const partToEvents = (
+    entry: GrokTranscriptEntry,
+    part: GrokTranscriptPart,
+    sequence: number,
+    finalTextPartIds: Set<string>,
+): ThreadEvent[] => {
+    if (part.type === 'text') {
+        const text = part.text?.trim();
+        return text ? [buildMessageEvent(entry, part, sequence, text, finalTextPartIds)] : [];
+    }
+
+    if (part.type === 'reasoning') {
+        const event = buildReasoningEvent(entry, part, sequence);
+        return event ? [event] : [];
+    }
+
+    if (part.type === 'tool_call') {
+        return [buildToolCallEvent(entry, part, sequence)];
+    }
+
+    if (part.type === 'tool_result') {
+        const event = buildToolOutputEvent(entry, part, sequence);
+        return event ? [event] : [];
+    }
+
+    return [];
+};
+
+export const grokTranscriptToThreadEvents = (transcript: GrokSessionTranscript): ThreadEvent[] => {
+    const finalTextPartIds = getFinalGrokAssistantTextPartIds(transcript.entries);
+    const events: ThreadEvent[] = [];
+    let sequence = 0;
+    for (const entry of transcript.entries) {
+        for (const part of entry.parts) {
+            events.push(...partToEvents(entry, part, sequence, finalTextPartIds));
+            sequence += 1;
+        }
+    }
+    return events;
+};
+
+export const getGrokThreadTranscriptStats = (events: ThreadEvent[]): ThreadTranscriptStats => {
+    return getThreadTranscriptStats(events);
+};

package/apps/ui/src/lib/kiro-queries.ts

@@ -0,0 +1,22 @@
+import { queryOptions } from '@tanstack/react-query';
+import { getKiroSessionDetailFn, listKiroSessionsFn, listKiroWorkspacesFn } from './kiro-server';
+
+export const kiroWorkspacesQueryOptions = () =>
+    queryOptions({
+        queryFn: () => listKiroWorkspacesFn(),
+        queryKey: ['kiro-workspaces'],
+    });
+
+export const kiroSessionsQueryOptions = (workspaceKey: string | null) =>
+    queryOptions({
+        enabled: workspaceKey !== null,
+        queryFn: () => listKiroSessionsFn({ data: { workspaceKey: workspaceKey ?? '' } }),
+        queryKey: ['kiro-sessions', workspaceKey ?? 'none'],
+    });
+
+export const kiroSessionDetailQueryOptions = (sessionId: string | null) =>
+    queryOptions({
+        enabled: sessionId !== null,
+        queryFn: () => getKiroSessionDetailFn({ data: { sessionId: sessionId ?? '' } }),
+        queryKey: ['kiro-session', sessionId ?? 'none'],
+    });

package/apps/ui/src/lib/kiro-server.ts

@@ -0,0 +1,151 @@
+import { createServerFn } from '@tanstack/react-start';
+import { z } from 'zod';
+import { renderSourceSessionDownload, renderSourceSessionsDownload } from './source-session-export-server';
+
+const workspaceSchema = z.object({
+    workspaceKey: z.string().min(1),
+});
+
+const sessionSchema = z.object({
+    sessionId: z.string().min(1),
+});
+
+const exportSessionSchema = z.object({
+    includeCommentary: z.boolean().default(true),
+    includeMetadata: z.boolean().default(true),
+    includeTools: z.boolean().default(true),
+    outputFormat: z.enum(['md', 'txt']).default('md'),
+    sessionId: z.string().min(1),
+    zipArchive: z.boolean().default(false),
+});
+
+const exportSessionsSchema = z.object({
+    includeCommentary: z.boolean().default(true),
+    includeMetadata: z.boolean().default(true),
+    includeTools: z.boolean().default(true),
+    outputFormat: z.enum(['md', 'txt']).default('md'),
+    sessionIds: z.array(z.string().min(1)).min(1),
+    zipArchive: z.boolean().default(true),
+});
+
+const deleteSessionsSchema = z.object({
+    sessionIds: z.array(z.string().min(1)).min(1),
+});
+
+export const listKiroWorkspacesFn = createServerFn({ method: 'GET' }).handler(async () => {
+    const { listKiroWorkspaceGroups } = await import('@spiracha/lib/kiro-db');
+    return listKiroWorkspaceGroups();
+});
+
+export const listKiroSessionsFn = createServerFn({ method: 'GET' })
+    .validator(workspaceSchema)
+    .handler(async ({ data }) => {
+        const { listKiroSessionsForGroup } = await import('@spiracha/lib/kiro-db');
+        return listKiroSessionsForGroup(data.workspaceKey);
+    });
+
+const loadKiroSessionTranscript = async (sessionId: string) => {
+    const { runWithTranscriptLoadLimit } = await import('@spiracha/lib/transcript-load-limiter');
+    const { readKiroSessionTranscript, resolveKiroWorkspaceSessionsDir } = await import('@spiracha/lib/kiro-db');
+    const sessionsDir = resolveKiroWorkspaceSessionsDir();
+    return runWithTranscriptLoadLimit(
+        async () => {
+            const transcript = await readKiroSessionTranscript(sessionsDir, sessionId);
+            if (!transcript) {
+                throw new Error(`Kiro session not found: ${sessionId}`);
+            }
+
+            return transcript;
+        },
+        {
+            id: sessionId,
+            path: sessionsDir,
+            source: 'kiro-ui',
+        },
+    );
+};
+
+export const getKiroSessionDetailFn = createServerFn({ method: 'GET' })
+    .validator(sessionSchema)
+    .handler(async ({ data }) => {
+        return loadKiroSessionTranscript(data.sessionId);
+    });
+
+export const exportKiroSessionFn = createServerFn({ method: 'POST' })
+    .validator(exportSessionSchema)
+    .handler(async ({ data }) => {
+        const { renderKiroTranscript } = await import('@spiracha/lib/kiro-transcript');
+        const transcript = await loadKiroSessionTranscript(data.sessionId);
+        const content = renderKiroTranscript(transcript, {
+            includeCommentary: data.includeCommentary,
+            includeMetadata: data.includeMetadata,
+            includeTools: data.includeTools,
+            outputFormat: data.outputFormat,
+        });
+
+        if (!content) {
+            throw new Error(`Kiro session has no exportable content: ${data.sessionId}`);
+        }
+
+        return renderSourceSessionDownload({
+            content,
+            cwd: transcript.session.workspacePath ?? transcript.session.worktree,
+            fallbackBaseName: 'kiro-session',
+            outputFormat: data.outputFormat,
+            sessionId: transcript.session.sessionId,
+            updatedAtMs: transcript.session.lastActiveAtMs,
+            zipArchive: data.zipArchive,
+        });
+    });
+
+export const exportKiroSessionsFn = createServerFn({ method: 'POST' })
+    .validator(exportSessionsSchema)
+    .handler(async ({ data }) => {
+        const { renderKiroTranscript } = await import('@spiracha/lib/kiro-transcript');
+        const entries = await Promise.all(
+            data.sessionIds.map(async (sessionId) => {
+                const transcript = await loadKiroSessionTranscript(sessionId);
+                const content = renderKiroTranscript(transcript, {
+                    includeCommentary: data.includeCommentary,
+                    includeMetadata: data.includeMetadata,
+                    includeTools: data.includeTools,
+                    outputFormat: data.outputFormat,
+                });
+
+                if (!content) {
+                    throw new Error(`Kiro session has no exportable content: ${sessionId}`);
+                }
+
+                return {
+                    content,
+                    cwd: transcript.session.workspacePath ?? transcript.session.worktree,
+                    fallbackBaseName: 'kiro-session',
+                    fileBaseName: transcript.session.title || transcript.session.sessionId,
+                    sessionId: transcript.session.sessionId,
+                    updatedAtMs: transcript.session.lastActiveAtMs,
+                };
+            }),
+        );
+
+        return renderSourceSessionsDownload({
+            entries,
+            fallbackBaseName: 'kiro-sessions',
+            outputFormat: data.outputFormat,
+            zipArchive: data.zipArchive,
+        });
+    });
+
+export const deleteKiroSessionFn = createServerFn({ method: 'POST' })
+    .validator(sessionSchema)
+    .handler(async ({ data }) => {
+        const { deleteKiroSession, resolveKiroWorkspaceSessionsDir } = await import('@spiracha/lib/kiro-db');
+        return deleteKiroSession(resolveKiroWorkspaceSessionsDir(), data.sessionId);
+    });
+
+export const deleteKiroSessionsFn = createServerFn({ method: 'POST' })
+    .validator(deleteSessionsSchema)
+    .handler(async ({ data }) => {
+        const { deleteKiroSession, resolveKiroWorkspaceSessionsDir } = await import('@spiracha/lib/kiro-db');
+        const sessionsDir = resolveKiroWorkspaceSessionsDir();
+        return Promise.all(data.sessionIds.map((sessionId) => deleteKiroSession(sessionsDir, sessionId)));
+    });

package/apps/ui/src/lib/kiro-transcript-events.ts

@@ -0,0 +1,113 @@
+import type { ThreadEvent, ThreadTranscriptStats } from '@spiracha/lib/codex-browser-types';
+import type { KiroSessionTranscript, KiroTranscriptEntry, KiroTranscriptPart } from '@spiracha/lib/kiro-exporter-types';
+import { getFinalKiroAssistantMessageEntryIds, getKiroMessagePhase } from '@spiracha/lib/kiro-transcript-phase';
+import type { JsonValue } from '@spiracha/lib/shared';
+import { getThreadTranscriptStats } from './thread-transcript-stats';
+
+const buildRaw = (
+    entry: KiroTranscriptEntry,
+    part: KiroTranscriptPart,
+    eventType: string,
+): Record<string, JsonValue> => ({
+    entryId: entry.entryId,
+    eventType,
+    executionId: entry.executionId,
+    role: entry.role,
+    source: 'kiro_workspace_sessions',
+    type: part.type,
+    ...part.raw,
+});
+
+const buildMessageEvent = (
+    transcript: KiroSessionTranscript,
+    entry: KiroTranscriptEntry,
+    part: KiroTranscriptPart,
+    sequence: number,
+    text: string,
+    phase: Extract<ThreadEvent, { kind: 'message' }>['phase'],
+): ThreadEvent => ({
+    isHiddenByDefault: entry.role !== 'assistant' && entry.role !== 'user',
+    kind: 'message',
+    memoryCitation: null,
+    model: transcript.session.selectedModel ?? transcript.session.defaultModelTitle,
+    phase,
+    raw: buildRaw(entry, part, 'message'),
+    role: entry.role,
+    sequence,
+    text,
+    timestamp: entry.timestamp,
+    variant: entry.role === 'user' ? 'user_message' : entry.role === 'assistant' ? 'agent_message' : 'message',
+});
+
+const getPartString = (part: KiroTranscriptPart, key: string): string | null => {
+    const value = part.raw[key];
+    return typeof value === 'string' && value.trim() ? value : null;
+};
+
+const buildToolCallEvent = (
+    transcript: KiroSessionTranscript,
+    entry: KiroTranscriptEntry,
+    part: KiroTranscriptPart,
+    sequence: number,
+    command: string,
+): ThreadEvent => ({
+    argumentsParseFailed: false,
+    argumentsText: command,
+    callId: entry.entryId,
+    command,
+    kind: 'tool_call',
+    name: getPartString(part, 'toolName') ?? 'kiro_action',
+    raw: buildRaw(entry, part, 'tool_call'),
+    sequence,
+    timestamp: entry.timestamp,
+    workdir: transcript.session.worktree,
+});
+
+const partToEvents = (
+    transcript: KiroSessionTranscript,
+    entry: KiroTranscriptEntry,
+    part: KiroTranscriptPart,
+    sequence: number,
+    finalAssistantMessageEntryIds: Set<string>,
+): ThreadEvent[] => {
+    if (entry.entryType === 'tool_call' && part.type === 'text') {
+        const command = part.text?.trim();
+        return command ? [buildToolCallEvent(transcript, entry, part, sequence, command)] : [];
+    }
+
+    if (part.type === 'text' || part.type === 'image') {
+        const text = part.text?.trim();
+        return text
+            ? [
+                  buildMessageEvent(
+                      transcript,
+                      entry,
+                      part,
+                      sequence,
+                      text,
+                      getKiroMessagePhase(entry, finalAssistantMessageEntryIds),
+                  ),
+              ]
+            : [];
+    }
+
+    return [];
+};
+
+export const kiroTranscriptToThreadEvents = (transcript: KiroSessionTranscript): ThreadEvent[] => {
+    const events: ThreadEvent[] = [];
+    const finalAssistantMessageEntryIds = getFinalKiroAssistantMessageEntryIds(transcript.entries);
+    let sequence = 0;
+
+    for (const entry of transcript.entries) {
+        for (const part of entry.parts) {
+            events.push(...partToEvents(transcript, entry, part, sequence, finalAssistantMessageEntryIds));
+            sequence += 1;
+        }
+    }
+    return events;
+};
+
+export const getKiroThreadTranscriptStats = (events: ThreadEvent[]): ThreadTranscriptStats => {
+    return getThreadTranscriptStats(events);
+};

package/apps/ui/src/lib/opencode-queries.ts

@@ -0,0 +1,37 @@
+import { isRetryableSqliteError } from '@spiracha/lib/sqlite-error';
+import { queryOptions } from '@tanstack/react-query';
+import { getOpenCodeSessionDetailFn, listOpenCodeSessionsFn, listOpenCodeWorkspacesFn } from './opencode-server';
+
+const retrySqliteQuery = (failureCount: number, error: unknown) => {
+    return failureCount < 3 && isRetryableSqliteError(error);
+};
+
+const retryDelay = (attemptIndex: number) => {
+    return [150, 400][attemptIndex] ?? 800;
+};
+
+export const openCodeWorkspacesQueryOptions = () =>
+    queryOptions({
+        queryFn: () => listOpenCodeWorkspacesFn(),
+        queryKey: ['opencode-workspaces'],
+        retry: retrySqliteQuery,
+        retryDelay,
+    });
+
+export const openCodeSessionsQueryOptions = (workspaceKey: string | null) =>
+    queryOptions({
+        enabled: workspaceKey !== null,
+        queryFn: () => listOpenCodeSessionsFn({ data: { workspaceKey: workspaceKey ?? '' } }),
+        queryKey: ['opencode-sessions', workspaceKey ?? 'none'],
+        retry: retrySqliteQuery,
+        retryDelay,
+    });
+
+export const openCodeSessionDetailQueryOptions = (sessionId: string | null) =>
+    queryOptions({
+        enabled: sessionId !== null,
+        queryFn: () => getOpenCodeSessionDetailFn({ data: { sessionId: sessionId ?? '' } }),
+        queryKey: ['opencode-session', sessionId ?? 'none'],
+        retry: retrySqliteQuery,
+        retryDelay,
+    });