@beeuni/sdk 0.1.0

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

@@ -0,0 +1,131 @@
+import type { MessageWithParts } from '../../transcript.js';
+import type { Part, ToolPart } from '../runtime/client.js';
+import { type GatewayAttemptFailure } from './errors.js';
+import { type ToolKind } from './tool-kind.js';
+import type { TokenUsageLike } from './types.js';
+export type ToolStatus = 'pending' | 'running' | 'done' | 'error';
+export interface ToolFile {
+    path: string;
+    type?: 'add' | 'update' | 'delete' | 'move';
+    before?: string;
+    after?: string;
+    patch?: string;
+    additions?: number;
+    deletions?: number;
+    movePath?: string;
+}
+export interface ToolView {
+    name: string;
+    kind?: ToolKind;
+    title: string;
+    status: ToolStatus;
+    input?: Record<string, unknown>;
+    output?: string;
+    error?: string;
+    outputParsed?: unknown;
+    outputText?: string;
+    files?: ToolFile[];
+    diff?: string;
+    diagnostics?: Record<string, unknown[]>;
+    answers?: string[][];
+    childSessionId?: string;
+}
+export declare function toToolView(part: Pick<ToolPart, 'tool' | 'state'>): ToolView;
+export interface ClassifiedTextPart {
+    kind: 'text';
+    id: string;
+    text: string;
+    synthetic: boolean;
+}
+export interface ClassifiedReasoningPart {
+    kind: 'reasoning';
+    id: string;
+    text: string;
+}
+export interface ClassifiedToolPart {
+    kind: 'tool';
+    id: string;
+    tool: ToolView;
+}
+export interface ClassifiedFilePart {
+    kind: 'file';
+    id: string;
+    filename?: string;
+    mime: string;
+    url: string;
+    isImage: boolean;
+    isPdf: boolean;
+}
+export interface ClassifiedSubtaskPart {
+    kind: 'subtask';
+    id: string;
+    description: string;
+    agent: string;
+    prompt: string;
+    model?: {
+        providerID: string;
+        modelID: string;
+    };
+}
+export interface ClassifiedPatchPart {
+    kind: 'patch';
+    id: string;
+    hash: string;
+    files: string[];
+    fileCount: number;
+}
+export interface ClassifiedSnapshotPart {
+    kind: 'snapshot';
+    id: string;
+    snapshot: string;
+}
+export interface ClassifiedAgentPart {
+    kind: 'agent';
+    id: string;
+    name: string;
+}
+export interface ClassifiedRetryPart {
+    kind: 'retry';
+    id: string;
+    attempt: number;
+    message: string;
+    createdAt: number;
+}
+export interface ClassifiedCompactionPart {
+    kind: 'compaction';
+    id: string;
+    auto: boolean;
+    overflow: boolean;
+    tailStartId?: string;
+}
+export interface ClassifiedStepPart {
+    kind: 'step';
+    id: string;
+    phase: 'start' | 'finish';
+    snapshot?: string;
+    reason?: string;
+    cost?: number;
+    tokens?: TokenUsageLike;
+}
+export interface ClassifiedUnknownPart {
+    kind: 'unknown';
+    raw: unknown;
+}
+export type ClassifiedPart = ClassifiedTextPart | ClassifiedReasoningPart | ClassifiedToolPart | ClassifiedFilePart | ClassifiedSubtaskPart | ClassifiedPatchPart | ClassifiedSnapshotPart | ClassifiedAgentPart | ClassifiedRetryPart | ClassifiedCompactionPart | ClassifiedStepPart | ClassifiedUnknownPart;
+export declare function classifyPart(part: Part): ClassifiedPart;
+export interface TurnError {
+    name: string;
+    message: string;
+    provider?: string;
+    code?: string;
+    suggestion?: string;
+    upstreamStatus?: number;
+    requestId?: string;
+    attemptFailures?: GatewayAttemptFailure[];
+}
+export interface ClassifiedTurn {
+    parts: ClassifiedPart[];
+    error?: TurnError;
+    isEmpty: boolean;
+}
+export declare function classifyTurn(message: MessageWithParts): ClassifiedTurn;

package/dist/core/turns/classify.js

