@bolt-foundry/gambit 0.8.6-rc.6 → 0.8.6

package/script/simulator-ui/mutations/GambitWorkspaceVerifyBatchRunCreateMutation.d.ts

@@ -1,173 +0,0 @@
-export declare const gambitWorkspaceVerifyBatchRunCreateMutation: import("../src/hooks/defineGambitMutation.js").GambitMutationDefinition<import("../__generated__/__isograph/Mutation/GambitWorkspaceVerifyBatchRunCreate/param_type.js").Mutation__GambitWorkspaceVerifyBatchRunCreate__param, {
-    readonly workspace: {
-        readonly id: string;
-        readonly scenarioDecks: ReadonlyArray<{
-            readonly id: string;
-            readonly label: string;
-            readonly description: (string | null);
-            readonly path: string;
-        }>;
-        readonly verification: {
-            readonly graderDecks: {
-                readonly edges: ReadonlyArray<{
-                    readonly node: {
-                        readonly id: string;
-                        readonly label: string;
-                        readonly description: (string | null);
-                        readonly path: string;
-                    };
-                }>;
-            };
-            readonly batches: {
-                readonly edges: ReadonlyArray<{
-                    readonly node: {
-                        readonly id: string;
-                        readonly workspaceId: string;
-                        readonly scenarioDeckId: (string | null);
-                        readonly graderId: string;
-                        readonly scenarioRuns: number;
-                        readonly graderRepeatsPerScenario: number;
-                        readonly status: string;
-                        readonly startedAt: (string | null);
-                        readonly finishedAt: (string | null);
-                        readonly requested: number;
-                        readonly active: number;
-                        readonly completed: number;
-                        readonly failed: number;
-                        readonly scenarioRunsCompleted: number;
-                        readonly scenarioRunsFailed: number;
-                        readonly requests: {
-                            readonly edges: ReadonlyArray<{
-                                readonly node: {
-                                    readonly id: string;
-                                    readonly scenarioRunId: (string | null);
-                                    readonly status: string;
-                                    readonly runId: (string | null);
-                                    readonly error: (string | null);
-                                };
-                            }>;
-                        };
-                        readonly metrics: ({
-                            readonly scenarioRunCountRequested: number;
-                            readonly scenarioRunCountCompleted: number;
-                            readonly scenarioRunCountFailed: number;
-                            readonly gradeSampleCountRequested: number;
-                            readonly gradeSampleCountCompleted: number;
-                            readonly gradeSampleCountFailed: number;
-                            readonly executionFailureCount: number;
-                            readonly gradingFailureCount: number;
-                            readonly passRate: (number | null);
-                            readonly scoreMin: (number | null);
-                            readonly scoreMedian: (number | null);
-                            readonly scoreMax: (number | null);
-                            readonly scoreMean: (number | null);
-                            readonly outlierScenarioRuns: {
-                                readonly edges: ReadonlyArray<{
-                                    readonly node: {
-                                        readonly key: string;
-                                        readonly scenarioRunId: string;
-                                        readonly gradeSampleCount: number;
-                                        readonly completedSampleCount: number;
-                                        readonly executionFailureCount: number;
-                                        readonly gradingFailureCount: number;
-                                        readonly averageScore: (number | null);
-                                        readonly minScore: (number | null);
-                                        readonly maxScore: (number | null);
-                                        readonly failed: boolean;
-                                        readonly minRunId: (string | null);
-                                        readonly maxRunId: (string | null);
-                                        readonly messageRefId: (string | null);
-                                    };
-                                }>;
-                            };
-                            readonly failureReasons: {
-                                readonly edges: ReadonlyArray<{
-                                    readonly node: {
-                                        readonly key: string;
-                                        readonly kind: string;
-                                        readonly reason: string;
-                                        readonly count: number;
-                                    };
-                                }>;
-                            };
-                        } | null);
-                    };
-                }>;
-            };
-        };
-    };
-    readonly batch: {
-        readonly id: string;
-        readonly workspaceId: string;
-        readonly scenarioDeckId: (string | null);
-        readonly graderId: string;
-        readonly scenarioRuns: number;
-        readonly graderRepeatsPerScenario: number;
-        readonly status: string;
-        readonly startedAt: (string | null);
-        readonly finishedAt: (string | null);
-        readonly requested: number;
-        readonly active: number;
-        readonly completed: number;
-        readonly failed: number;
-        readonly scenarioRunsCompleted: number;
-        readonly scenarioRunsFailed: number;
-        readonly requests: {
-            readonly edges: ReadonlyArray<{
-                readonly node: {
-                    readonly id: string;
-                    readonly scenarioRunId: (string | null);
-                    readonly status: string;
-                    readonly runId: (string | null);
-                    readonly error: (string | null);
-                };
-            }>;
-        };
-        readonly metrics: ({
-            readonly scenarioRunCountRequested: number;
-            readonly scenarioRunCountCompleted: number;
-            readonly scenarioRunCountFailed: number;
-            readonly gradeSampleCountRequested: number;
-            readonly gradeSampleCountCompleted: number;
-            readonly gradeSampleCountFailed: number;
-            readonly executionFailureCount: number;
-            readonly gradingFailureCount: number;
-            readonly passRate: (number | null);
-            readonly scoreMin: (number | null);
-            readonly scoreMedian: (number | null);
-            readonly scoreMax: (number | null);
-            readonly scoreMean: (number | null);
-            readonly outlierScenarioRuns: {
-                readonly edges: ReadonlyArray<{
-                    readonly node: {
-                        readonly key: string;
-                        readonly scenarioRunId: string;
-                        readonly gradeSampleCount: number;
-                        readonly completedSampleCount: number;
-                        readonly executionFailureCount: number;
-                        readonly gradingFailureCount: number;
-                        readonly averageScore: (number | null);
-                        readonly minScore: (number | null);
-                        readonly maxScore: (number | null);
-                        readonly failed: boolean;
-                        readonly minRunId: (string | null);
-                        readonly maxRunId: (string | null);
-                        readonly messageRefId: (string | null);
-                    };
-                }>;
-            };
-            readonly failureReasons: {
-                readonly edges: ReadonlyArray<{
-                    readonly node: {
-                        readonly key: string;
-                        readonly kind: string;
-                        readonly reason: string;
-                        readonly count: number;
-                    };
-                }>;
-            };
-        } | null);
-    };
-}, import("../__generated__/__isograph/Mutation/GambitWorkspaceVerifyBatchRunCreate/raw_response_type.js").Mutation__GambitWorkspaceVerifyBatchRunCreate__raw_response_type>;
-export default gambitWorkspaceVerifyBatchRunCreateMutation;
-//# sourceMappingURL=GambitWorkspaceVerifyBatchRunCreateMutation.d.ts.map

