@beeuni/sdk 0.1.0

package/dist/core/turns/segments/group-steps.js

@@ -0,0 +1,65 @@
+import { isEmptyShowPart, isNoGroupActivityTool } from './session-activity-groups.js';
+import { familyForTool, narrateFailedStep, narrateStep } from './narration.js';
+function statusOf(parts) {
+    if (parts.some((p) => p.state?.status === 'running' || p.state?.status === 'pending')) {
+        return 'running';
+    }
+    if (parts.some((p) => p.state?.status === 'error'))
+        return 'error';
+    return 'done';
+}
+function durationOf(parts) {
+    let start = Number.POSITIVE_INFINITY;
+    let end = 0;
+    for (const p of parts) {
+        const time = p.state.time;
+        if (typeof time?.start === 'number')
+            start = Math.min(start, time.start);
+        if (typeof time?.end === 'number')
+            end = Math.max(end, time.end);
+    }
+    if (!Number.isFinite(start) || end <= start)
+        return undefined;
+    return end - start;
+}
+function finalize(family, parts) {
+    const status = statusOf(parts);
+    return {
+        id: parts[0].callID,
+        family,
+        label: status === 'error' ? narrateFailedStep(family, parts) : narrateStep(family, parts),
+        parts,
+        status,
+        durationMs: status === 'running' ? undefined : durationOf(parts),
+    };
+}
+export function groupSteps(parts) {
+    const steps = [];
+    let family = null;
+    let buffer = [];
+    const flush = () => {
+        if (family && buffer.length)
+            steps.push(finalize(family, buffer));
+        family = null;
+        buffer = [];
+    };
+    for (const part of parts) {
+        const f = familyForTool(part.tool);
+        if (f === 'hidden')
+            continue;
+        if (isEmptyShowPart(part))
+            continue;
+        if (isNoGroupActivityTool(part.tool)) {
+            flush();
+            steps.push(finalize(f, [part]));
+            continue;
+        }
+        if (f !== family) {
+            flush();
+            family = f;
+        }
+        buffer.push(part);
+    }
+    flush();
+    return steps;
+}

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

@@ -0,0 +1,12 @@
+export * from './burst-summary.js';
+export * from './compaction-state.js';
+export * from './group-steps.js';
+export * from './merge-steps.js';
+export * from './message-time.js';
+export * from './narration.js';
+export * from './segment-turn.js';
+export * from './session-activity-groups.js';
+export * from './show-group.js';
+export * from './step-label.js';
+export * from './working-turn.js';
+export * from './turn-busy-visibility.js';

package/dist/core/turns/segments/index.js

@@ -0,0 +1,12 @@
+export * from './burst-summary.js';
+export * from './compaction-state.js';
+export * from './group-steps.js';
+export * from './merge-steps.js';
+export * from './message-time.js';
+export * from './narration.js';
+export * from './segment-turn.js';
+export * from './session-activity-groups.js';
+export * from './show-group.js';
+export * from './step-label.js';
+export * from './working-turn.js';
+export * from './turn-busy-visibility.js';

package/dist/core/turns/segments/merge-steps.d.ts

@@ -0,0 +1,21 @@
+import type { Part } from '../../runtime/client.js';
+import { type Step } from './group-steps.js';
+import type { StepTier } from './step-label.js';
+export type BurstStep = {
+    kind: 'thought';
+    key: string;
+    texts: string[];
+    running: boolean;
+    durationMs?: number;
+} | {
+    kind: 'part';
+    key: string;
+    part: Part;
+} | {
+    kind: 'group';
+    key: string;
+    step: Step;
+};
+export declare function reasoningIsRunning(part: Part): boolean;
+export declare function mergeBurstSteps(parts: ReadonlyArray<Part>, tierOf: (part: Part) => StepTier): BurstStep[];
+export declare function flattenThought(texts: ReadonlyArray<string>): string;

package/dist/core/turns/segments/merge-steps.js

