@beeuni/sdk 0.1.0

package/dist/core/turns/errors.js

@@ -0,0 +1,355 @@
+const GENERIC_ERROR_MESSAGE = 'An error occurred';
+const MAX_UNWRAP_DEPTH = 4;
+const MESSAGE_KEYS = [
+    'message',
+    'error',
+    'detail',
+    'error_description',
+    'msg',
+    'errors',
+    'data',
+];
+function stripErrorPrefixes(str) {
+    let s = str.trim();
+    for (let i = 0; i < MAX_UNWRAP_DEPTH; i++) {
+        const next = s.replace(/^(?:\d{3}\s+)?(?:[A-Za-z_$][\w$]*)?Error:\s*/, '').trim();
+        if (next === s)
+            break;
+        s = next;
+    }
+    return s;
+}
+function tryParseJson(value) {
+    if (typeof value !== 'string' || !value)
+        return undefined;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function messageFieldFromJsonish(str) {
+    const match = str.match(/"(?:message|detail|error_description|msg)"\s*:\s*"((?:[^"\\]|\\.)*)"/);
+    if (!match)
+        return undefined;
+    const literal = tryParseJson(`"${match[1]}"`);
+    return typeof literal === 'string' && literal.trim() ? literal.trim() : undefined;
+}
+function textFromHtml(str) {
+    if (!/^\s*<(?:!doctype|html|head|body)\b/i.test(str))
+        return undefined;
+    const lower = str.toLowerCase();
+    const title = titleFromHtml(str, lower);
+    if (title)
+        return title;
+    const text = visibleTextFromHtml(str, lower);
+    return text ? text.slice(0, 200) : undefined;
+}
+function isTagNameBoundary(code) {
+    if (Number.isNaN(code))
+        return true;
+    const isAlnum = (code >= 48 && code <= 57) || (code >= 65 && code <= 90) || (code >= 97 && code <= 122);
+    return !isAlnum;
+}
+function endOfTag(str, lt) {
+    const gt = str.indexOf('>', lt);
+    return gt === -1 ? str.length : gt + 1;
+}
+function titleFromHtml(str, lower) {
+    let from = 0;
+    for (;;) {
+        const open = lower.indexOf('<title', from);
+        if (open === -1)
+            return undefined;
+        const afterName = open + '<title'.length;
+        if (!isTagNameBoundary(lower.charCodeAt(afterName))) {
+            from = afterName;
+            continue;
+        }
+        const gt = str.indexOf('>', afterName);
+        if (gt === -1)
+            return undefined;
+        const nextTag = str.indexOf('<', gt + 1);
+        if (nextTag !== -1 && lower.startsWith('</title', nextTag)) {
+            const title = str.slice(gt + 1, nextTag).trim();
+            if (title)
+                return title;
+        }
+        from = gt + 1;
+    }
+}
+const NON_VISIBLE_ELEMENTS = ['script', 'style'];
+function visibleTextFromHtml(str, lower) {
+    const parts = [];
+    let i = 0;
+    while (i < str.length) {
+        const lt = str.indexOf('<', i);
+        if (lt === -1) {
+            parts.push(str.slice(i));
+            break;
+        }
+        parts.push(str.slice(i, lt));
+        const skipped = NON_VISIBLE_ELEMENTS.find((tag) => lower.startsWith(`<${tag}`, lt) &&
+            isTagNameBoundary(lower.charCodeAt(lt + tag.length + 1)));
+        if (skipped) {
+            const close = lower.indexOf(`</${skipped}`, lt);
+            i = close === -1 ? str.length : endOfTag(str, close);
+            continue;
+        }
+        i = endOfTag(str, lt);
+    }
+    return parts.join(' ').replace(/\s+/g, ' ').trim();
+}
+function streamParseFailure(str) {
+    if (!str.startsWith('JSON parsing failed: Text:'))
+        return undefined;
+    const model = str.match(/"model"\s*:\s*"([^"\\]{1,120})"/)?.[1]?.trim();
+    return model
+        ? `The response from ${model} could not be read.`
+        : 'The model response could not be read.';
+}
+function humanizeCode(code) {
+    const words = code.replace(/[_-]+/g, ' ').trim();
+    return words ? words.charAt(0).toUpperCase() + words.slice(1) : words;
+}
+function unwrapValue(value, depth, seen) {
+    if (typeof value === 'string')
+        return unwrapString(value, depth, seen);
+    if (value && typeof value === 'object')
+        return unwrapObject(value, depth, seen);
+    return undefined;
+}
+function unwrapString(raw, depth, seen = new WeakSet()) {
+    const str = stripErrorPrefixes(raw);
+    if (!str)
+        return undefined;
+    if (depth >= MAX_UNWRAP_DEPTH)
+        return str;
+    const streamFailure = streamParseFailure(str);
+    if (streamFailure)
+        return streamFailure;
+    const parsed = tryParseJson(str);
+    if (parsed !== undefined) {
+        if (typeof parsed === 'string')
+            return unwrapString(parsed, depth + 1, seen);
+        if (parsed && typeof parsed === 'object')
+            return unwrapObject(parsed, depth + 1, seen);
+        return String(parsed);
+    }
+    const embedded = embeddedJsonSubstring(str);
+    if (embedded) {
+        const parsedEmbedded = tryParseJson(embedded);
+        if (parsedEmbedded && typeof parsedEmbedded === 'object') {
+            const fromEmbedded = unwrapObject(parsedEmbedded, depth + 1, seen);
+            if (fromEmbedded)
+                return fromEmbedded;
+        }
+    }
+    if (str.includes('{')) {
+        const field = messageFieldFromJsonish(str);
+        if (field)
+            return unwrapString(field, depth + 1, seen) ?? field;
+    }
+    return textFromHtml(str) ?? str;
+}
+function unwrapObject(obj, depth, seen = new WeakSet()) {
+    if (depth >= MAX_UNWRAP_DEPTH || seen.has(obj))
+        return undefined;
+    seen.add(obj);
+    if (Array.isArray(obj)) {
+        for (const item of obj) {
+            const fromItem = unwrapValue(item, depth, seen);
+            if (fromItem)
+                return fromItem;
+        }
+        return undefined;
+    }
+    const record = obj;
+    for (const key of MESSAGE_KEYS) {
+        const fromKey = unwrapValue(record[key], depth, seen);
+        if (fromKey)
+            return fromKey;
+    }
+    const code = record.type ?? record.code;
+    if (typeof code === 'string' && code.trim())
+        return humanizeCode(code);
+    const status = record.status ?? record.statusCode ?? record.upstream_status;
+    if (typeof status === 'number' && Number.isFinite(status)) {
+        return `Request failed with status ${status}`;
+    }
+    return undefined;
+}
+export function unwrapError(raw) {
+    if (!raw)
+        return GENERIC_ERROR_MESSAGE;
+    if (typeof raw === 'string')
+        return unwrapString(raw, 0) ?? GENERIC_ERROR_MESSAGE;
+    if (typeof raw === 'object')
+        return unwrapObject(raw, 0) ?? GENERIC_ERROR_MESSAGE;
+    return String(raw);
+}
+export function rawErrorText(raw) {
+    const text = rawTextOf(raw)?.trim();
+    if (!text)
+        return undefined;
+    const sentence = unwrapError(raw);
+    if (text === sentence || stripErrorPrefixes(text) === sentence)
+        return undefined;
+    return text;
+}
+function rawTextOf(raw) {
+    if (typeof raw === 'string')
+        return raw;
+    if (!raw || typeof raw !== 'object')
+        return undefined;
+    const record = raw;
+    const data = record.data;
+    if (data && typeof data === 'object' && !Array.isArray(data)) {
+        const { message, responseBody } = data;
+        const parts = [message, responseBody].filter((part, index, all) => typeof part === 'string' && part.trim() !== '' && all.indexOf(part) === index);
+        if (parts.length > 0)
+            return parts.join('\n\n');
+    }
+    if (typeof record.message === 'string' && record.message)
+        return record.message;
+    try {
+        return JSON.stringify(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
+function embeddedJsonSubstring(str) {
+    const start = str.indexOf('{');
+    const end = str.lastIndexOf('}');
+    if (start === -1 || end === -1 || end <= start)
+        return undefined;
+    return str.slice(start, end + 1);
+}
+function extractErrorFromObject(obj) {
+    if (typeof obj !== 'object' || obj === null || Array.isArray(obj))
+        return undefined;
+    const record = obj;
+    if (typeof record.message === 'string' && record.message)
+        return record.message;
+    if (typeof record.error === 'string' && record.error)
+        return record.error;
+    const data = record.data;
+    if (typeof data?.message === 'string')
+        return data.message;
+    const error = record.error;
+    if (typeof error?.message === 'string')
+        return error.message;
+    return undefined;
+}
+function attemptFailuresFrom(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const failures = [];
+    for (const item of value) {
+        if (!item || typeof item !== 'object' || Array.isArray(item))
+            continue;
+        const failure = item;
+        if (!Number.isInteger(failure.attempt) ||
+            failure.attempt < 1 ||
+            typeof failure.provider !== 'string' ||
+            !failure.provider ||
+            typeof failure.route_model !== 'string' ||
+            !failure.route_model ||
+            typeof failure.resolved_model !== 'string' ||
+            !failure.resolved_model ||
+            typeof failure.stage !== 'string' ||
+            !failure.stage ||
+            (typeof failure.code !== 'string' &&
+                !(typeof failure.code === 'number' && Number.isFinite(failure.code))) ||
+            typeof failure.message !== 'string' ||
+            !failure.message ||
+            (failure.status !== undefined &&
+                (!Number.isInteger(failure.status) ||
+                    failure.status < 100 ||
+                    failure.status > 599))) {
+            continue;
+        }
+        failures.push({
+            attempt: failure.attempt,
+            provider: failure.provider,
+            routeModel: failure.route_model,
+            resolvedModel: failure.resolved_model,
+            stage: failure.stage,
+            ...(typeof failure.status === 'number' ? { status: failure.status } : {}),
+            code: failure.code,
+            message: failure.message,
+        });
+    }
+    return failures.length > 0 ? failures : undefined;
+}
+function gatewayFieldsFrom(obj) {
+    const provider = typeof obj.provider === 'string' && obj.provider ? obj.provider : undefined;
+    const code = typeof obj.code === 'string' && obj.code ? obj.code : undefined;
+    const suggestion = typeof obj.suggestion === 'string' && obj.suggestion ? obj.suggestion : undefined;
+    const upstreamStatus = typeof obj.upstream_status === 'number' ? obj.upstream_status : undefined;
+    const requestId = typeof obj.request_id === 'string' && obj.request_id ? obj.request_id : undefined;
+    const attemptFailures = attemptFailuresFrom(obj.attempt_failures);
+    const requestedModel = typeof obj.requested_model === 'string' && obj.requested_model ? obj.requested_model : undefined;
+    const resolvedModel = typeof obj.resolved_model === 'string' && obj.resolved_model ? obj.resolved_model : undefined;
+    if (!provider &&
+        !code &&
+        !suggestion &&
+        upstreamStatus === undefined &&
+        !requestId &&
+        !attemptFailures)
+        return undefined;
+    const message = (typeof obj.message === 'string' && obj.message) || extractErrorFromObject(obj) || '';
+    return {
+        message, provider, code, suggestion, upstreamStatus, requestId, attemptFailures,
+        ...(requestedModel ? { requestedModel } : {}),
+        ...(resolvedModel ? { resolvedModel } : {}),
+    };
+}
+export function extractGatewayErrorDetails(raw) {
+    if (raw == null)
+        return undefined;
+    if (typeof raw === 'string') {
+        const str = stripErrorPrefixes(raw);
+        const parsed = tryParseJson(str) ?? tryParseJson(embeddedJsonSubstring(str));
+        return parsed !== undefined ? extractGatewayErrorDetails(parsed) : undefined;
+    }
+    if (typeof raw !== 'object')
+        return undefined;
+    const record = raw;
+    const direct = gatewayFieldsFrom(record);
+    const runtimeError = typeof record.name === 'string' && typeof record.data === 'object';
+    if (direct && !runtimeError)
+        return direct;
+    const errorField = record.error;
+    if (errorField && typeof errorField === 'object' && !Array.isArray(errorField)) {
+        const nested = gatewayFieldsFrom(errorField);
+        if (nested)
+            return nested;
+    }
+    const data = record.data;
+    if (data && typeof data.responseBody === 'string') {
+        const parsedBody = tryParseJson(data.responseBody);
+        if (parsedBody !== undefined) {
+            const fromBody = extractGatewayErrorDetails(parsedBody);
+            if (fromBody)
+                return fromBody;
+        }
+    }
+    if (data && typeof data.message === 'string') {
+        const fromMessage = extractGatewayErrorDetails(data.message);
+        if (fromMessage)
+            return fromMessage;
+    }
+    const cause = record.cause;
+    if (cause && typeof cause === 'object') {
+        const causeBody = cause.body;
+        if (causeBody !== undefined) {
+            const fromCause = extractGatewayErrorDetails(causeBody);
+            if (fromCause)
+                return fromCause;
+        }
+    }
+    return direct;
+}

package/dist/core/turns/grouping.d.ts

@@ -0,0 +1,47 @@
+import type { MessageWithPartsLike, PartLike, PartWithMessage, TurnLike } from './types.js';
+export declare function compareMessagesForDisplay(a: {
+    info: {
+        id: string;
+        time?: {
+            created?: number;
+        };
+    };
+}, b: {
+    info: {
+        id: string;
+        time?: {
+            created?: number;
+        };
+    };
+}): number;
+export declare function groupMessagesIntoTurns<M extends MessageWithPartsLike>(input: readonly M[], options?: {
+    pendingMessageIds?: ReadonlySet<string>;
+}): TurnLike<M>[];
+export declare function collectTurnParts<M extends MessageWithPartsLike>(turn: TurnLike<M>): PartWithMessage<M>[];
+export declare function findLastTextPart<P extends PartLike>(parts: ReadonlyArray<{
+    part: P;
+}>): (P & {
+    type: 'text';
+}) | undefined;
+export declare function turnHasSteps(parts: ReadonlyArray<{
+    part: PartLike;
+}>): boolean;
+export declare function getAnsweredQuestionParts<M extends MessageWithPartsLike>(turn: TurnLike<M>, _stepsExpanded: boolean, hasActiveQuestion: boolean): PartWithMessage<M>[];
+export declare function childMapByParent(sessions: ReadonlyArray<{
+    id: string;
+    parentID?: string;
+}>): Map<string, string[]>;
+export declare function sortSessions(now: number): (a: {
+    id: string;
+    time: {
+        updated?: number;
+        created: number;
+    };
+}, b: {
+    id: string;
+    time: {
+        updated?: number;
+        created: number;
+    };
+}) => number;
+export declare function allDescendantIds(childMap: Map<string, string[]>, sessionId: string): string[];

package/dist/core/turns/grouping.js

@@ -0,0 +1,247 @@
+import { isTextPart, isToolPart } from './parts.js';
+import { WIRE_ID_CLOCK_TOLERANCE, wireIdClock } from '../session/wire-message-id.js';
+import { absoluteWireIdClockAt, unwrapWireIdClock } from '../session/wire-id-unwrap.js';
+function placedDisplayClock(message, untimedAnchor) {
+    const clock = wireIdClock(message.info.id) ?? BigInt(0);
+    const created = message.info.time?.created;
+    if (typeof created !== 'number')
+        return unwrapWireIdClock(clock, untimedAnchor);
+    const own = absoluteWireIdClockAt(created);
+    const unwrapped = unwrapWireIdClock(clock, own);
+    const drift = unwrapped > own ? unwrapped - own : own - unwrapped;
+    return drift <= WIRE_ID_CLOCK_TOLERANCE ? unwrapped : own;
+}
+function displaySegment(id) {
+    return wireIdClock(id) === null ? 1 : 0;
+}
+function compareIds(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+export function compareMessagesForDisplay(a, b) {
+    return compareForDisplayAt(a, b, absoluteWireIdClockAt(Date.now()));
+}
+function untimedAnchorOf(messages) {
+    let newest = null;
+    for (const message of messages) {
+        const created = message.info.time?.created;
+        if (typeof created === 'number' && (newest === null || created > newest))
+            newest = created;
+    }
+    return absoluteWireIdClockAt(newest ?? Date.now());
+}
+function compareForDisplayAt(a, b, untimedAnchor) {
+    const segmentA = displaySegment(a.info.id);
+    const segmentB = displaySegment(b.info.id);
+    if (segmentA !== segmentB)
+        return segmentA - segmentB;
+    if (segmentA === 0) {
+        const clockA = placedDisplayClock(a, untimedAnchor);
+        const clockB = placedDisplayClock(b, untimedAnchor);
+        if (clockA !== clockB)
+            return clockA < clockB ? -1 : 1;
+        return compareIds(a.info.id, b.info.id);
+    }
+    const at = typeof a.info.time?.created === 'number' ? a.info.time.created : null;
+    const bt = typeof b.info.time?.created === 'number' ? b.info.time.created : null;
+    if (at === null && bt === null)
+        return 0;
+    if (at === null)
+        return 1;
+    if (bt === null)
+        return -1;
+    if (at !== bt)
+        return at < bt ? -1 : 1;
+    return compareIds(a.info.id, b.info.id);
+}
+export function groupMessagesIntoTurns(input, options) {
+    const pendingOrder = new Map([...(options?.pendingMessageIds ?? [])].map((id, index) => [id, index]));
+    const untimedAnchor = untimedAnchorOf(input);
+    const messages = [...input].sort((a, b) => {
+        const aPending = pendingOrder.get(a.info.id);
+        const bPending = pendingOrder.get(b.info.id);
+        if (aPending !== undefined && bPending !== undefined)
+            return aPending - bPending;
+        if (aPending !== undefined)
+            return 1;
+        if (bPending !== undefined)
+            return -1;
+        return compareForDisplayAt(a, b, untimedAnchor);
+    });
+    const turns = [];
+    const turnsByUserMsgId = new Map();
+    for (const msg of messages) {
+        if (msg.info.role === 'user') {
+            if (turnsByUserMsgId.has(msg.info.id))
+                continue;
+            const turn = { userMessage: msg, assistantMessages: [] };
+            turns.push(turn);
+            turnsByUserMsgId.set(msg.info.id, turn);
+        }
+    }
+    let lastTurn = null;
+    const partialTurns = [];
+    const leadingParentless = [];
+    for (const msg of messages) {
+        if (msg.info.role === 'user') {
+            lastTurn = turnsByUserMsgId.get(msg.info.id) ?? null;
+            continue;
+        }
+        if (msg.info.role !== 'assistant')
+            continue;
+        const assistantMsg = msg.info;
+        const tokens = assistantMsg.tokens;
+        if (!assistantMsg.error &&
+            msg.parts.length === 0 &&
+            tokens?.input === 0 &&
+            tokens.output === 0 &&
+            tokens.reasoning === 0) {
+            continue;
+        }
+        if (assistantMsg.parentID) {
+            const parentTurn = turnsByUserMsgId.get(assistantMsg.parentID);
+            if (parentTurn) {
+                parentTurn.assistantMessages.push(msg);
+                continue;
+            }
+        }
+        if (lastTurn) {
+            lastTurn.assistantMessages.push(msg);
+            continue;
+        }
+        if (assistantMsg.parentID) {
+            const current = partialTurns[partialTurns.length - 1];
+            if (current && current.userMessage.info.id === assistantMsg.parentID) {
+                current.assistantMessages.push(msg);
+            }
+            else {
+                partialTurns.push({
+                    userMessage: unloadedPrompt(assistantMsg.parentID, msg),
+                    assistantMessages: [msg],
+                    partial: true,
+                });
+            }
+            continue;
+        }
+        leadingParentless.push(msg);
+    }
+    if (leadingParentless.length > 0) {
+        const first = turns[0] ?? partialTurns[0];
+        if (first) {
+            first.assistantMessages.unshift(...leadingParentless);
+        }
+        else {
+            const [opening, ...rest] = leadingParentless;
+            turns.push({ userMessage: opening, assistantMessages: rest });
+        }
+    }
+    return partialTurns.length > 0 ? [...partialTurns, ...turns] : turns;
+}
+const unloadedPrompts = new Map();
+const UNLOADED_PROMPT_LIMIT = 256;
+function unloadedPrompt(parentID, firstReply) {
+    const info = firstReply.info;
+    const created = info.time?.created;
+    const key = `${info.sessionID ?? ''}|${parentID}|${created ?? ''}`;
+    const cached = unloadedPrompts.get(key);
+    if (cached)
+        return cached;
+    const prompt = {
+        info: {
+            id: parentID,
+            role: 'user',
+            ...(info.sessionID ? { sessionID: info.sessionID } : {}),
+            ...(typeof created === 'number' ? { time: { created } } : {}),
+        },
+        parts: [],
+    };
+    if (unloadedPrompts.size >= UNLOADED_PROMPT_LIMIT) {
+        const oldest = unloadedPrompts.keys().next().value;
+        if (oldest !== undefined)
+            unloadedPrompts.delete(oldest);
+    }
+    unloadedPrompts.set(key, prompt);
+    return prompt;
+}
+export function collectTurnParts(turn) {
+    const result = [];
+    for (const msg of turn.assistantMessages) {
+        for (const part of msg.parts) {
+            result.push({ part, message: msg });
+        }
+    }
+    return result;
+}
+export function findLastTextPart(parts) {
+    for (let i = parts.length - 1; i >= 0; i--) {
+        const p = parts[i].part;
+        if (isTextPart(p) && p.text?.trim()) {
+            return p;
+        }
+    }
+    return undefined;
+}
+export function turnHasSteps(parts) {
+    return parts.some(({ part }) => part.type === 'tool' ||
+        part.type === 'compaction' ||
+        part.type === 'snapshot' ||
+        part.type === 'patch');
+}
+export function getAnsweredQuestionParts(turn, _stepsExpanded, hasActiveQuestion) {
+    if (hasActiveQuestion)
+        return [];
+    const result = [];
+    for (const msg of turn.assistantMessages) {
+        for (const part of msg.parts) {
+            if (!isToolPart(part))
+                continue;
+            const tp = part;
+            const answers = tp.state?.metadata?.answers;
+            if (tp.tool === 'question' && (answers?.length ?? 0) > 0) {
+                result.push({ part, message: msg });
+            }
+        }
+    }
+    return result;
+}
+export function childMapByParent(sessions) {
+    const map = new Map();
+    for (const session of sessions) {
+        if (!session.parentID)
+            continue;
+        const existing = map.get(session.parentID);
+        if (existing) {
+            existing.push(session.id);
+        }
+        else {
+            map.set(session.parentID, [session.id]);
+        }
+    }
+    return map;
+}
+export function sortSessions(now) {
+    const oneMinuteAgo = now - 60 * 1000;
+    return (a, b) => {
+        const aUpdated = a.time.updated ?? a.time.created;
+        const bUpdated = b.time.updated ?? b.time.created;
+        const aRecent = aUpdated > oneMinuteAgo;
+        const bRecent = bUpdated > oneMinuteAgo;
+        if (aRecent && bRecent)
+            return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+        if (aRecent && !bRecent)
+            return -1;
+        if (!aRecent && bRecent)
+            return 1;
+        return bUpdated - aUpdated;
+    };
+}
+export function allDescendantIds(childMap, sessionId) {
+    const directChildren = childMap.get(sessionId);
+    if (!directChildren || directChildren.length === 0)
+        return [];
+    const result = [];
+    for (const childId of directChildren) {
+        result.push(childId);
+        result.push(...allDescendantIds(childMap, childId));
+    }
+    return result;
+}

package/dist/core/turns/index.d.ts

@@ -0,0 +1,13 @@
+export type * from './types.js';
+export * from './classify.js';
+export * from './errors.js';
+export * from './grouping.js';
+export * from './open-turn.js';
+export * from './parts.js';
+export * from './segments/index.js';
+export * from './shell.js';
+export * from './state.js';
+export * from './tool-kind.js';
+export * from './tool-registry.js';
+export * from './tools/index.js';
+export * from './view-model.js';

package/dist/core/turns/index.js

@@ -0,0 +1,12 @@
+export * from './classify.js';
+export * from './errors.js';
+export * from './grouping.js';
+export * from './open-turn.js';
+export * from './parts.js';
+export * from './segments/index.js';
+export * from './shell.js';
+export * from './state.js';
+export * from './tool-kind.js';
+export * from './tool-registry.js';
+export * from './tools/index.js';
+export * from './view-model.js';

package/dist/core/turns/open-turn.d.ts

@@ -0,0 +1,13 @@
+export interface OpenTurnMessageLike {
+    info: {
+        role: string;
+        id?: string;
+        time?: {
+            completed?: number | null;
+            [key: string]: unknown;
+        } | null;
+        error?: unknown;
+    };
+}
+export declare function isRetryableTurnError(error: unknown): boolean;
+export declare function hasRetryingAssistantTurn(messages: readonly OpenTurnMessageLike[] | undefined): boolean;