package/script/simulator-ui/mutations/GambitWorkspaceVerifyBatchRunCreateMutation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"GambitWorkspaceVerifyBatchRunCreateMutation.d.ts","sourceRoot":"","sources":["../../../src/simulator-ui/mutations/GambitWorkspaceVerifyBatchRunCreateMutation.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,2CAA2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4KAKvD,CAAC;AAEF,eAAe,2CAA2C,CAAC"}

package/script/simulator-ui/mutations/GambitWorkspaceVerifyBatchRunCreateMutation.js

@@ -1,13 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.gambitWorkspaceVerifyBatchRunCreateMutation = void 0;
-const entrypoint_js_1 = __importDefault(require("../__generated__/__isograph/Mutation/GambitWorkspaceVerifyBatchRunCreate/entrypoint.js"));
-const defineGambitMutation_js_1 = require("../src/hooks/defineGambitMutation.js");
-exports.gambitWorkspaceVerifyBatchRunCreateMutation = (0, defineGambitMutation_js_1.defineGambitMutation)({
-    entrypoint: entrypoint_js_1.default,
-    flightPolicy: "single",
-});
-exports.default = exports.gambitWorkspaceVerifyBatchRunCreateMutation;

package/script/simulator-ui/src/ActivityReasoningBubble.d.ts