@@ -0,0 +1,100 @@
+import { isReasoningPart, isToolPart } from '../parts.js';
+import { groupSteps } from './group-steps.js';
+export function reasoningIsRunning(part) {
+    const end = part.time?.end;
+    return !(typeof end === 'number' && end > 0);
+}
+export function mergeBurstSteps(parts, tierOf) {
+    const steps = [];
+    let pending = null;
+    let tools = [];
+    const flushThought = () => {
+        if (pending && pending.texts.length > 0) {
+            const { startedAt, endedAt } = pending;
+            const durationMs = typeof startedAt === 'number' && typeof endedAt === 'number' && endedAt > startedAt
+                ? endedAt - startedAt
+                : undefined;
+            steps.push({
+                kind: 'thought',
+                key: pending.key,
+                texts: pending.texts,
+                running: pending.running,
+                durationMs,
+            });
+        }
+        pending = null;
+    };
+    const flushTools = () => {
+        if (tools.length === 0)
+            return;
+        for (const step of groupSteps(tools)) {
+            steps.push(step.parts.length === 1
+                ? { kind: 'part', key: step.parts[0].id, part: step.parts[0] }
+                : { kind: 'group', key: `group-${step.parts[0].id}`, step });
+        }
+        tools = [];
+    };
+    for (const part of parts) {
+        if (tierOf(part) === 'plumbing')
+            continue;
+        if (isReasoningPart(part)) {
+            const text = part.text?.trim();
+            if (!text)
+                continue;
+            flushTools();
+            if (!pending)
+                pending = { key: `thought-${part.id}`, texts: [], running: false };
+            pending.texts.push(text);
+            const time = part.time;
+            if (pending.startedAt === undefined && typeof time?.start === 'number') {
+                pending.startedAt = time.start;
+            }
+            pending.endedAt = typeof time?.end === 'number' && time.end > 0 ? time.end : undefined;
+            pending.running = reasoningIsRunning(part);
+            continue;
+        }
+        flushThought();
+        if (isToolPart(part)) {
+            tools.push(part);
+            continue;
+        }
+        flushTools();
+        steps.push({ kind: 'part', key: part.id, part });
+    }
+    flushThought();
+    flushTools();
+    for (let i = 0; i < steps.length - 1; i++) {
+        const step = steps[i];
+        if (step.kind === 'thought')
+            step.running = false;
+    }
+    return steps;
+}
+const ALREADY_THINKING = /^(thinking|thought|considering|planning|deciding|weighing|exploring|analy[sz]ing|reasoning|working out|figuring)/i;
+function stripMarkdown(text) {
+    return text
+        .replace(/```[\s\S]*?```/g, ' ')
+        .replace(/`([^`]*)`/g, '$1')
+        .replace(/^#{1,6}\s*/gm, '')
+        .replace(/\*\*([^*]*)\*\*/g, '$1')
+        .replace(/(^|\s)[*_]([^*_]+)[*_]/g, '$1$2')
+        .replace(/^\s*[-*+]\s+/gm, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+export function flattenThought(texts) {
+    const joined = texts
+        .flatMap((text) => {
+        const stripped = stripMarkdown(text);
+        return stripped ? [stripped] : [];
+    })
+        .join(' ')
+        .trim();
+    if (!joined)
+        return 'Thinking';
+    if (ALREADY_THINKING.test(joined))
+        return joined;
+    const isSentenceCased = /^[A-Z][a-z]/.test(joined);
+    const body = isSentenceCased ? joined[0].toLowerCase() + joined.slice(1) : joined;
+    return `Thinking about ${body}`;
+}

package/dist/core/turns/segments/message-time.d.ts

@@ -0,0 +1,12 @@
+import type { MessageWithParts } from '../../../transcript.js';
+export declare function messageTime(message: MessageWithParts | undefined): {
+    created?: number;
+    completed?: number;
+};
+export declare function messageCreatedAt(message: MessageWithParts | undefined): number | null;
+export interface MessageTimeOptions {
+    timeZone?: string;
+    locale?: string;
+}
+export declare function formatMessageDay(timestamp: number | null | undefined, now: number | null, opts?: MessageTimeOptions): string;
+export declare function formatMessageExact(timestamp: number | null | undefined, opts?: MessageTimeOptions): string;

package/dist/core/turns/segments/message-time.js

@@ -0,0 +1,82 @@
+export function messageTime(message) {
+    return (message?.info?.time ?? {});
+}
+export function messageCreatedAt(message) {
+    const created = messageTime(message).created;
+    if (typeof created !== 'number' || !Number.isFinite(created) || created <= 0)
+        return null;
+    return created;
+}
+const MINUTE = 60_000;
+const WEEK = 7 * 24 * 60 * MINUTE;
+const MINUTES_IN_DAY = 24 * 60;
+function zoneOffsetMs(date) {
+    const utc = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds()));
+    utc.setUTCFullYear(date.getFullYear());
+    return date.getTime() - utc.getTime();
+}
+function relativePast(date, now) {
+    const milliseconds = now.getTime() - date.getTime();
+    const minutes = milliseconds / MINUTE;
+    const plural = (count, unit) => `${count} ${unit}${count === 1 ? '' : 's'} ago`;
+    if (minutes < 60)
+        return plural(Math.round(minutes), 'minute');
+    if (minutes < MINUTES_IN_DAY)
+        return plural(Math.round(minutes / 60), 'hour');
+    const dstNormalizedMinutes = (milliseconds - (zoneOffsetMs(now) - zoneOffsetMs(date))) / MINUTE;
+    return plural(Math.round(dstNormalizedMinutes / MINUTES_IN_DAY), 'day');
+}
+function instant(timestamp) {
+    if (typeof timestamp !== 'number' || !Number.isFinite(timestamp) || timestamp <= 0)
+        return null;
+    const date = new Date(timestamp);
+    return Number.isNaN(date.getTime()) ? null : date;
+}
+const formatters = new Map();
+function formatter(options, opts) {
+    const resolved = { ...options, ...(opts.timeZone ? { timeZone: opts.timeZone } : {}) };
+    const key = `${opts.locale ?? ''}|${JSON.stringify(resolved)}`;
+    let cached = formatters.get(key);
+    if (!cached) {
+        cached = new Intl.DateTimeFormat(opts.locale, resolved);
+        formatters.set(key, cached);
+    }
+    return cached;
+}
+function part(date, options, opts) {
+    return formatter(options, opts)
+        .formatToParts(date)
+        .map((token) => (token.type === 'dayPeriod' ? dayPeriod(token.value, opts) : token.value))
+        .join('');
+}
+function dayPeriod(value, opts) {
+    const latin = /^([ap])\.?\s?m\.?$/i.exec(value.trim());
+    if (latin)
+        return `${latin[1].toUpperCase()}M`;
+    return value.toLocaleUpperCase(opts.locale);
+}
+function yearIn(date, opts) {
+    return part(date, { year: 'numeric' }, opts);
+}
+export function formatMessageDay(timestamp, now, opts = {}) {
+    const date = instant(timestamp);
+    if (!date)
+        return '';
+    const dated = (withYear) => part(date, { month: 'long', day: 'numeric', ...(withYear ? { year: 'numeric' } : {}) }, opts);
+    if (now === null)
+        return dated(true);
+    const elapsed = Math.max(0, now - date.getTime());
+    if (elapsed < MINUTE)
+        return 'just now';
+    if (elapsed < WEEK)
+        return relativePast(date, new Date(now));
+    return dated(yearIn(date, opts) !== yearIn(new Date(now), opts));
+}
+export function formatMessageExact(timestamp, opts = {}) {
+    const date = instant(timestamp);
+    if (!date)
+        return '';
+    const day = part(date, { month: 'long', day: 'numeric', year: 'numeric' }, opts);
+    const clock = part(date, { hour: 'numeric', minute: '2-digit' }, opts);
+    return `${day} ${clock}`;
+}

package/dist/core/turns/segments/narration.d.ts

@@ -0,0 +1,9 @@
+import type { ToolPart } from '../../runtime/client.js';
+export type StepFamily = 'explore' | 'edit' | 'run' | 'web' | 'create' | 'plan' | 'delegate' | 'sessions' | 'memory' | 'connectors' | 'automations' | 'projects' | 'skills' | 'ask' | 'retired' | 'other';
+export declare function familyForTool(toolName: string): StepFamily | 'hidden';
+export declare function narrationToolName(toolName: string): string;
+export declare function contextLabelForTool(toolName: string): string;
+export type CreateArtifactKind = 'image' | 'video' | 'presentation';
+export declare function createArtifactKind(part: ToolPart): CreateArtifactKind | null;
+export declare function narrateStep(family: StepFamily, parts: ToolPart[]): string;
+export declare function narrateFailedStep(family: StepFamily, parts: ToolPart[]): string;