@beeuni/sdk 0.1.0

package/dist/core/turns/tools/memory-helpers.js

@@ -0,0 +1,50 @@
+import { hasPhrasePair } from '../text-scan.js';
+export const MEMORY_VERBS = {
+    view: 'View',
+    create: 'Create',
+    str_replace: 'Edit',
+    insert: 'Insert',
+    delete: 'Delete',
+    rename: 'Rename',
+};
+export function memoryRelPath(p) {
+    if (!p)
+        return '';
+    const rel = p
+        .replace(/^\.\//, '')
+        .replace(/^(?:\.beeuni\/)?memory(?:\/|$)/, '')
+        .replace(/\/$/, '');
+    return rel || 'memory';
+}
+export function parseMemoryView(output, viewedPath) {
+    if (!output)
+        return null;
+    const nl = output.indexOf('\n');
+    const header = nl === -1 ? output : output.slice(0, nl);
+    const body = nl === -1 ? '' : output.slice(nl + 1);
+    if (hasPhrasePair(header, 'content of ', ' with line numbers')) {
+        const content = body
+            .split('\n')
+            .map((line) => line.replace(/^\s*\d+(\t|$)/, ''))
+            .join('\n');
+        return { type: 'file', content };
+    }
+    if (/files and directories/i.test(header)) {
+        const root = viewedPath.replace(/\/$/, '');
+        const entries = [];
+        for (const line of body.split('\n')) {
+            if (!line.trim())
+                continue;
+            const tab = line.indexOf('\t');
+            if (tab === -1)
+                continue;
+            const size = line.slice(0, tab).trim();
+            const path = line.slice(tab + 1).trim();
+            if (path === root)
+                continue;
+            entries.push({ size, path, isDir: !/\.\w+$/.test(path) });
+        }
+        return { type: 'dir', entries };
+    }
+    return null;
+}

package/dist/core/turns/tools/patch-summary.d.ts

@@ -0,0 +1,6 @@
+import { type FileVerb } from './file-verb.js';
+export type PatchOp = 'add' | 'update' | 'delete' | 'move';
+export interface PatchVerb extends FileVerb {
+    icon: 'create' | 'delete' | 'edit';
+}
+export declare function patchVerb(types: ReadonlyArray<string | undefined>): PatchVerb;

package/dist/core/turns/tools/patch-summary.js

@@ -0,0 +1,21 @@
+import { FILE_VERBS } from './file-verb.js';
+const VERBS = {
+    add: { ...FILE_VERBS.write, icon: 'create' },
+    delete: { ...FILE_VERBS.delete, icon: 'delete' },
+    move: { ...FILE_VERBS.rename, icon: 'edit' },
+    update: { ...FILE_VERBS.edit, icon: 'edit' },
+};
+const MIXED = { ...FILE_VERBS.change, icon: 'edit' };
+export function patchVerb(types) {
+    if (types.length === 0)
+        return MIXED;
+    const first = normalizeOp(types[0]);
+    for (let i = 1; i < types.length; i++) {
+        if (normalizeOp(types[i]) !== first)
+            return MIXED;
+    }
+    return VERBS[first];
+}
+function normalizeOp(type) {
+    return type === 'add' || type === 'delete' || type === 'move' ? type : 'update';
+}

package/dist/core/turns/tools/presentation-helpers.d.ts

@@ -0,0 +1,15 @@
+export interface PresentationOutput {
+    success: boolean;
+    action: string;
+    error?: string;
+    presentation_name?: string;
+    presentation_path?: string;
+    slide_number?: number;
+    slide_title?: string;
+    slide_file?: string;
+    total_slides?: number;
+    viewer_url?: string;
+    viewer_file?: string;
+    message?: string;
+}
+export declare function parsePresentationOutput(output: string): PresentationOutput | null;

package/dist/core/turns/tools/presentation-helpers.js

@@ -0,0 +1,17 @@
+export function parsePresentationOutput(output) {
+    if (!output)
+        return null;
+    try {
+        return JSON.parse(output);
+    }
+    catch {
+        if (output.startsWith('Error:')) {
+            return {
+                success: false,
+                action: 'unknown',
+                error: output.replace(/^Error:\s*/, ''),
+            };
+        }
+        return null;
+    }
+}

package/dist/core/turns/tools/question-helpers.d.ts

@@ -0,0 +1,9 @@
+export interface ParsedQuestion {
+    question: string;
+    header?: string;
+    options: {
+        label: string;
+        description?: string;
+    }[];
+}
+export declare function parseQuestionAnswersFromOutput(output: string, count: number): string[][] | null;

package/dist/core/turns/tools/question-helpers.js

@@ -0,0 +1,12 @@
+export function parseQuestionAnswersFromOutput(output, count) {
+    if (!output)
+        return null;
+    const pairRegex = /"([^"]*)"="([^"]*)"/g;
+    const found = [];
+    let m;
+    while ((m = pairRegex.exec(output)) !== null)
+        found.push(m[2]);
+    if (found.length === 0)
+        return null;
+    return Array.from({ length: Math.max(count, found.length) }, (_, i) => found[i] ? [found[i]] : []);
+}

package/dist/core/turns/tools/read-helpers.d.ts

@@ -0,0 +1,7 @@
+export interface ParsedReadOutput {
+    path?: string;
+    type?: 'file' | 'directory';
+    content?: string;
+    entries?: string[];
+}
+export declare function parseReadOutput(output: string): ParsedReadOutput | null;

package/dist/core/turns/tools/read-helpers.js

@@ -0,0 +1,24 @@
+import { tagBodyTrimNewline, textBetween } from '../text-scan.js';
+export function parseReadOutput(output) {
+    if (!output)
+        return null;
+    const pathText = textBetween(output, '<path>', '</path>');
+    const path = pathText !== null ? pathText.trim() : undefined;
+    const contentText = tagBodyTrimNewline(output, 'content');
+    if (contentText !== null) {
+        const content = contentText
+            .split('\n')
+            .map((l) => l.replace(/^\s*\d+:\s?/, ''))
+            .join('\n');
+        return { path, type: 'file', content };
+    }
+    const entriesText = tagBodyTrimNewline(output, 'entries');
+    if (entriesText !== null) {
+        const entries = entriesText
+            .split('\n')
+            .map((l) => l.trim())
+            .filter((l) => l && !/^\(\d+\s+entr/i.test(l));
+        return { path, type: 'directory', entries };
+    }
+    return null;
+}

package/dist/core/turns/tools/search-query.d.ts

@@ -0,0 +1 @@
+export declare function humanizeSearchQuery(query: string | undefined | null): string;

package/dist/core/turns/tools/search-query.js

@@ -0,0 +1,73 @@
+const OPERATORS = [
+    'site',
+    'filetype',
+    'ext',
+    'inurl',
+    'allinurl',
+    'intitle',
+    'allintitle',
+    'intext',
+    'allintext',
+    'inanchor',
+    'inbody',
+    'before',
+    'after',
+    'daterange',
+    'related',
+    'cache',
+    'define',
+    'link',
+    'source',
+    'lang',
+    'loc',
+    'location',
+    'imagesize',
+];
+function operatorPattern() {
+    return new RegExp(`(^|\\s)([-+]?)(${OPERATORS.join('|')}):("[^"]*"|\\S+)`, 'gi');
+}
+function negatedTermPattern() {
+    return /(^|\s)-(?:"[^"]*"|\S+)/g;
+}
+function booleanPattern() {
+    return /(^|\s)(?:OR|AND)(?=\s|$)/g;
+}
+function stripQuotes(value) {
+    return value.startsWith('"') && value.endsWith('"') ? value.slice(1, -1) : value;
+}
+function hostOf(value) {
+    return stripQuotes(value)
+        .replace(/^[a-z]+:\/\//i, '')
+        .replace(/^www\./i, '')
+        .replace(/\/.*$/, '')
+        .trim();
+}
+function listPhrase(items) {
+    if (items.length <= 1)
+        return items[0] ?? '';
+    return `${items.slice(0, -1).join(', ')} or ${items[items.length - 1]}`;
+}
+export function humanizeSearchQuery(query) {
+    const raw = typeof query === 'string' ? query.trim() : '';
+    if (!raw)
+        return '';
+    const scopes = [];
+    let rest = raw.replace(operatorPattern(), (_match, lead, sign, name, value) => {
+        if (!sign && name.toLowerCase() === 'site') {
+            const host = hostOf(value);
+            if (host && !scopes.includes(host))
+                scopes.push(host);
+        }
+        return lead;
+    });
+    rest = rest
+        .replace(negatedTermPattern(), '$1')
+        .replace(booleanPattern(), '$1')
+        .replace(/[()]/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+    if (!rest) {
+        return scopes.length > 0 ? listPhrase(scopes) : raw;
+    }
+    return scopes.length > 0 ? `${rest} on ${listPhrase(scopes)}` : rest;
+}

package/dist/core/turns/tools/show-availability.d.ts

@@ -0,0 +1,11 @@
+export type ShowLoadStatus = 'loading' | 'ready' | 'error';
+export interface ShowAvailabilityInput {
+    running: boolean;
+    isCarousel: boolean;
+    contentStatus: ShowLoadStatus;
+    isWebsitePreview: boolean;
+    previewHasError: boolean;
+    previewIsLinkOnly: boolean;
+}
+export declare function isShowContentUnavailable(input: ShowAvailabilityInput): boolean;
+export declare function isShowPayloadEmpty(input: Record<string, unknown> | null | undefined): boolean;

package/dist/core/turns/tools/show-availability.js

@@ -0,0 +1,38 @@
+export function isShowContentUnavailable(input) {
+    const { running, isCarousel, contentStatus, isWebsitePreview, previewHasError, previewIsLinkOnly, } = input;
+    if (running || isCarousel)
+        return false;
+    if (isWebsitePreview)
+        return previewHasError && !previewIsLinkOnly;
+    return contentStatus === 'error';
+}
+function isFilled(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+function hasShowArtifact(payload) {
+    if (!payload || typeof payload !== 'object')
+        return false;
+    const { path, url, content } = payload;
+    return isFilled(path) || isFilled(url) || isFilled(content);
+}
+function parseShowItemsPayload(raw) {
+    if (Array.isArray(raw))
+        return raw.length > 0 ? raw : null;
+    if (typeof raw !== 'string' || !raw.trim())
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) && parsed.length > 0 ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function isShowPayloadEmpty(input) {
+    if (!input)
+        return true;
+    const items = parseShowItemsPayload(input.items);
+    if (items)
+        return !items.some(hasShowArtifact);
+    return !hasShowArtifact(input);
+}

package/dist/core/turns/tools/skill-helpers.d.ts

@@ -0,0 +1,5 @@
+export declare function extractSkillContent(output: string): string;
+export declare function extractSkillFiles(output: string): string[];
+export declare function extractSkillBaseDir(output: string): string;
+export declare function skillInputDir(input: Record<string, unknown>): string;
+export declare function skillDocumentPath(output: string, inputDir?: string, skillName?: string): string | null;

package/dist/core/turns/tools/skill-helpers.js

@@ -0,0 +1,61 @@
+import { labelledValue, stripEdgeSlashes, stripTrailingSlashes, tagAttributes, tagBody, textBetween, textItems } from '../text-scan.js';
+export function extractSkillContent(output) {
+    const body = tagBody(output, 'skill_content');
+    return body !== null ? body.trim() : output;
+}
+export function extractSkillFiles(output) {
+    const listing = textBetween(output, '<skill_files>', '</skill_files>');
+    if (listing === null)
+        return [];
+    return textItems(listing, '<file>', '</file>').map((file) => file.trim());
+}
+function attributeDir(output) {
+    const attributes = tagAttributes(output, 'skill_content');
+    if (attributes === null)
+        return '';
+    for (const key of ['dir', 'directory', 'path', 'base', 'baseDir', 'base_dir']) {
+        const found = attributes.match(new RegExp(`\\b${key}\\s*=\\s*["']([^"']+)["']`, 'i'));
+        if (found?.[1]?.trim())
+            return found[1].trim();
+    }
+    return '';
+}
+function labelledDir(output) {
+    return labelledValue(output, ['Base directory', 'Directory', 'Skill directory'])?.trim() ?? '';
+}
+export function extractSkillBaseDir(output) {
+    return stripTrailingSlashes(attributeDir(output) || labelledDir(output));
+}
+export function skillInputDir(input) {
+    for (const key of ['dir', 'directory', 'path', 'skillPath', 'location']) {
+        const value = input[key];
+        if (typeof value === 'string' && value.trim())
+            return stripTrailingSlashes(value.trim());
+    }
+    return '';
+}
+const SKILLS_DIR = 'skills';
+function conventionalSkillDir(skillName) {
+    const raw = stripEdgeSlashes(skillName?.trim() ?? '');
+    if (!raw || raw.toLowerCase() === 'skill')
+        return '';
+    const segments = raw.split('/').map((s) => s.trim());
+    if (segments.some((s) => s === '..' || s === '.'))
+        return '';
+    const leaf = segments.at(-1) ?? '';
+    if (!leaf)
+        return '';
+    return `${SKILLS_DIR}/${leaf}`;
+}
+export function skillDocumentPath(output, inputDir, skillName) {
+    const stated = stripTrailingSlashes(inputDir?.trim() ?? '') || extractSkillBaseDir(output);
+    const base = stated || conventionalSkillDir(skillName);
+    const listed = extractSkillFiles(output).find((f) => /(^|\/)SKILL\.md$/i.test(f));
+    if (listed) {
+        if (listed.startsWith('/'))
+            return listed;
+        if (base)
+            return `${base}/${listed}`;
+    }
+    return base ? `${base}/SKILL.md` : null;
+}

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

@@ -0,0 +1,30 @@
+import type { ToolPart } from '../../runtime/client.js';
+export declare const CONTEXT_TOOLS: Set<string>;
+export declare function normalizeName(name: string): string;
+export declare function isContextTool(toolName: string): boolean;
+export declare function contextToolSummary(parts: ToolPart[]): {
+    read: number;
+    search: number;
+    list: number;
+};
+export declare function getToolPrimaryArg(part: ToolPart): string;
+export interface ContextToolTriggerLabels {
+    read: string;
+    search: string;
+    list: string;
+    shell: string;
+    edit: string;
+    write: string;
+    fetch: string;
+    webSearch: string;
+    scrape: string;
+    applyPatch: string;
+    task: string;
+    worker: string;
+    workspace: string;
+}
+export declare const DEFAULT_CONTEXT_TOOL_TRIGGER_LABELS: Readonly<ContextToolTriggerLabels>;
+export declare function contextToolTrigger(part: ToolPart, labels?: Partial<ContextToolTriggerLabels>): {
+    title: string;
+    subtitle: string;
+};

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

@@ -0,0 +1,146 @@
+import { toolKind } from '../tool-kind.js';
+import { humanizeSearchQuery } from './search-query.js';
+import { stripTrailingSlashes } from '../text-scan.js';
+export const CONTEXT_TOOLS = new Set(['read', 'glob', 'grep', 'list']);
+export function normalizeName(name) {
+    return name.replace(/^oc-/, '').replace(/-/g, '_');
+}
+export function isContextTool(toolName) {
+    return CONTEXT_TOOLS.has(toolKind(toolName));
+}
+export function contextToolSummary(parts) {
+    let read = 0;
+    let search = 0;
+    let list = 0;
+    for (const part of parts) {
+        const kind = toolKind(part.tool);
+        if (kind === 'read')
+            read++;
+        else if (kind === 'glob' || kind === 'grep')
+            search++;
+        else if (kind === 'list')
+            list++;
+    }
+    return { read, search, list };
+}
+function basename(p) {
+    if (!p)
+        return '';
+    const cleaned = stripTrailingSlashes(p.replace(/\\/g, '/'));
+    const idx = cleaned.lastIndexOf('/');
+    return idx >= 0 ? cleaned.slice(idx + 1) : cleaned;
+}
+function truncate(s, max = 60) {
+    if (!s)
+        return '';
+    const trimmed = s.replace(/\s+/g, ' ').trim();
+    return trimmed.length > max ? `${trimmed.slice(0, max)}…` : trimmed;
+}
+export function getToolPrimaryArg(part) {
+    const state = (part.state ?? {});
+    const input = (state.input ?? {});
+    const key = normalizeName(part.tool);
+    switch (key) {
+        case 'read':
+        case 'edit':
+        case 'write':
+        case 'morph_edit': {
+            const p = input.filePath ?? input.file_path ?? input.path;
+            return p ? basename(String(p)) : '';
+        }
+        case 'glob':
+            return input.pattern ? String(input.pattern) : '';
+        case 'grep': {
+            const pat = input.pattern ?? input.query;
+            const where = input.path ?? input.include;
+            if (pat && where)
+                return `"${truncate(String(pat), 40)}" in ${basename(String(where))}`;
+            if (pat)
+                return `"${truncate(String(pat), 60)}"`;
+            return '';
+        }
+        case 'list':
+            return input.path ? basename(String(input.path)) : '';
+        case 'bash':
+            return truncate(String(input.command ?? ''), 80);
+        default:
+            break;
+    }
+    const fallbackKeys = [
+        'description',
+        'query',
+        'url',
+        'filePath',
+        'file_path',
+        'path',
+        'pattern',
+        'name',
+        'prompt',
+    ];
+    for (const k of fallbackKeys) {
+        const v = input[k];
+        if (typeof v === 'string' && v.length > 0) {
+            return truncate(k === 'query' ? humanizeSearchQuery(v) || v : v, 60);
+        }
+    }
+    return '';
+}
+export const DEFAULT_CONTEXT_TOOL_TRIGGER_LABELS = {
+    read: 'Read',
+    search: 'Search',
+    list: 'List',
+    shell: 'Shell',
+    edit: 'Edit',
+    write: 'Write',
+    fetch: 'Fetch',
+    webSearch: 'Web Search',
+    scrape: 'Scrape',
+    applyPatch: 'Apply Patch',
+    task: 'Task',
+    worker: 'Worker',
+    workspace: 'Workspace',
+};
+export function contextToolTrigger(part, labels = {}) {
+    const l = { ...DEFAULT_CONTEXT_TOOL_TRIGGER_LABELS, ...labels };
+    const n = normalizeName(part.tool);
+    const sub = getToolPrimaryArg(part);
+    switch (n) {
+        case 'read':
+            return { title: l.read, subtitle: sub };
+        case 'glob':
+        case 'grep':
+            return { title: l.search, subtitle: sub };
+        case 'list':
+            return { title: l.list, subtitle: sub };
+        case 'bash':
+            return { title: l.shell, subtitle: sub };
+        case 'edit':
+        case 'morph_edit':
+            return { title: l.edit, subtitle: sub };
+        case 'write':
+            return { title: l.write, subtitle: sub };
+        case 'webfetch':
+        case 'web_fetch':
+            return { title: l.fetch, subtitle: sub };
+        case 'websearch':
+        case 'web_search':
+            return { title: l.webSearch, subtitle: sub };
+        case 'scrape':
+        case 'scrape_webpage':
+            return { title: l.scrape, subtitle: sub };
+        case 'apply_patch':
+            return { title: l.applyPatch, subtitle: sub };
+        case 'task':
+            return { title: l.task, subtitle: sub };
+        case 'session_spawn':
+        case 'session_start_background':
+            return { title: l.worker, subtitle: sub };
+        case 'project_select':
+        case 'project_list':
+            return { title: l.workspace, subtitle: sub };
+        default: {
+            const display = n.replace(/_/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase());
+            return { title: display, subtitle: sub };
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+import type { ToolPart } from '../../runtime/client.js';
+export interface ParsedJsonFailure {
+    errorSummary: string;
+    hint?: string;
+    status?: number;
+    nestedMessage?: string;
+    nestedError?: boolean;
+}
+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 parseJsonFailure(output: string): ParsedJsonFailure | null;
+export declare function cleanErrorMessage(raw: string): string;
+export declare function formatJsonFailureOutput(output: string): string | null;