@@ -1,7 +0,0 @@
-import { type BuildDisplayMessage } from "./utils.js";
-export default function ActivityReasoningBubble(props: {
-    entry: BuildDisplayMessage & {
-        kind: "reasoning";
-    };
-}): import("react").JSX.Element;
-//# sourceMappingURL=ActivityReasoningBubble.d.ts.map

package/script/simulator-ui/src/ActivityReasoningBubble.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ActivityReasoningBubble.d.ts","sourceRoot":"","sources":["../../../src/simulator-ui/src/ActivityReasoningBubble.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,mBAAmB,EAGzB,MAAM,YAAY,CAAC;AAEpB,MAAM,CAAC,OAAO,UAAU,uBAAuB,CAC7C,KAAK,EAAE;IAAE,KAAK,EAAE,mBAAmB,GAAG;QAAE,IAAI,EAAE,WAAW,CAAA;KAAE,CAAA;CAAE,+BAwD9D"}

package/script/simulator-ui/src/ActivityReasoningBubble.js

@@ -1,35 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = ActivityReasoningBubble;
-const react_1 = require("react");
-const Icon_js_1 = __importDefault(require("./gds/Icon.js"));
-const utils_js_1 = require("./utils.js");
-function ActivityReasoningBubble(props) {
-    const { entry } = props;
-    const [open, setOpen] = (0, react_1.useState)(false);
-    const reasoningSummaryText = typeof entry.content === "string" &&
-        entry.content.trim().length > 0
-        ? entry.content
-        : "No reasoning content";
-    const reasoningSummaryHtml = (0, utils_js_1.renderMarkdown)(reasoningSummaryText);
-    const reasoningType = typeof entry.reasoningType === "string" &&
-        entry.reasoningType.length > 0
-        ? entry.reasoningType
-        : undefined;
-    return (React.createElement("div", { className: "imessage-row tool-call-row reasoning-row" },
-        React.createElement("div", { className: "imessage-bubble tool-call-bubble reasoning-bubble" },
-            React.createElement("button", { type: "button", className: (0, utils_js_1.classNames)("tool-call-collapse", "tool-call-collapse-activity"), onClick: () => setOpen((prev) => !prev), "aria-expanded": open },
-                React.createElement("div", { className: "tool-call-header" },
-                    React.createElement("div", { className: "tool-call-title" }, "Reasoning"),
-                    React.createElement("span", { className: (0, utils_js_1.classNames)("tool-call-chevron", open && "is-open"), "aria-hidden": "true" },
-                        React.createElement(Icon_js_1.default, { name: "chevronDown", size: 10 }))),
-                React.createElement("div", { className: "tool-call-summary reasoning-summary", dangerouslySetInnerHTML: { __html: reasoningSummaryHtml } })),
-            open && (React.createElement("div", { className: "tool-call-detail" }, reasoningType
-                ? (React.createElement("div", { className: "reasoning-details-empty" },
-                    "Type: ",
-                    reasoningType))
-                : React.createElement("div", { className: "reasoning-details-empty" }, "No details"))))));
-}

package/script/simulator-ui/src/ActivityTranscriptRows.d.ts

@@ -1,27 +0,0 @@
-import React from "react";
-import { type BuildDisplayMessage } from "./utils.js";
-export type BuildChatTranscriptBucket = {
-    kind: "message";
-    key: string;
-    entry: BuildDisplayMessage & {
-        kind: "message";
-    };
-} | {
-    kind: "activity";
-    key: string;
-    entries: Array<BuildDisplayMessage>;
-    latestContent: string;
-    latestToolLabel: string | null;
-    currentToolLabel: string | null;
-    reasoningCount: number;
-    toolCount: number;
-};
-export declare function bucketBuildChatDisplay(display: Array<BuildDisplayMessage>): Array<BuildChatTranscriptBucket>;
-export declare function ActivityTranscriptRows(props: {
-    display: Array<BuildDisplayMessage>;
-    renderMessage: (entry: BuildDisplayMessage & {
-        kind: "message";
-    }, messageOrdinal: number) => React.ReactNode;
-    previewToolWhenNoReasoning?: boolean;
-}): React.JSX.Element;
-//# sourceMappingURL=ActivityTranscriptRows.d.ts.map

