@beeuni/sdk 0.2.0 → 0.3.0

package/dist/core/session-sync/saved-transcript.js

@@ -1,3 +1,58 @@
+import { getSessionTranscriptSync, getSessionTurn, } from '../rest/projects-client/sessions.js';
+import { OPEN_BUNDLE_TRANSCRIPT_LIMIT, claimOpenBundle, heldSavedWindow, holdSavedWindow, openBundleHistory, } from '../session/open-bundle.js';
+export const SAVED_HISTORY_SNAPSHOT_WAIT_MS = 2_000;
+export async function loadSavedTranscript(projectId, sessionId, options = {}) {
+    return heldSavedWindow(projectId, sessionId) ?? readSavedWindow(projectId, sessionId, options);
+}
+async function readSavedWindow(projectId, sessionId, options) {
+    const claimed = claimOpenBundle(projectId, sessionId);
+    let timer;
+    const bundle = claimed
+        ? await Promise.race([
+            claimed,
+            new Promise((resolve) => {
+                timer = setTimeout(resolve, options.snapshotWaitMs ?? SAVED_HISTORY_SNAPSHOT_WAIT_MS, null);
+            }),
+        ]).finally(() => clearTimeout(timer))
+        : null;
+    return ((bundle && openBundleHistory(bundle)) ??
+        getSessionTranscriptSync(projectId, sessionId, {
+            limit: OPEN_BUNDLE_TRANSCRIPT_LIMIT,
+            history: true,
+            signal: options.signal,
+        }));
+}
+export async function readSavedSessionCopy(input) {
+    const { projectId, sessionId, runtimeSessionId } = input;
+    if (!projectId || !sessionId || !runtimeSessionId)
+        return { envelope: null, empty: false };
+    let envelope;
+    try {
+        envelope = await readSavedWindow(projectId, sessionId, {});
+    }
+    catch {
+        return { envelope: null, empty: false };
+    }
+    holdSavedWindow(projectId, sessionId, envelope);
+    if (savedCopyEmptyRoot(envelope) !== runtimeSessionId)
+        return { envelope, empty: false };
+    try {
+        const turn = await getSessionTurn(projectId, sessionId);
+        return {
+            envelope,
+            empty: isEmptyConversation({
+                savedEmptyRoot: runtimeSessionId,
+                rootSessionId: runtimeSessionId,
+                turnRead: true,
+                hasEndedTurn: turn.last_ended != null,
+                hasOpenOrQueuedTurn: turn.turns.length > 0,
+            }),
+        };
+    }
+    catch {
+        return { envelope, empty: false };
+    }
+}
 export function resolveSavedTranscript(input) {
     if (input.hasMessages)
         return 'shown';

package/dist/core/session-sync/session-sync-controller.js

@@ -132,6 +132,9 @@ export class SessionSyncController {
     reconcile(reason = 'manual') {
         if (this.destroyed)
             return Promise.resolve();
+        if (reason === 'visible' && this.streamReliable && this.snapshot.freshness === 'fresh') {
+            return Promise.resolve();
+        }
         if (this.tailRequest)
             return this.tailRequest;
         this.update({

package/dist/core/stream/event-stream.js

@@ -1,4 +1,4 @@
-import { getAuthToken, invalidateTokenCache } from '../http/auth.js';
+import { getAuthToken as getSupabaseAccessToken, invalidateTokenCache } from '../http/auth.js';
 import { getClientForUrl } from '../runtime/client.js';
 import { isAuthFailure } from '../http/api/errors.js';
 import { logger } from '../http/logger.js';
@@ -222,8 +222,8 @@ function createLiveStream(client, opts, subscribers) {
                     schedule();
                     if (t.now() - yieldedAt < YIELD_INTERVAL_MS)
                         continue;
-                    yieldedAt = t.now();
                     await new Promise((resolve) => t.setTimeout(resolve, 0));
+                    yieldedAt = t.now();
                 }
                 stableConnection = streamHadWork;
             }
@@ -241,7 +241,7 @@ function createLiveStream(client, opts, subscribers) {
                 if (isAuthError) {
                     try {
                         invalidateTokenCache();
-                        await getAuthToken();
+                        await getSupabaseAccessToken();
                         logger.info('SSE: refreshed auth token after auth error');
                     }
                     catch (refreshErr) {

package/dist/core/turns/classify.js

@@ -1,6 +1,7 @@
 import { extractGatewayErrorDetails, unwrapError } from './errors.js';
 import { getChildSessionId } from './parts.js';
 import { isToolCallBlock, toolPartOf } from '../session-log/tool-call.js';
+import { editBlocks } from './edit-blocks.js';
 import { inputPath, toolKind } from './tool-kind.js';
 import { toolInfo } from './tool-registry.js';
 const MAX_PARSEABLE_OUTPUT_LENGTH = 256 * 1024;
@@ -92,11 +93,12 @@ function toolFiles(kind, input, metadata) {
     const filediff = record(metadata.filediff);
     const patch = filediff ? undefined : text(metadata.patch);
     const counts = patch ? patchLineCounts(patch) : undefined;
+    const blocks = filediff || patch ? [] : editBlocks(input);
     return [
         defined({
             path,
-            before: text(filediff?.before) ?? text(input.oldString),
-            after: text(filediff?.after) ?? text(input.newString),
+            before: text(filediff?.before) ?? (blocks.length ? blocks.map(([before]) => before).join('\n') : undefined),
+            after: text(filediff?.after) ?? (blocks.length ? blocks.map(([, after]) => after).join('\n') : text(input.new_source)),
             patch,
             additions: count(filediff?.additions) ?? counts?.additions,
             deletions: count(filediff?.deletions) ?? counts?.deletions,

package/dist/core/turns/edit-blocks.d.ts

@@ -0,0 +1 @@
+export declare function editBlocks(input: Record<string, unknown> | undefined): Array<[string, string]>;

package/dist/core/turns/edit-blocks.js

@@ -0,0 +1,15 @@
+export function editBlocks(input) {
+    const one = pair(input);
+    if (one)
+        return [one];
+    const edits = Array.isArray(input?.edits) ? input.edits : [];
+    return edits.flatMap((edit) => {
+        const block = edit && typeof edit === 'object' ? pair(edit) : undefined;
+        return block ? [block] : [];
+    });
+}
+function pair(input) {
+    const before = input?.oldString ?? input?.old_string ?? input?.oldText;
+    const after = input?.newString ?? input?.new_string ?? input?.newText;
+    return typeof before === 'string' && typeof after === 'string' ? [before, after] : undefined;
+}

package/dist/core/turns/segments/burst-summary.d.ts

@@ -7,3 +7,4 @@ export interface BurstSummary {
 }
 export declare function burstSummary(parts: ReadonlyArray<Part>): BurstSummary;
 export declare function burstSummaryLabel(summary: BurstSummary, running: boolean): string;
+export declare function burstWorkLabel(parts: ReadonlyArray<Part>): string;

package/dist/core/turns/segments/burst-summary.js

@@ -1,5 +1,6 @@
 import { isReasoningPart, isToolPart } from '../parts.js';
 import { partOutcome } from '../tools/tool-outcome.js';
+import { familyForTool, narrateStep } from './narration.js';
 import { stepLabel } from './step-label.js';
 export function burstSummary(parts) {
     let total = 0;
@@ -43,3 +44,26 @@ export function burstSummaryLabel(summary, running) {
         return `${steps(total)} failed`;
     return `Completed ${completed} of ${total} steps · ${failed} failed`;
 }
+export function burstWorkLabel(parts) {
+    const families = new Map();
+    let failed = 0;
+    for (const part of parts) {
+        if (!isToolPart(part) || stepLabel(part).tier === 'plumbing')
+            continue;
+        const family = familyForTool(part.tool);
+        if (family === 'hidden')
+            continue;
+        families.set(family, [...(families.get(family) ?? []), part]);
+        if (partOutcome(part) !== 'ok')
+            failed += 1;
+    }
+    if (families.size === 0)
+        return burstSummaryLabel(burstSummary(parts), false);
+    const label = [...families]
+        .map(([family, calls], i) => {
+        const sentence = narrateStep(family, calls);
+        return i === 0 ? sentence : sentence.charAt(0).toLowerCase() + sentence.slice(1);
+    })
+        .join(', ');
+    return failed > 0 ? `${label} · ${failed} failed` : label;
+}

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

@@ -1,11 +1,12 @@
 import type { ToolPart } from '../../runtime/client.js';
+import type { ToolCallBlock } from '../../session-log/types.js';
 import { type StepFamily } from './narration.js';
-export interface Step {
+export interface Step<P extends ToolPart | ToolCallBlock = ToolPart> {
     id: string;
     family: StepFamily;
     label: string;
-    parts: ToolPart[];
+    parts: P[];
     status: 'running' | 'error' | 'done';
     durationMs?: number;
 }
-export declare function groupSteps(parts: ToolPart[]): Step[];
+export declare function groupSteps<P extends ToolPart | ToolCallBlock = ToolPart>(given: P[]): Step<P>[];

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

@@ -1,3 +1,4 @@
+import { asToolPart } from '../../session-log/tool-call.js';
 import { isEmptyShowPart, isNoGroupActivityTool } from './session-activity-groups.js';
 import { familyForTool, narrateFailedStep, narrateStep } from './narration.js';
 function statusOf(parts) {
@@ -22,18 +23,19 @@ function durationOf(parts) {
         return undefined;
     return end - start;
 }
-function finalize(family, parts) {
+function finalize(family, given) {
+    const parts = given.map(asToolPart);
     const status = statusOf(parts);
     return {
         id: parts[0].callID,
         family,
         label: status === 'error' ? narrateFailedStep(family, parts) : narrateStep(family, parts),
-        parts,
+        parts: given,
         status,
         durationMs: status === 'running' ? undefined : durationOf(parts),
     };
 }
-export function groupSteps(parts) {
+export function groupSteps(given) {
     const steps = [];
     let family = null;
     let buffer = [];
@@ -43,7 +45,8 @@ export function groupSteps(parts) {
         family = null;
         buffer = [];
     };
-    for (const part of parts) {
+    for (const item of given) {
+        const part = asToolPart(item);
         const f = familyForTool(part.tool);
         if (f === 'hidden')
             continue;
@@ -51,14 +54,14 @@ export function groupSteps(parts) {
             continue;
         if (isNoGroupActivityTool(part.tool)) {
             flush();
-            steps.push(finalize(f, [part]));
+            steps.push(finalize(f, [item]));
             continue;
         }
         if (f !== family) {
             flush();
             family = f;
         }
-        buffer.push(part);
+        buffer.push(item);
     }
     flush();
     return steps;

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

@@ -1,9 +1,10 @@
 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';
+import type { ToolCallBlock } from '../../session-log/types.js';
+export type StepFamily = 'explore' | 'edit' | 'run' | 'script' | '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;
+export declare function createArtifactKind(call: ToolPart | ToolCallBlock): CreateArtifactKind | null;
+export declare function narrateStep(family: StepFamily, calls: ReadonlyArray<ToolPart | ToolCallBlock>): string;
+export declare function narrateFailedStep(family: StepFamily, calls: ReadonlyArray<ToolPart | ToolCallBlock>): string;

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

@@ -1,3 +1,4 @@
+import { asToolPart } from '../../session-log/tool-call.js';
 import { inputPath, toolKind } from '../tool-kind.js';
 import { getToolPrimaryArg, normalizeName } from '../tools/tool-meta.js';
 import { parseWebSearchOutput, wsDomain } from '../tools/web-helpers.js';
@@ -23,6 +24,7 @@ const FAMILY_OF_KIND = {
     apply_patch: 'edit',
     bash: 'run',
     pty: 'run',
+    script: 'script',
     web_search: 'web',
     webfetch: 'web',
     media: 'create',
@@ -286,7 +288,8 @@ function createPartKey(part) {
     return 'shown:result';
 }
 const PRESENTATION_GEN_ARTIFACT_ACTIONS = new Set(['create_slide', 'export_pdf', 'export_pptx']);
-export function createArtifactKind(part) {
+export function createArtifactKind(call) {
+    const part = asToolPart(call);
     const t = normalizeName(part.tool);
     if (t === 'image_gen')
         return 'image';
@@ -337,7 +340,8 @@ function mixedCreateSentence(keys) {
     });
     return `Worked on ${joinWithAnd(segments)}`;
 }
-export function narrateStep(family, parts) {
+export function narrateStep(family, calls) {
+    const parts = calls.map(asToolPart);
     const n = parts.length;
     const arg = firstArg(parts);
     switch (family) {
@@ -358,6 +362,8 @@ export function narrateStep(family, parts) {
         }
         case 'run':
             return n === 1 ? 'Ran a command' : `Ran ${n} commands`;
+        case 'script':
+            return n === 1 ? 'Ran a script' : `Ran ${n} scripts`;
         case 'web': {
             const isSearch = (p) => {
                 const t = normalizeName(p.tool);
@@ -525,7 +531,8 @@ export function narrateStep(family, parts) {
         }
     }
 }
-export function narrateFailedStep(family, parts) {
+export function narrateFailedStep(family, calls) {
+    const parts = calls.map(asToolPart);
     const arg = firstArg(parts);
     switch (family) {
         case 'explore':
@@ -539,6 +546,8 @@ export function narrateFailedStep(family, parts) {
         }
         case 'run':
             return 'A command failed';
+        case 'script':
+            return 'A script failed';
         case 'web':
             return "Couldn't finish searching the web";
         case 'create':

package/dist/core/turns/segments/session-activity-groups.d.ts

@@ -1,3 +1,4 @@
+import type { ToolCallBlock } from '../../session-log/types.js';
 export declare function normalizeActivityToolName(toolName: string | undefined): string;
 export declare function isShellActivityTool(toolName: string | undefined): boolean;
 export declare function isQuestionTool(toolName: string | undefined): boolean;
@@ -15,6 +16,6 @@ export interface ActivityPartLike {
         input?: Record<string, unknown> | null;
     } | null;
 }
-export declare function isEmptyShowPart(part: ActivityPartLike): boolean;
+export declare function isEmptyShowPart(call: ActivityPartLike | ToolCallBlock): boolean;
 export declare const STANDALONE_TOOLS: ReadonlySet<string>;
 export declare function isStandaloneActivityTool(toolName: string | undefined): boolean;

package/dist/core/turns/segments/session-activity-groups.js

@@ -1,4 +1,5 @@
 import { isShowPayloadEmpty } from '../tools/show-availability.js';
+import { isToolCallBlock, toolPartOf } from '../../session-log/tool-call.js';
 export function normalizeActivityToolName(toolName) {
     return (toolName ?? '').replace(/^oc-/, '').replace(/-/g, '_');
 }
@@ -34,7 +35,8 @@ export function isInvisibleActivityPart(part) {
         return true;
     return false;
 }
-export function isEmptyShowPart(part) {
+export function isEmptyShowPart(call) {
+    const part = isToolCallBlock(call) ? toolPartOf(call) : call;
     const name = normalizeActivityToolName(part.tool);
     if (name !== 'show' && name !== 'show_user')
         return false;

package/dist/core/turns/segments/step-label.d.ts

@@ -1,4 +1,5 @@
 import type { Part } from '../../runtime/client.js';
+import type { SessionLogBlock, ToolCallBlock } from '../../session-log/types.js';
 export type StepTier = 'primary' | 'reasoning' | 'plumbing';
 export interface StepLabel {
     verb: string;
@@ -7,4 +8,4 @@ export interface StepLabel {
     tier: StepTier;
 }
 export declare const PLUMBING_TOOLS: ReadonlySet<string>;
-export declare function stepLabel(part: Part): StepLabel;
+export declare function stepLabel(call: Part | ToolCallBlock | SessionLogBlock): StepLabel;

package/dist/core/turns/segments/step-label.js

@@ -1,6 +1,7 @@
 import { isReasoningPart, isToolPart } from '../parts.js';
 import { humanizeSearchQuery } from '../tools/search-query.js';
 import { normalizeActivityToolName } from './session-activity-groups.js';
+import { isToolCallBlock, toolPartOf } from '../../session-log/tool-call.js';
 export const PLUMBING_TOOLS = new Set([
     'get_mem',
     'memory_search',
@@ -63,7 +64,8 @@ function readObject(input, keys) {
     }
     return undefined;
 }
-export function stepLabel(part) {
+export function stepLabel(call) {
+    const part = (isToolCallBlock(call) ? toolPartOf(call) : call);
     if (isReasoningPart(part)) {
         return { verb: 'Thought', running: 'Thinking', object: undefined, tier: 'reasoning' };
     }

package/dist/core/turns/segments/working-turn.d.ts

@@ -1,4 +1,5 @@
 import type { SessionPrompt } from '../../rest/projects-client/sessions.js';
+import type { SessionLogTurn } from '../../session-log/turns/turn.js';
 interface TurnLike {
     userMessage: {
         info: {
@@ -14,6 +15,7 @@ interface TurnLike {
         };
     }>;
 }
+type BlockTurnLike = Pick<SessionLogTurn, 'id' | 'assistant'>;
 export interface WorkingTurnResolution {
     workingTurnId: string | null;
     pendingTurnIds: string[];
@@ -38,7 +40,7 @@ interface DeliveringTurnInput {
     };
 }
 export declare function fallbackBusyRowAfterTurnId(input: QueuedTurnInput & DeliveringTurnInput & {
-    turns: ReadonlyArray<TurnLike>;
+    turns: ReadonlyArray<TurnLike | BlockTurnLike>;
 }): string | null;
 export declare function turnIsConfirmedActive(input: {
     isTurnWorking: boolean;
@@ -61,7 +63,7 @@ export declare function workingTurnDrawsBusyRow(input: {
     isRetrying: boolean;
     awaitingUser?: boolean;
 }): boolean;
-export declare function freshSendHint(turns: ReadonlyArray<TurnLike>, isSentTurn: (userMessageId: string) => boolean): string | null;
+export declare function freshSendHint(turns: ReadonlyArray<TurnLike | BlockTurnLike>, isSentTurn: (userMessageId: string) => boolean): string | null;
 export declare function resolveWorkingTurn(input: {
     turns: ReadonlyArray<TurnLike>;
     hintMessageId: string | null | undefined;

package/dist/core/turns/segments/working-turn.js

@@ -1,4 +1,6 @@
 import { showTurnBusyIndicator } from './turn-busy-visibility.js';
+const turnIdOf = (turn) => ('id' in turn ? turn.id : turn.userMessage.info.id);
+const replyCountOf = (turn) => ('assistant' in turn ? turn.assistant.length : turn.assistantMessages.length);
 const completedAt = (info) => info.time?.completed;
 export function shouldSuppressWorkingTurnBusy(input) {
     if (!input.hasPendingTurns || !input.newestAssistantCompleted)
@@ -8,18 +10,17 @@ export function shouldSuppressWorkingTurnBusy(input) {
         (input.activeTurnId !== null && input.activeTurnId !== input.workingTurnId));
 }
 function isQueuedTurn(turn, input) {
-    const id = turn.userMessage.info.id;
-    return (input.pendingTurnIds.has(id) ||
-        (turn.assistantMessages.length === 0 && input.pendingPromptIds.has(id)));
+    const id = turnIdOf(turn);
+    return input.pendingTurnIds.has(id) || (replyCountOf(turn) === 0 && input.pendingPromptIds.has(id));
 }
 export function fallbackBusyRowAfterTurnId(input) {
-    const delivering = input.turns.find((turn) => input.deliveringPromptIds.has(turn.userMessage.info.id));
+    const delivering = input.turns.find((turn) => input.deliveringPromptIds.has(turnIdOf(turn)));
     if (delivering)
-        return delivering.userMessage.info.id;
+        return turnIdOf(delivering);
     const firstQueued = input.turns.findIndex((turn) => isQueuedTurn(turn, input));
     if (firstQueued <= 0)
         return null;
-    return input.turns[firstQueued - 1].userMessage.info.id;
+    return turnIdOf(input.turns[firstQueued - 1]);
 }
 export function turnIsConfirmedActive(input) {
     return input.isTurnWorking && !input.pendingDelivery && input.activeTurnId === input.turnId;
@@ -47,10 +48,10 @@ export function workingTurnDrawsBusyRow(input) {
 }
 export function freshSendHint(turns, isSentTurn) {
     for (let i = turns.length - 1; i >= 0; i--) {
-        const id = turns[i].userMessage.info.id;
+        const id = turnIdOf(turns[i]);
         if (!isSentTurn(id))
             continue;
-        return turns[i].assistantMessages.length === 0 ? id : null;
+        return replyCountOf(turns[i]) === 0 ? id : null;
     }
     return null;
 }

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

@@ -8,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;

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

@@ -1,5 +1,5 @@
 import { toolKind } from '../tool-kind.js';
-import { isToolCallBlock, toolPartOf } from '../../session-log/tool-call.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']);
@@ -37,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);

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/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;