@@ -0,0 +1,306 @@
+import { extractGatewayErrorDetails, unwrapError } from './errors.js';
+import { getChildSessionId } from './parts.js';
+import { inputPath, toolKind } from './tool-kind.js';
+import { toolInfo } from './tool-registry.js';
+const MAX_PARSEABLE_OUTPUT_LENGTH = 256 * 1024;
+function toolStatus(state) {
+    switch (state.status) {
+        case 'pending':
+            return 'pending';
+        case 'running':
+            return 'running';
+        case 'completed':
+            return 'done';
+        case 'error':
+            return 'error';
+        default: {
+            const _exhaustive = state;
+            return _exhaustive;
+        }
+    }
+}
+function parseToolOutput(rawOutput) {
+    if (rawOutput === undefined)
+        return {};
+    if (rawOutput.length > MAX_PARSEABLE_OUTPUT_LENGTH)
+        return { outputText: rawOutput };
+    try {
+        return { outputParsed: JSON.parse(rawOutput), outputText: rawOutput };
+    }
+    catch {
+        return { outputText: rawOutput };
+    }
+}
+function detectEmbeddedFailure(outputParsed) {
+    if (typeof outputParsed !== 'object' || outputParsed === null || Array.isArray(outputParsed)) {
+        return undefined;
+    }
+    const obj = outputParsed;
+    const failedFlag = obj.success === false;
+    const errorField = obj.error;
+    const hasErrorField = (typeof errorField === 'string' && errorField.length > 0) ||
+        (typeof errorField === 'object' && errorField !== null);
+    if (!failedFlag && !hasErrorField)
+        return undefined;
+    if (hasErrorField)
+        return unwrapError(errorField);
+    if (typeof obj.message === 'string' && obj.message)
+        return obj.message;
+    return 'Tool reported failure';
+}
+const text = (value) => (typeof value === 'string' ? value : undefined);
+const count = (value) => (typeof value === 'number' ? value : undefined);
+const record = (value) => value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+function defined(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, v]) => v !== undefined));
+}
+const FILE_TYPES = new Set(['add', 'update', 'delete', 'move']);
+function toolFiles(kind, input, metadata) {
+    if (kind === 'apply_patch') {
+        const files = Array.isArray(metadata.files) ? metadata.files : [];
+        const out = files.flatMap((raw) => {
+            const f = record(raw);
+            const path = f && (text(f.relativePath) || text(f.filePath));
+            if (!f || !path)
+                return [];
+            const type = text(f.type);
+            return [
+                defined({
+                    path,
+                    type: type && FILE_TYPES.has(type) ? type : undefined,
+                    before: text(f.before),
+                    after: text(f.after),
+                    patch: text(f.patch) ?? text(f.diff),
+                    additions: count(f.additions),
+                    deletions: count(f.deletions),
+                    movePath: text(f.movePath),
+                }),
+            ];
+        });
+        return out.length ? out : undefined;
+    }
+    const path = inputPath(input);
+    if (!path)
+        return undefined;
+    if (kind === 'read')
+        return [{ path }];
+    if (kind === 'write')
+        return [defined({ path, after: text(input.content) })];
+    if (kind !== 'edit')
+        return undefined;
+    const filediff = record(metadata.filediff);
+    const patch = filediff ? undefined : text(metadata.patch);
+    const counts = patch ? patchLineCounts(patch) : undefined;
+    return [
+        defined({
+            path,
+            before: text(filediff?.before) ?? text(input.oldString),
+            after: text(filediff?.after) ?? text(input.newString),
+            patch,
+            additions: count(filediff?.additions) ?? counts?.additions,
+            deletions: count(filediff?.deletions) ?? counts?.deletions,
+        }),
+    ];
+}
+function patchLineCounts(patch) {
+    let additions = 0;
+    let deletions = 0;
+    for (const line of patch.split('\n')) {
+        if (line.startsWith('+') && !line.startsWith('+++'))
+            additions++;
+        else if (line.startsWith('-') && !line.startsWith('---'))
+            deletions++;
+    }
+    return { additions, deletions };
+}
+function toolAnswers(metadata) {
+    const answers = metadata.answers;
+    if (!Array.isArray(answers))
+        return undefined;
+    return answers.map((answer) => (Array.isArray(answer) ? answer.filter((a) => typeof a === 'string') : []));
+}
+function classifyToolState(tool, state) {
+    const liveTitle = 'title' in state ? state.title : undefined;
+    const rawOutput = state.status === 'completed' ? state.output : undefined;
+    const { outputParsed, outputText } = parseToolOutput(rawOutput);
+    let status = toolStatus(state);
+    let error = state.status === 'error' ? state.error : undefined;
+    if (status === 'done') {
+        const embeddedError = detectEmbeddedFailure(outputParsed);
+        if (embeddedError) {
+            status = 'error';
+            error = embeddedError;
+        }
+    }
+    const kind = toolKind(tool);
+    const input = state.input ?? {};
+    const metadata = ('metadata' in state && record(state.metadata)) || {};
+    const diagnostics = record(metadata.diagnostics);
+    return {
+        name: tool,
+        kind,
+        title: liveTitle || toolInfo(tool).label,
+        status,
+        input: state.input,
+        output: rawOutput,
+        outputParsed,
+        outputText,
+        error,
+        files: toolFiles(kind, input, metadata),
+        diff: text(metadata.patch) ?? text(metadata.diff),
+        diagnostics,
+        answers: kind === 'question' ? toolAnswers(metadata) : undefined,
+        childSessionId: getChildSessionId({ tool, state }),
+    };
+}
+export function toToolView(part) {
+    return classifyToolState(part.tool, part.state);
+}
+function classifyText(part) {
+    return { kind: 'text', id: part.id, text: part.text, synthetic: !!part.synthetic };
+}
+function classifyReasoning(part) {
+    return { kind: 'reasoning', id: part.id, text: part.text };
+}
+function classifyTool(part) {
+    return { kind: 'tool', id: part.id, tool: classifyToolState(part.tool, part.state) };
+}
+function classifyFile(part) {
+    const mime = part.mime;
+    return {
+        kind: 'file',
+        id: part.id,
+        filename: part.filename,
+        mime,
+        url: part.url,
+        isImage: mime.startsWith('image/'),
+        isPdf: mime === 'application/pdf',
+    };
+}
+function classifySubtask(part) {
+    return {
+        kind: 'subtask',
+        id: part.id,
+        description: part.description,
+        agent: part.agent,
+        prompt: part.prompt,
+        model: part.model,
+    };
+}
+function classifyPatch(part) {
+    return {
+        kind: 'patch',
+        id: part.id,
+        hash: part.hash,
+        files: part.files,
+        fileCount: part.files.length,
+    };
+}
+function classifySnapshot(part) {
+    return { kind: 'snapshot', id: part.id, snapshot: part.snapshot };
+}
+function classifyAgent(part) {
+    return { kind: 'agent', id: part.id, name: part.name };
+}
+function classifyRetry(part) {
+    return {
+        kind: 'retry',
+        id: part.id,
+        attempt: part.attempt,
+        message: unwrapError(part.error),
+        createdAt: part.time.created,
+    };
+}
+function classifyCompaction(part) {
+    return {
+        kind: 'compaction',
+        id: part.id,
+        auto: part.auto,
+        overflow: !!part.overflow,
+        tailStartId: part.tail_start_id,
+    };
+}
+function classifyStepStart(part) {
+    return { kind: 'step', id: part.id, phase: 'start', snapshot: part.snapshot };
+}
+function classifyStepFinish(part) {
+    return {
+        kind: 'step',
+        id: part.id,
+        phase: 'finish',
+        snapshot: part.snapshot,
+        reason: part.reason,
+        cost: part.cost,
+        tokens: part.tokens,
+    };
+}
+export function classifyPart(part) {
+    switch (part.type) {
+        case 'text':
+            return classifyText(part);
+        case 'reasoning':
+            return classifyReasoning(part);
+        case 'tool':
+            return classifyTool(part);
+        case 'file':
+            return classifyFile(part);
+        case 'subtask':
+            return classifySubtask(part);
+        case 'patch':
+            return classifyPatch(part);
+        case 'snapshot':
+            return classifySnapshot(part);
+        case 'agent':
+            return classifyAgent(part);
+        case 'retry':
+            return classifyRetry(part);
+        case 'compaction':
+            return classifyCompaction(part);
+        case 'step-start':
+            return classifyStepStart(part);
+        case 'step-finish':
+            return classifyStepFinish(part);
+        default: {
+            const _exhaustive = part;
+            return { kind: 'unknown', raw: _exhaustive };
+        }
+    }
+}
+function normalizeTurnError(error) {
+    if (!error)
+        return undefined;
+    const name = typeof error === 'object' &&
+        'name' in error &&
+        typeof error.name === 'string'
+        ? error.name
+        : 'Error';
+    const gateway = extractGatewayErrorDetails(error);
+    return {
+        name,
+        message: gateway?.message || unwrapError(error),
+        provider: gateway?.provider,
+        code: gateway?.code,
+        suggestion: gateway?.suggestion,
+        upstreamStatus: gateway?.upstreamStatus,
+        requestId: gateway?.requestId,
+        attemptFailures: gateway?.attemptFailures,
+    };
+}
+function partHasContent(part) {
+    switch (part.kind) {
+        case 'text':
+        case 'reasoning':
+            return part.text.trim().length > 0;
+        case 'step':
+            return false;
+        default:
+            return true;
+    }
+}
+export function classifyTurn(message) {
+    const parts = message.parts.map(classifyPart);
+    const rawError = message.info.role === 'assistant' ? message.info.error : undefined;
+    const error = normalizeTurnError(rawError);
+    const isEmpty = !error && !parts.some(partHasContent);
+    return { parts, error, isEmpty };
+}

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

@@ -0,0 +1,24 @@
+export declare function unwrapError(raw: unknown): string;
+export declare function rawErrorText(raw: unknown): string | undefined;
+export interface GatewayErrorDetails {
+    message: string;
+    provider?: string;
+    code?: string;
+    suggestion?: string;
+    upstreamStatus?: number;
+    requestId?: string;
+    attemptFailures?: GatewayAttemptFailure[];
+    requestedModel?: string;
+    resolvedModel?: string;
+}
+export interface GatewayAttemptFailure {
+    attempt: number;
+    provider: string;
+    routeModel: string;
+    resolvedModel: string;
+    stage: string;
+    status?: number;
+    code: string | number;
+    message: string;
+}
+export declare function extractGatewayErrorDetails(raw: unknown): GatewayErrorDetails | undefined;