@beeuni/sdk 0.1.0

package/dist/core/turns/state.js

@@ -0,0 +1,364 @@
+import { extractGatewayErrorDetails, rawErrorText, unwrapError } from './errors.js';
+import { isReasoningPart, isTextPart, isToolPart } from './parts.js';
+export function isLastUserMessage(messageId, allMessages) {
+    for (let i = allMessages.length - 1; i >= 0; i--) {
+        if (allMessages[i].info.role === 'user') {
+            return allMessages[i].info.id === messageId;
+        }
+    }
+    return false;
+}
+export function getWorkingState(sessionStatus, isLast) {
+    if (!isLast)
+        return false;
+    if (!sessionStatus)
+        return false;
+    return sessionStatus.type !== 'idle';
+}
+export function shouldHideResponsePart(working, responsePartId) {
+    return !working && !!responsePartId;
+}
+export function getTurnError(turn) {
+    for (const msg of turn.assistantMessages) {
+        const info = msg.info;
+        if (info.error) {
+            return extractGatewayErrorDetails(info.error)?.message || unwrapError(info.error);
+        }
+    }
+    return undefined;
+}
+export function getTurnErrorRawText(turn) {
+    for (const msg of turn.assistantMessages) {
+        const info = msg.info;
+        if (info.error)
+            return rawErrorText(info.error);
+    }
+    return undefined;
+}
+export function getTurnErrorDetails(turn) {
+    for (const msg of turn.assistantMessages) {
+        const info = msg.info;
+        if (info.error)
+            return extractGatewayErrorDetails(info.error);
+    }
+    return undefined;
+}
+export function computeStatusFromPart(part) {
+    if (!part)
+        return undefined;
+    if (isToolPart(part)) {
+        switch (part.tool) {
+            case 'task':
+            case 'session_spawn':
+            case 'session_start_background':
+            case 'session-spawn':
+            case 'session-start-background':
+                return 'Handing off to an agent...';
+            case 'agent_spawn':
+            case 'agent-spawn':
+            case 'agent_task':
+            case 'agent-task':
+                return 'Handing off to an agent...';
+            case 'agent_task_update':
+            case 'agent-task-update':
+            case 'task_update':
+            case 'task-update':
+                return 'Updating progress...';
+            case 'agent_message':
+            case 'agent-message':
+            case 'agent_task_message':
+            case 'agent-task-message':
+            case 'task_message':
+            case 'task-message':
+                return 'Checking in with an agent...';
+            case 'task_create':
+            case 'task-create':
+            case 'task_start':
+            case 'task-start':
+                return 'Starting a new task...';
+            case 'task_list':
+            case 'task-list':
+                return 'Reviewing the task list...';
+            case 'task_done':
+            case 'task-done':
+                return 'Updating progress...';
+            case 'todowrite':
+            case 'todoread':
+                return 'Planning...';
+            case 'read':
+                return 'Reading files...';
+            case 'list':
+            case 'grep':
+            case 'glob':
+                return 'Searching files...';
+            case 'webfetch':
+            case 'scrape-webpage':
+                return 'Reading a web page...';
+            case 'websearch':
+            case 'web-search':
+            case 'web_search':
+                return 'Searching the web...';
+            case 'image-search':
+                return 'Searching for images...';
+            case 'image-gen':
+                return 'Creating an image...';
+            case 'video-gen':
+                return 'Creating a video...';
+            case 'presentation-gen':
+                return 'Creating a presentation...';
+            case 'show':
+            case 'show-user':
+                return 'Sharing the result...';
+            case 'edit':
+            case 'write':
+            case 'morph_edit':
+                return 'Making changes...';
+            case 'bash':
+                return 'Working on the computer...';
+            case 'apply_patch':
+                return 'Making changes...';
+            case 'prune':
+                return 'Tidying up memory...';
+            case 'distill':
+                return 'Tidying up memory...';
+            case 'compress':
+                return 'Tidying up memory...';
+            case 'context_info':
+                return 'Refreshing memory...';
+            default:
+                return 'Working on it...';
+        }
+    }
+    if (isReasoningPart(part)) {
+        const text = part.text?.trimStart();
+        if (text) {
+            const match = text.match(/^\*\*(.+?)\*\*/);
+            if (match)
+                return `Thinking about ${match[1].trim()}...`;
+        }
+        return 'Thinking...';
+    }
+    if (isTextPart(part))
+        return 'Gathering thoughts...';
+    return undefined;
+}
+export function getTurnStatus(parts, childMessages) {
+    for (let i = parts.length - 1; i >= 0; i--) {
+        const p = parts[i].part;
+        const tp = isToolPart(p) ? p : undefined;
+        if (tp &&
+            (tp.tool === 'task' ||
+                tp.tool === 'agent_task' ||
+                tp.tool === 'agent-task' ||
+                tp.tool === 'task_create' ||
+                tp.tool === 'task-create' ||
+                tp.tool === 'task_start' ||
+                tp.tool === 'task-start') &&
+            tp.state.status === 'running' &&
+            childMessages &&
+            childMessages.length > 0) {
+            for (let mi = childMessages.length - 1; mi >= 0; mi--) {
+                const childMsg = childMessages[mi];
+                if (childMsg.info.role !== 'assistant')
+                    continue;
+                for (let pi = childMsg.parts.length - 1; pi >= 0; pi--) {
+                    const childStatus = computeStatusFromPart(childMsg.parts[pi]);
+                    if (childStatus)
+                        return childStatus;
+                }
+            }
+            return 'Handing off to an agent...';
+        }
+        const s = computeStatusFromPart(p);
+        if (s)
+            return s;
+    }
+    return 'Figuring out what’s next...';
+}
+export function formatDuration(ms) {
+    if (!Number.isFinite(ms) || ms < 1000)
+        return '';
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    const secs = seconds % 60;
+    return secs > 0 ? `${minutes}m ${secs}s` : `${minutes}m`;
+}
+export const COST_MARKUP = 1.2;
+function estimateTokenCost(tokens, rates) {
+    if (!tokens)
+        return 0;
+    const input = tokens.input ?? 0;
+    const output = (tokens.output ?? 0) + (tokens.reasoning ?? 0);
+    const cacheRead = tokens.cache?.read ?? 0;
+    const cacheWrite = tokens.cache?.write ?? 0;
+    const regularInput = Math.max(0, input - cacheRead - cacheWrite);
+    const tierCandidates = [
+        ...(rates.tiers ?? []),
+        ...(rates.contextOver200k ? [rates.contextOver200k] : []),
+    ]
+        .filter((tier) => input > tier.contextThreshold)
+        .sort((a, b) => b.contextThreshold - a.contextThreshold);
+    const effective = tierCandidates[0] ?? rates;
+    let cost = (regularInput / 1_000_000) * effective.inputPer1M;
+    cost += (output / 1_000_000) * effective.outputPer1M;
+    if (cacheRead > 0) {
+        cost += (cacheRead / 1_000_000) * (effective.cacheReadPer1M ?? effective.inputPer1M);
+    }
+    if (cacheWrite > 0) {
+        cost += (cacheWrite / 1_000_000) * (effective.cacheWritePer1M ?? effective.inputPer1M);
+    }
+    return cost;
+}
+function isSubscriptionUsage(providerID, modelID) {
+    return (providerID === 'codex' ||
+        providerID === 'openai-codex' ||
+        (providerID === 'beeuni' && !!modelID?.startsWith('codex/')));
+}
+function stepFinishRawCost(sfp, providerID, modelID, lookup) {
+    if (isSubscriptionUsage(providerID, modelID))
+        return 0;
+    const reported = sfp.cost || 0;
+    if (reported > 0)
+        return reported;
+    if (!lookup || !providerID || !modelID)
+        return 0;
+    const rates = lookup(providerID, modelID);
+    if (!rates)
+        return 0;
+    return estimateTokenCost(sfp.tokens, rates);
+}
+function assistantMessageIds(message) {
+    if (message.role !== 'assistant')
+        return {};
+    const assistant = message;
+    return { providerID: assistant.providerID, modelID: assistant.modelID };
+}
+export function getTurnCost(parts, lookup) {
+    let totalCost = 0;
+    let input = 0;
+    let output = 0;
+    let reasoning = 0;
+    let cacheRead = 0;
+    let cacheWrite = 0;
+    let found = false;
+    for (const { part, message } of parts) {
+        if (part.type === 'step-finish') {
+            found = true;
+            const sfp = part;
+            const { providerID, modelID } = assistantMessageIds(message.info);
+            totalCost += stepFinishRawCost(sfp, providerID, modelID, lookup);
+            input += sfp.tokens?.input || 0;
+            output += sfp.tokens?.output || 0;
+            reasoning += sfp.tokens?.reasoning || 0;
+            cacheRead += sfp.tokens?.cache?.read || 0;
+            cacheWrite += sfp.tokens?.cache?.write || 0;
+        }
+    }
+    if (!found) {
+        const seen = new Set();
+        for (const { message } of parts) {
+            if (message.info.role !== 'assistant')
+                continue;
+            const assistant = message.info;
+            if (seen.has(assistant.id))
+                continue;
+            seen.add(assistant.id);
+            const stepCost = assistantTokensCost(assistant, lookup);
+            const subscriptionTokens = assistant.tokens && isSubscriptionUsage(assistant.providerID, assistant.modelID);
+            if (stepCost <= 0 && !subscriptionTokens)
+                continue;
+            found = true;
+            totalCost += stepCost;
+            const t = assistant.tokens;
+            if (t) {
+                input += t.input ?? 0;
+                output += t.output ?? 0;
+                reasoning += t.reasoning ?? 0;
+                cacheRead += t.cache?.read ?? 0;
+                cacheWrite += t.cache?.write ?? 0;
+            }
+        }
+    }
+    if (!found)
+        return undefined;
+    return {
+        cost: totalCost * COST_MARKUP,
+        tokens: { input, output, reasoning, cacheRead, cacheWrite },
+    };
+}
+function assistantTokensCost(assistant, lookup) {
+    if (isSubscriptionUsage(assistant.providerID, assistant.modelID))
+        return 0;
+    if (!lookup || !assistant.providerID || !assistant.modelID || !assistant.tokens)
+        return 0;
+    const rates = lookup(assistant.providerID, assistant.modelID);
+    if (!rates)
+        return 0;
+    return estimateTokenCost({
+        input: assistant.tokens.input,
+        output: assistant.tokens.output,
+        reasoning: assistant.tokens.reasoning,
+        cache: assistant.tokens.cache,
+    }, rates);
+}
+export function getSessionCost(messages, lookup) {
+    let totalCost = 0;
+    for (const msg of messages) {
+        if (msg.info?.role !== 'assistant')
+            continue;
+        const assistant = msg.info;
+        const { providerID, modelID } = assistantMessageIds(assistant);
+        let msgCost = 0;
+        let sawStepFinish = false;
+        for (const part of msg.parts) {
+            if (part.type !== 'step-finish')
+                continue;
+            sawStepFinish = true;
+            msgCost += stepFinishRawCost(part, providerID, modelID, lookup);
+        }
+        if (!sawStepFinish) {
+            msgCost += assistantTokensCost(assistant, lookup);
+        }
+        totalCost += msgCost;
+    }
+    return totalCost * COST_MARKUP;
+}
+export function formatCost(cost) {
+    if (cost === 0)
+        return '$0.00';
+    if (cost < 0.001)
+        return `$${cost.toFixed(4)}`;
+    if (cost < 0.01)
+        return `$${cost.toFixed(3)}`;
+    return `$${cost.toFixed(2)}`;
+}
+export function formatTokens(tokens) {
+    if (tokens < 1000)
+        return String(tokens);
+    if (tokens < 10000)
+        return `${(tokens / 1000).toFixed(1)}k`;
+    return `${Math.round(tokens / 1000)}k`;
+}
+export function getRetryInfo(status) {
+    if (!status || status.type !== 'retry')
+        return undefined;
+    const retry = status;
+    const fullMessage = unwrapError(retry.message);
+    return {
+        attempt: retry.attempt,
+        message: fullMessage.length > 60 ? `${fullMessage.slice(0, 60)}...` : fullMessage,
+        next: retry.next,
+        details: extractGatewayErrorDetails(retry.message),
+    };
+}
+export function getRetryMessage(status) {
+    if (!status || status.type !== 'retry')
+        return undefined;
+    return unwrapError(status.message);
+}
+export function hasDiffs(userMessage) {
+    const summary = userMessage.info.summary;
+    return (summary?.diffs?.length ?? 0) > 0;
+}

package/dist/core/turns/text-scan.d.ts

@@ -0,0 +1,21 @@
+export declare function stripTrailingSlashes(s: string): string;
+export declare function stripEdgeSlashes(s: string): string;
+export declare function textBetween(s: string, open: string, close: string): string | null;
+export declare function tagBodyTrimNewline(s: string, tag: string): string | null;
+export declare function tagAttributes(s: string, tag: string): string | null;
+export declare function tagBody(s: string, tag: string): string | null;
+export declare function removeTagBlocks(s: string, tag: string): string;
+export declare function textItems(s: string, open: string, close: string): string[];
+export declare function jsonTail(s: string): string | null;
+export declare function hasPhrasePair(s: string, first: string, second: string): boolean;
+export declare function labelledValue(s: string, labels: readonly string[]): string | null;
+export declare function taskRow(s: string): {
+    id: string;
+    title: string;
+    status: string;
+} | null;
+export declare function stripErrorPrefixes(s: string): string;
+export declare function stripMarkdownImages(s: string): string;
+export declare function unwrapMarkdownLinks(s: string): string;
+export declare function urlError(s: string, url: string): string | null;
+export declare function foldForTest(s: string): string;