package/script/simulator-ui/src/ActivityTranscriptRows.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ActivityTranscriptRows.d.ts","sourceRoot":"","sources":["../../../src/simulator-ui/src/ActivityTranscriptRows.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,OAAO,CAAC;AAK1B,OAAO,EACL,KAAK,mBAAmB,EAGzB,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,yBAAyB,GACjC;IACA,IAAI,EAAE,SAAS,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,mBAAmB,GAAG;QAAE,IAAI,EAAE,SAAS,CAAA;KAAE,CAAC;CAClD,GACC;IACA,IAAI,EAAE,UAAU,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,KAAK,CAAC,mBAAmB,CAAC,CAAC;IACpC,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAwBJ,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,KAAK,CAAC,mBAAmB,CAAC,GAClC,KAAK,CAAC,yBAAyB,CAAC,CAuFlC;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE;IAC5C,OAAO,EAAE,KAAK,CAAC,mBAAmB,CAAC,CAAC;IACpC,aAAa,EAAE,CACb,KAAK,EAAE,mBAAmB,GAAG;QAAE,IAAI,EAAE,SAAS,CAAA;KAAE,EAChD,cAAc,EAAE,MAAM,KACnB,KAAK,CAAC,SAAS,CAAC;IACrB,0BAA0B,CAAC,EAAE,OAAO,CAAC;CACtC,qBA8RA"}

package/script/simulator-ui/src/ActivityTranscriptRows.js

