@beeuni/sdk 0.1.0 → 0.3.0

package/dist/core/turns/state.js

@@ -185,145 +185,39 @@ export function formatDuration(ms) {
     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;
+export function getTurnTokens(parts) {
+    const tokens = { input: 0, output: 0, reasoning: 0, cacheRead: 0, cacheWrite: 0 };
     let found = false;
+    const add = (usage) => {
+        found = true;
+        tokens.input += usage.input ?? 0;
+        tokens.output += usage.output ?? 0;
+        tokens.reasoning += usage.reasoning ?? 0;
+        tokens.cacheRead += usage.cache?.read ?? 0;
+        tokens.cacheWrite += usage.cache?.write ?? 0;
+    };
+    const stepMessages = new Set();
     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 (part.type !== 'step-finish')
+            continue;
+        const usage = part.tokens;
+        if (!usage)
+            continue;
+        stepMessages.add(message.info.id);
+        add(usage);
     }
-    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')
+    const seen = new Set();
+    for (const { message } of parts) {
+        if (message.info.role !== 'assistant' ||
+            stepMessages.has(message.info.id) ||
+            seen.has(message.info.id))
             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;
+        seen.add(message.info.id);
+        const usage = message.info.tokens;
+        if (usage)
+            add(usage);
     }
-    return totalCost * COST_MARKUP;
+    return found ? tokens : undefined;
 }
 export function formatCost(cost) {
     if (cost === 0)

package/dist/core/turns/tool-kind.d.ts

@@ -1,3 +1,3 @@
-export type ToolKind = 'read' | 'list' | 'glob' | 'grep' | 'write' | 'edit' | 'apply_patch' | 'bash' | 'pty' | 'web_search' | 'webfetch' | 'media' | 'show' | 'task' | 'delegate' | 'sessions' | 'todowrite' | 'question' | 'memory' | 'connectors' | 'automations' | 'projects' | 'skill' | 'context' | 'retired' | 'other';
+export type ToolKind = 'read' | 'list' | 'glob' | 'grep' | 'write' | 'edit' | 'apply_patch' | 'bash' | 'pty' | 'script' | 'web_search' | 'webfetch' | 'media' | 'show' | 'task' | 'delegate' | 'sessions' | 'todowrite' | 'question' | 'memory' | 'connectors' | 'automations' | 'projects' | 'skill' | 'context' | 'retired' | 'other';
 export declare function toolKind(name: string): ToolKind;
 export declare function inputPath(input: Record<string, unknown> | undefined): string | undefined;

package/dist/core/turns/tool-kind.js

@@ -8,9 +8,10 @@ kind('list', ['list', 'ls']);
 kind('glob', ['glob']);
 kind('grep', ['grep']);
 kind('write', ['write']);
-kind('edit', ['edit', 'multiedit', 'morph_edit']);
+kind('edit', ['edit', 'multiedit', 'morph_edit', 'MultiEdit', 'NotebookEdit']);
 kind('apply_patch', ['apply_patch', 'patch']);
 kind('bash', ['bash']);
+kind('script', ['codemode']);
 kind('web_search', ['web_search', 'websearch', 'image_search']);
 kind('webfetch', ['webfetch', 'web_fetch', 'scrape_webpage', 'scrapewebpage']);
 kind('media', ['image_gen', 'video_gen']);
@@ -91,7 +92,7 @@ export function toolKind(name) {
     return 'other';
 }
 export function inputPath(input) {
-    for (const value of [input?.filePath, input?.file_path, input?.path]) {
+    for (const value of [input?.filePath, input?.file_path, input?.path, input?.notebook_path]) {
         if (typeof value === 'string' && value)
             return value;
     }

package/dist/core/turns/tool-registry.js

@@ -47,6 +47,7 @@ const CATEGORY_OF_KIND = {
     apply_patch: 'edit',
     bash: 'shell',
     pty: 'shell',
+    script: 'shell',
     web_search: 'web',
     webfetch: 'web',
     media: 'web',

package/dist/core/turns/tools/tool-meta.d.ts

@@ -1,4 +1,5 @@
 import type { ToolPart } from '../../runtime/client.js';
+import type { ToolCallBlock } from '../../session-log/types.js';
 export declare const CONTEXT_TOOLS: Set<string>;
 export declare function normalizeName(name: string): string;
 export declare function isContextTool(toolName: string): boolean;
@@ -7,7 +8,7 @@ export declare function contextToolSummary(parts: ToolPart[]): {
     search: number;
     list: number;
 };
-export declare function getToolPrimaryArg(part: ToolPart): string;
+export declare function getToolPrimaryArg(call: ToolPart | ToolCallBlock): string;
 export interface ContextToolTriggerLabels {
     read: string;
     search: string;
@@ -24,7 +25,7 @@ export interface ContextToolTriggerLabels {
     workspace: string;
 }
 export declare const DEFAULT_CONTEXT_TOOL_TRIGGER_LABELS: Readonly<ContextToolTriggerLabels>;
-export declare function contextToolTrigger(part: ToolPart, labels?: Partial<ContextToolTriggerLabels>): {
+export declare function contextToolTrigger(call: ToolPart | ToolCallBlock, labels?: Partial<ContextToolTriggerLabels>): {
     title: string;
     subtitle: string;
 };

package/dist/core/turns/tools/tool-meta.js

@@ -1,4 +1,5 @@
 import { toolKind } from '../tool-kind.js';
+import { asToolPart, isToolCallBlock, toolPartOf } from '../../session-log/tool-call.js';
 import { humanizeSearchQuery } from './search-query.js';
 import { stripTrailingSlashes } from '../text-scan.js';
 export const CONTEXT_TOOLS = new Set(['read', 'glob', 'grep', 'list']);
@@ -36,7 +37,8 @@ function truncate(s, max = 60) {
     const trimmed = s.replace(/\s+/g, ' ').trim();
     return trimmed.length > max ? `${trimmed.slice(0, max)}…` : trimmed;
 }
-export function getToolPrimaryArg(part) {
+export function getToolPrimaryArg(call) {
+    const part = asToolPart(call);
     const state = (part.state ?? {});
     const input = (state.input ?? {});
     const key = normalizeName(part.tool);
@@ -100,7 +102,8 @@ export const DEFAULT_CONTEXT_TOOL_TRIGGER_LABELS = {
     worker: 'Worker',
     workspace: 'Workspace',
 };
-export function contextToolTrigger(part, labels = {}) {
+export function contextToolTrigger(call, labels = {}) {
+    const part = isToolCallBlock(call) ? toolPartOf(call) : call;
     const l = { ...DEFAULT_CONTEXT_TOOL_TRIGGER_LABELS, ...labels };
     const n = normalizeName(part.tool);
     const sub = getToolPrimaryArg(part);

package/dist/core/turns/tools/tool-outcome.d.ts

@@ -1,4 +1,5 @@
 import type { ToolPart } from '../../runtime/client.js';
+import type { ToolCallBlock } from '../../session-log/types.js';
 export interface ParsedJsonFailure {
     errorSummary: string;
     hint?: string;
@@ -9,7 +10,7 @@ export interface ParsedJsonFailure {
 export type ToolOutcome = 'ok' | 'partial' | 'failed';
 export declare function looksLikeError(text: string): boolean;
 export declare function isErrorOutput(output: string): boolean;
-export declare function partOutcome(part: Pick<ToolPart, 'state'>): ToolOutcome;
+export declare function partOutcome(call: Pick<ToolPart, 'state'> | ToolCallBlock): ToolOutcome;
 export declare function parseJsonFailure(output: string): ParsedJsonFailure | null;
 export declare function cleanErrorMessage(raw: string): string;
 export declare function formatJsonFailureOutput(output: string): string | null;

package/dist/core/turns/tools/tool-outcome.js

@@ -1,4 +1,5 @@
 import { jsonTail, stripErrorPrefixes } from '../text-scan.js';
+import { isToolCallBlock, toolPartOf } from '../../session-log/tool-call.js';
 function isJsonObject(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
@@ -19,7 +20,8 @@ export function looksLikeError(text) {
 export function isErrorOutput(output) {
     return !!output && (looksLikeError(output) || parseJsonFailure(output) !== null);
 }
-export function partOutcome(part) {
+export function partOutcome(call) {
+    const part = isToolCallBlock(call) ? toolPartOf(call) : call;
     const cached = OUTCOME_CACHE.get(part);
     if (cached && cached.state === part.state)
         return cached.outcome;

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

@@ -79,7 +79,7 @@ export interface ToolInfo {
     subtitle?: string;
 }
 export interface TurnCostInfo {
-    cost: number;
+    cost: number | null;
     tokens: {
         input: number;
         output: number;

package/dist/core/turns/view-model.js

@@ -1,3 +1,4 @@
+import { editBlocks } from './edit-blocks.js';
 import { toolKind } from './tool-kind.js';
 const PRETTY_CAP = 4000;
 function capText(text, max = PRETTY_CAP) {
@@ -144,19 +145,6 @@ function computeLineDiff(oldStr, newStr) {
         lines.push({ type: 'unchanged', text: oldLines[i] });
     return lines;
 }
-function editBlocks(input) {
-    const oldString = firstString(input?.oldString);
-    const newString = firstString(input?.newString);
-    if (oldString !== undefined && newString !== undefined)
-        return [[oldString, newString]];
-    const edits = Array.isArray(input?.edits) ? input.edits : [];
-    return edits.flatMap((edit) => {
-        const e = asRecord(edit);
-        const before = e && firstString(e.oldText);
-        const after = e && firstString(e.newText);
-        return before !== undefined && after !== undefined ? [[before, after]] : [];
-    });
-}
 function fileEditViewModel(tool) {
     const blocks = editBlocks(tool.input);
     const diffs = blocks.map(([before, after]) => computeLineDiff(before, after));

package/dist/core/warm-session-pool.d.ts

@@ -0,0 +1,29 @@
+export interface WarmPoolSession {
+    sessionId: string;
+}
+export interface WarmSessionPoolClient<Session extends WarmPoolSession, ClaimInput> {
+    ensure: (projectId: string, excludeSessionId?: string) => Promise<Session>;
+    claim: (projectId: string, input: ClaimInput) => Promise<unknown>;
+    read: (projectId: string, sessionId: string) => Promise<{
+        metadata?: unknown;
+    } | null>;
+}
+export interface WarmSessionPoolCoreOptions<Session extends WarmPoolSession, Send> {
+    fits: (session: Session, send: Send) => boolean;
+    sleep?: (ms: number) => Promise<void>;
+}
+export interface WarmSessionPoolCore<Session extends WarmPoolSession, Send, ClaimInput> {
+    ensure: (projectId: string, options?: {
+        excludeSessionId?: string;
+    }) => Promise<void>;
+    take: (projectId: string, send: Send, options: {
+        replenish: boolean;
+    }) => Session | null;
+    prime: (projectId: string, session: Session, input: ClaimInput) => Promise<boolean>;
+    dropBySessionId: (sessionId: string) => string | null;
+    revalidate: (projectId: string) => Promise<boolean>;
+    held: (projectId: string) => Session | null;
+    reset: () => void;
+    settled: () => Promise<void>;
+}
+export declare function createWarmSessionPool<Session extends WarmPoolSession, Send, ClaimInput>(client: WarmSessionPoolClient<Session, ClaimInput>, options: WarmSessionPoolCoreOptions<Session, Send>): WarmSessionPoolCore<Session, Send, ClaimInput>;

package/dist/core/warm-session-pool.js

@@ -0,0 +1,127 @@
+function isAmbiguousCreateFailure(code) {
+    return code === 'TIMEOUT' || code === 'request_deadline';
+}
+function errorCode(error) {
+    const code = isRecord(error) ? error.code : undefined;
+    return typeof code === 'string' ? code : undefined;
+}
+const isRecord = (value) => typeof value === 'object' && value !== null;
+function isWarmRow(row) {
+    const metadata = row?.metadata;
+    return !!isRecord(metadata) && metadata.warm === true;
+}
+const COMMIT_CONFIRM_ATTEMPTS = 5;
+const COMMIT_CONFIRM_DELAY_MS = 2_000;
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function confirmCommitted(probe, { attempts = COMMIT_CONFIRM_ATTEMPTS, delayMs = COMMIT_CONFIRM_DELAY_MS, sleep = wait, } = {}) {
+    for (let attempt = 0; attempt < attempts; attempt++) {
+        if (attempt > 0)
+            await sleep(delayMs);
+        try {
+            if (await probe())
+                return true;
+        }
+        catch {
+        }
+    }
+    return false;
+}
+export function createWarmSessionPool(client, options) {
+    const ready = new Map();
+    const creating = new Set();
+    const taken = new Set();
+    const inFlight = new Set();
+    let generation = 0;
+    const runEnsure = (projectId, excludeSessionId, retriesLeft) => {
+        if (creating.has(projectId) || ready.has(projectId))
+            return Promise.resolve();
+        creating.add(projectId);
+        const startedIn = generation;
+        const run = (async () => {
+            let retryExclude = null;
+            try {
+                const session = await client.ensure(projectId, excludeSessionId);
+                if (startedIn !== generation)
+                    return;
+                if (taken.has(session.sessionId))
+                    retryExclude = session.sessionId;
+                else
+                    ready.set(projectId, session);
+            }
+            catch {
+            }
+            finally {
+                if (startedIn === generation)
+                    creating.delete(projectId);
+            }
+            if (retryExclude && retriesLeft > 0) {
+                await runEnsure(projectId, retryExclude, retriesLeft - 1);
+            }
+        })();
+        inFlight.add(run);
+        void run.finally(() => inFlight.delete(run));
+        return run;
+    };
+    return {
+        ensure: (projectId, opts) => runEnsure(projectId, opts?.excludeSessionId, 1),
+        take: (projectId, send, { replenish }) => {
+            const warm = ready.get(projectId);
+            if (!warm)
+                return null;
+            ready.delete(projectId);
+            taken.add(warm.sessionId);
+            if (replenish)
+                void runEnsure(projectId, warm.sessionId, 1);
+            return options.fits(warm, send) ? warm : null;
+        },
+        prime: async (projectId, warm, input) => {
+            try {
+                await client.claim(projectId, input);
+                return true;
+            }
+            catch (error) {
+                if (!isAmbiguousCreateFailure(errorCode(error)))
+                    return false;
+                return confirmCommitted(async () => !isWarmRow(await client.read(projectId, warm.sessionId)), options.sleep ? { sleep: options.sleep } : {});
+            }
+        },
+        dropBySessionId: (sessionId) => {
+            for (const [projectId, warm] of ready) {
+                if (warm.sessionId !== sessionId)
+                    continue;
+                ready.delete(projectId);
+                taken.add(sessionId);
+                return projectId;
+            }
+            return null;
+        },
+        revalidate: async (projectId) => {
+            const held = ready.get(projectId);
+            if (!held)
+                return false;
+            try {
+                if (isWarmRow(await client.read(projectId, held.sessionId)))
+                    return false;
+            }
+            catch {
+                return false;
+            }
+            if (ready.get(projectId)?.sessionId !== held.sessionId)
+                return false;
+            ready.delete(projectId);
+            taken.add(held.sessionId);
+            return true;
+        },
+        held: (projectId) => ready.get(projectId) ?? null,
+        reset: () => {
+            generation += 1;
+            ready.clear();
+            creating.clear();
+            taken.clear();
+        },
+        settled: async () => {
+            while (inFlight.size > 0)
+                await Promise.all([...inFlight]);
+        },
+    };
+}

package/dist/genui/catalog.d.ts

@@ -0,0 +1,28 @@
+import { type Library } from '@openuidev/lang-core';
+import { z } from 'zod/v4';
+import type { GenuiNode } from './types.js';
+export interface GenuiSlot {
+    accepts: readonly string[];
+    min: number;
+    max: number;
+    optional?: boolean;
+    lazy?: boolean;
+}
+export type GenuiChildToMarkdown = (node: GenuiNode) => string;
+export interface GenuiComponentSpec {
+    name: string;
+    block: boolean;
+    container: boolean;
+    slots: Readonly<Record<string, GenuiSlot>>;
+    urls: Readonly<Record<string, 'required' | 'optional'>>;
+    strict: z.ZodType;
+    streaming: z.ZodType;
+    toMarkdown(props: Record<string, any>, child: GenuiChildToMarkdown): string;
+    a11y?(props: Record<string, any>): string;
+}
+export declare const GENUI_BLOCKS: readonly ["Stack", "Card", "Stat", "StatRow", "Table", "Compare", "RankedList", "BarChart", "LineChart", "PieChart", "Map", "Steps", "Checklist", "Tabs", "Accordion", "Badge", "Callout", "Image", "Link"];
+export declare const GENUI_SPECS: Readonly<Record<string, GenuiComponentSpec>>;
+export declare const GENUI_LIBRARY: Library<string>;
+export declare const GENUI_MAX_DEPTH = 4;
+export declare const GENUI_MAX_NODES = 500;
+export declare const GENUI_MAX_SOURCE_CHARS: number;