@@ -1,309 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.bucketBuildChatDisplay = bucketBuildChatDisplay;
-exports.ActivityTranscriptRows = ActivityTranscriptRows;
-// deno-lint-ignore-file gambit/no-useeffect-setstate gambit/no-useeffect-setstate
-const react_1 = require("react");
-const react_2 = __importDefault(require("react"));
-const Badge_js_1 = __importDefault(require("./gds/Badge.js"));
-const Icon_js_1 = __importDefault(require("./gds/Icon.js"));
-const ActivityReasoningBubble_js_1 = __importDefault(require("./ActivityReasoningBubble.js"));
-const ToolCallBubble_js_1 = __importDefault(require("./ToolCallBubble.js"));
-const utils_js_1 = require("./utils.js");
-function findScrollableAncestor(element) {
-    let current = element?.parentElement ?? null;
-    while (current) {
-        const { overflowY } = globalThis.getComputedStyle(current);
-        if ((overflowY === "auto" || overflowY === "scroll" ||
-            overflowY === "overlay") &&
-            current.scrollHeight > current.clientHeight) {
-            return current;
-        }
-        current = current.parentElement;
-    }
-    return null;
-}
-function bucketBuildChatDisplay(display) {
-    const buckets = [];
-    let index = 0;
-    while (index < display.length) {
-        const entry = display[index];
-        if (entry.kind === "message") {
-            buckets.push({
-                kind: "message",
-                key: `message-${index}-${entry.role ?? "assistant"}`,
-                entry: entry,
-            });
-            index += 1;
-            continue;
-        }
-        if (entry.kind === "tool" || entry.kind === "reasoning") {
-            const grouped = [];
-            let cursor = index;
-            let reasoningCount = 0;
-            let toolCount = 0;
-            while (cursor < display.length && display[cursor].kind !== "message") {
-                const nextEntry = display[cursor];
-                grouped.push(nextEntry);
-                if (nextEntry.kind === "reasoning") {
-                    reasoningCount += 1;
-                }
-                else if (nextEntry.kind === "tool") {
-                    toolCount += 1;
-                }
-                cursor += 1;
-            }
-            let latestContent = "";
-            let latestToolLabel = null;
-            let currentToolLabel = null;
-            let latestReasoningIndex = -1;
-            grouped.forEach((nextEntry, nextEntryIndex) => {
-                if (nextEntry.kind === "reasoning") {
-                    if (typeof nextEntry.content === "string" && nextEntry.content.trim()) {
-                        latestContent = nextEntry.content;
-                    }
-                    latestReasoningIndex = nextEntryIndex;
-                    return;
-                }
-                if (nextEntry.kind === "tool" && nextEntry.toolSummary) {
-                    const rawName = nextEntry.toolSummary.name;
-                    const toolLabel = typeof rawName === "string" && rawName.length > 0
-                        ? `Tool call: ${rawName}`
-                        : "Tool call";
-                    latestToolLabel = toolLabel;
-                    currentToolLabel = toolLabel;
-                }
-            });
-            if (latestReasoningIndex >= 0) {
-                currentToolLabel = null;
-                for (let entryIdx = latestReasoningIndex + 1; entryIdx < grouped.length; entryIdx += 1) {
-                    const nextEntry = grouped[entryIdx];
-                    if (nextEntry.kind !== "tool" || !nextEntry.toolSummary)
-                        continue;
-                    const rawName = nextEntry.toolSummary.name;
-                    currentToolLabel = typeof rawName === "string" && rawName.length > 0
-                        ? `Tool call: ${rawName}`
-                        : "Tool call";
-                }
-            }
-            buckets.push({
-                kind: "activity",
-                key: `activity-${index}`,
-                entries: grouped,
-                latestContent,
-                latestToolLabel,
-                currentToolLabel,
-                reasoningCount,
-                toolCount,
-            });
-            if (cursor === index) {
-                index += 1;
-                continue;
-            }
-            index = cursor;
-            continue;
-        }
-        index += 1;
-    }
-    return buckets;
-}
-function ActivityTranscriptRows(props) {
-    const { display, renderMessage, previewToolWhenNoReasoning = false } = props;
-    const [activityBucketsOpen, setActivityBucketsOpen] = (0, react_1.useState)({});
-    const [activityBadgeFlash, setActivityBadgeFlash] = (0, react_1.useState)({});
-    const activityBadgeTimersRef = (0, react_1.useRef)({});
-    const activityRowRefs = (0, react_1.useRef)({});
-    const previousActivityCountsRef = (0, react_1.useRef)({});
-    const rows = [];
-    const buckets = bucketBuildChatDisplay(display);
-    const clearActivityBadgeFlashTimer = (0, react_1.useCallback)((bucketKey, badgeKey) => {
-        const bucketTimers = activityBadgeTimersRef.current[bucketKey];
-        if (!bucketTimers)
-            return;
-        const timerId = bucketTimers[badgeKey];
-        if (timerId !== undefined) {
-            clearTimeout(timerId);
-        }
-        delete bucketTimers[badgeKey];
-        if (bucketTimers.reasoning === undefined && bucketTimers.tool === undefined) {
-            delete activityBadgeTimersRef.current[bucketKey];
-        }
-    }, []);
-    const triggerActivityBadgeFlash = (0, react_1.useCallback)((bucketKey, badgeKey) => {
-        setActivityBadgeFlash((prev) => ({
-            ...prev,
-            [bucketKey]: {
-                reasoning: prev[bucketKey]?.reasoning ?? false,
-                tool: prev[bucketKey]?.tool ?? false,
-                [badgeKey]: true,
-            },
-        }));
-        clearActivityBadgeFlashTimer(bucketKey, badgeKey);
-        const bucketTimers = activityBadgeTimersRef.current[bucketKey] ?? {};
-        bucketTimers[badgeKey] = setTimeout(() => {
-            clearActivityBadgeFlashTimer(bucketKey, badgeKey);
-            setActivityBadgeFlash((prev) => {
-                const existing = prev[bucketKey];
-                if (!existing)
-                    return prev;
-                const nextBucketState = {
-                    reasoning: badgeKey === "reasoning" ? false : existing.reasoning,
-                    tool: badgeKey === "tool" ? false : existing.tool,
-                };
-                if (!nextBucketState.reasoning && !nextBucketState.tool) {
-                    const { [bucketKey]: _, ...rest } = prev;
-                    return rest;
-                }
-                return {
-                    ...prev,
-                    [bucketKey]: nextBucketState,
-                };
-            });
-        }, 1500);
-        activityBadgeTimersRef.current[bucketKey] = bucketTimers;
-    }, [clearActivityBadgeFlashTimer]);
-    const handleActivityBucketToggle = (0, react_1.useCallback)((bucketKey, isOpen) => {
-        let adjustScroll = null;
-        if (isOpen) {
-            const rowElement = activityRowRefs.current[bucketKey];
-            const scrollContainer = findScrollableAncestor(rowElement ?? null);
-            const nextElement = rowElement?.nextElementSibling instanceof HTMLElement
-                ? rowElement.nextElementSibling
-                : null;
-            const anchorElement = nextElement ?? rowElement ?? null;
-            if (scrollContainer && anchorElement) {
-                const anchorTopBefore = anchorElement.getBoundingClientRect().top;
-                adjustScroll = () => {
-                    const anchorTopAfter = anchorElement.getBoundingClientRect().top;
-                    const delta = anchorTopAfter - anchorTopBefore;
-                    if (Math.abs(delta) < 0.5)
-                        return;
-                    scrollContainer.scrollTop += delta;
-                };
-            }
-        }
-        setActivityBucketsOpen((prev) => ({
-            ...prev,
-            [bucketKey]: !prev[bucketKey],
-        }));
-        if (adjustScroll) {
-            requestAnimationFrame(adjustScroll);
-        }
-    }, []);
-    (0, react_1.useEffect)(() => {
-        const nextCounts = {};
-        const activeBucketKeys = new Set();
-        buckets.forEach((bucket) => {
-            if (bucket.kind !== "activity")
-                return;
-            activeBucketKeys.add(bucket.key);
-            nextCounts[bucket.key] = {
-                reasoning: bucket.reasoningCount,
-                tool: bucket.toolCount,
-            };
-            const previousCounts = previousActivityCountsRef.current[bucket.key];
-            if (!previousCounts)
-                return;
-            if (bucket.reasoningCount > previousCounts.reasoning) {
-                triggerActivityBadgeFlash(bucket.key, "reasoning");
-            }
-            if (bucket.toolCount > previousCounts.tool) {
-                triggerActivityBadgeFlash(bucket.key, "tool");
-            }
-        });
-        Object.keys(previousActivityCountsRef.current).forEach((bucketKey) => {
-            if (activeBucketKeys.has(bucketKey))
-                return;
-            clearActivityBadgeFlashTimer(bucketKey, "reasoning");
-            clearActivityBadgeFlashTimer(bucketKey, "tool");
-        });
-        previousActivityCountsRef.current = nextCounts;
-        setActivityBadgeFlash((prev) => {
-            let changed = false;
-            const next = {};
-            Object.entries(prev).forEach(([bucketKey, value]) => {
-                if (!activeBucketKeys.has(bucketKey)) {
-                    changed = true;
-                    return;
-                }
-                if (!value.reasoning && !value.tool) {
-                    changed = true;
-                    return;
-                }
-                next[bucketKey] = value;
-            });
-            return changed ? next : prev;
-        });
-    }, [buckets, clearActivityBadgeFlashTimer, triggerActivityBadgeFlash]);
-    (0, react_1.useEffect)(() => {
-        return () => {
-            Object.entries(activityBadgeTimersRef.current).forEach(([bucketKey, bucketTimers,]) => {
-                if (bucketTimers.reasoning !== undefined) {
-                    clearTimeout(bucketTimers.reasoning);
-                }
-                if (bucketTimers.tool !== undefined) {
-                    clearTimeout(bucketTimers.tool);
-                }
-                delete activityBadgeTimersRef.current[bucketKey];
-            });
-        };
-    }, []);
-    let messageOrdinal = 0;
-    buckets.forEach((bucket) => {
-        if (bucket.kind === "message") {
-            rows.push(renderMessage(bucket.entry, messageOrdinal));
-            messageOrdinal += 1;
-            return;
-        }
-        if (bucket.kind === "activity") {
-            const isOpen = Boolean(activityBucketsOpen[bucket.key]);
-            const latestReasoning = bucket.latestContent.trim().length > 0
-                ? bucket.latestContent
-                : bucket.reasoningCount > 0
-                    ? "Reasoning in progress"
-                    : "";
-            const previewToolLabel = previewToolWhenNoReasoning &&
-                latestReasoning.length === 0
-                ? bucket.currentToolLabel ?? bucket.latestToolLabel
-                : null;
-            rows.push(react_2.default.createElement("div", { key: bucket.key, className: "tool-calls-collapsible activity-collapsible", ref: (element) => {
-                    activityRowRefs.current[bucket.key] = element;
-                } },
-                react_2.default.createElement("button", { type: "button", className: (0, utils_js_1.classNames)("tool-calls-toggle activity-toggle", isOpen && "is-open"), onClick: () => handleActivityBucketToggle(bucket.key, isOpen) },
-                    react_2.default.createElement("span", { className: "tool-calls-toggle-label" },
-                        react_2.default.createElement("span", { className: "activity-toggle-title" }, "Activity"),
-                        react_2.default.createElement(Badge_js_1.default, { variant: "ghost", className: (0, utils_js_1.classNames)("activity-count-badge activity-count-badge-reasoning", activityBadgeFlash[bucket.key]?.reasoning && "is-highlight"), tooltip: bucket.latestContent },
-                            "Reasoning: ",
-                            bucket.reasoningCount),
-                        react_2.default.createElement(Badge_js_1.default, { variant: "ghost", className: (0, utils_js_1.classNames)("activity-count-badge activity-count-badge-tool", activityBadgeFlash[bucket.key]?.tool && "is-highlight"), tooltip: bucket.latestToolLabel },
-                            "Tool calls: ",
-                            bucket.toolCount)),
-                    react_2.default.createElement("span", { className: "activity-toggle-chevron", "aria-hidden": "true" },
-                        react_2.default.createElement(Icon_js_1.default, { name: "chevronDown", size: 10 }))),
-                !isOpen && (react_2.default.createElement("div", { className: "activity-preview" },
-                    latestReasoning && (react_2.default.createElement("div", { className: "activity-preview-reasoning", dangerouslySetInnerHTML: {
-                            __html: (0, utils_js_1.renderMarkdown)(latestReasoning),
-                        } })),
-                    previewToolLabel && (react_2.default.createElement("div", { className: "activity-preview-tool" }, previewToolLabel)))),
-                isOpen && (react_2.default.createElement("div", { className: "tool-calls-list activity-details" }, bucket.entries.map((entry, activityIdx) => {
-                    if (entry.kind === "tool") {
-                        const tool = entry.toolSummary;
-                        if (!tool)
-                            return null;
-                        const toolId = tool.id ?? entry.toolCallId ??
-                            `tool-${bucket.key}-${activityIdx}`;
-                        return (react_2.default.createElement("div", { key: `tool-${toolId}-${activityIdx}` },
-                            react_2.default.createElement(ToolCallBubble_js_1.default, { call: tool })));
-                    }
-                    if (entry.kind !== "reasoning")
-                        return null;
-                    return (react_2.default.createElement(ActivityReasoningBubble_js_1.default, { key: `reasoning-${bucket.key}-${activityIdx}-${entry.reasoningId ?? "r"}`, entry: entry }));
-                })))));
-            return;
-        }
-    });
-    return react_2.default.createElement(react_2.default.Fragment, null, rows);
-}

package/script/simulator-ui/src/AppIsoMinimal.d.ts

@@ -1,10 +0,0 @@
-import React from "react";
-export declare function AppIsoMinimal(props: {
-    entrypoint: any;
-    params?: Record<string, string>;
-    onNavigate?: (nextPath: string) => void;
-    fallback?: React.ReactNode;
-    rendererKey?: string;
-    shouldFetch?: "IfNecessary" | "No" | "Yes";
-}): React.JSX.Element;
-//# sourceMappingURL=AppIsoMinimal.d.ts.map

package/script/simulator-ui/src/AppIsoMinimal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AppIsoMinimal.d.ts","sourceRoot":"","sources":["../../../src/simulator-ui/src/AppIsoMinimal.tsx"],"names":[],"mappings":"AACA,OAAO,KAAsC,MAAM,OAAO,CAAC;AAqI3D,wBAAgB,aAAa,CAAC,KAAK,EAAE;IAEnC,UAAU,EAAE,GAAG,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,aAAa,GAAG,IAAI,GAAG,KAAK,CAAC;CAC5C,qBAuBA"}