@manta-eu/horns-client 0.1.4 → 0.2.1

package/dist/embed/horn-about.js

@@ -0,0 +1,87 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useQuery } from "@tanstack/react-query";
+import { z } from "zod";
+import { isPresent } from "@manta-eu/lib/present";
+import { hornSchema, isRecord } from "@manta-eu/horns";
+import { hornSnapshotSchema } from "@manta-eu/horns/render";
+import { HornSnapshotView } from "@manta-eu/horns-kit";
+import { writtenHornView } from "../components/written-horn-view";
+import { PlanChanges } from "../components/plan-changes";
+import { catalogCardView } from "../components/catalog-card-view";
+import { ErrorState, Loading } from "../components/states";
+import { problemFrom } from "../lib/problem";
+import { appTheme } from "../lib/theme";
+const aboutAnswer = z.object({
+    horn: hornSchema,
+    kept: z.boolean(),
+    slug: z.string().min(1).optional(),
+    revision: z.string().min(1).optional(),
+});
+/**
+ * Where the worker answers for a thing. The IRI goes in a query parameter and is encoded: a plan's carries
+ * a `#`, which would otherwise end the URL and ask about nothing.
+ */
+export function hornAboutPath(datastoreId, about) {
+    return `/api/d/${encodeURIComponent(datastoreId)}/horns/by/about?iri=${encodeURIComponent(about)}`;
+}
+/** Where a Horn is turned into rows to draw. */
+export function hornSnapshotPath(datastoreId) {
+    return `/api/d/${encodeURIComponent(datastoreId)}/horns/snapshot`;
+}
+/** Where every Horn about a thing is listed. */
+export function hornsAboutPath(datastoreId, about, limit) {
+    const capped = limit === undefined ? "" : `&limit=${limit}`;
+    return `/api/d/${encodeURIComponent(datastoreId)}/horns/by/about/list?iri=${encodeURIComponent(about)}${capped}`;
+}
+export function HornDrawn(props) {
+    const { datastoreId, horn, cacheKey, variables = {}, mode = "embed", planActions, explain, onVariableChange } = props;
+    const snapshot = useQuery({
+        enabled: isPresent(horn),
+        queryKey: ["horn-snapshot", datastoreId, cacheKey, variables],
+        queryFn: async ({ signal }) => {
+            const response = await fetch(hornSnapshotPath(datastoreId), {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({ horn, variables }),
+                signal,
+            });
+            if (!response.ok)
+                throw new Error(await problemFrom(response, "The Horn could not be drawn."));
+            const body = await response.json();
+            return hornSnapshotSchema.parse(isRecord(body) ? body["snapshot"] : undefined);
+        },
+    });
+    if (snapshot.isError)
+        return _jsx(ErrorState, { title: "This could not be drawn", hint: snapshot.error.message });
+    if (!isPresent(snapshot.data))
+        return _jsx(Loading, { label: "Drawing this\u2026", rows: 3 });
+    return (_jsx(HornSnapshotView, { snapshot: snapshot.data, mode: mode, theme: appTheme(), writtenView: writtenHornView, planStrip: PlanChanges, catalogCard: catalogCardView, ...(isPresent(planActions) ? { planActions } : {}), ...(isPresent(explain) ? { explain } : {}), ...(isPresent(onVariableChange) ? { onVariableChange } : {}) }));
+}
+/**
+ * The Horn for a thing, drawn wherever a host puts it.
+ *
+ * A host with an IRI gets something to look at whether or not anyone has made a Horn for it: the worker
+ * answers with the kept one, or builds one from the plan or rule itself. So this needs no saved Horn, no
+ * route of the host's and no Studio — it is the read-only half, for a plan shown beside its own screen.
+ *
+ * Written views and catalog cards are bound here because they need `@manta-eu/react`, which the kit has not
+ * got. Everything else a host wants to hang on it is a prop.
+ */
+export function HornAbout(props) {
+    const { datastoreId, about, variables = {}, mode = "embed", planActions, explain, onVariableChange } = props;
+    const seed = useQuery({
+        queryKey: ["horn-about", datastoreId, about],
+        queryFn: async ({ signal }) => {
+            const response = await fetch(hornAboutPath(datastoreId, about), { signal });
+            if (!response.ok)
+                throw new Error(await problemFrom(response, `The answer was ${response.status}.`));
+            return aboutAnswer.parse(await response.json());
+        },
+    });
+    if (seed.isError)
+        return _jsx(ErrorState, { title: "Nothing could be shown for this", hint: seed.error.message });
+    const horn = seed.data?.horn;
+    if (!isPresent(horn))
+        return _jsx(Loading, { label: "Drawing this\u2026", rows: 3 });
+    return (_jsx(HornDrawn, { datastoreId: datastoreId, horn: horn, cacheKey: seed.data?.revision ?? about, variables: variables, mode: mode, ...(isPresent(planActions) ? { planActions } : {}), ...(isPresent(explain) ? { explain } : {}), ...(isPresent(onVariableChange) ? { onVariableChange } : {}) }));
+}

package/dist/embed/horns-about.d.ts

@@ -0,0 +1,29 @@
+import { type HornDrawProps } from "./horn-about";
+export type HornsAboutProps = HornDrawProps & {
+    datastoreId: string;
+    /** The thing these are about: a rule, a plan, a campaign, a person. Opaque — only ever passed on. */
+    about: string;
+    /** How many to draw. The worker caps it; leaving it off takes the worker's default. */
+    limit?: number;
+    variables?: Record<string, unknown>;
+    /**
+     * Where a Horn opens in full, where the host has somewhere to send a person. A plain href, not a route:
+     * the Horns UI may be another document, or another origin entirely.
+     */
+    hornHref?: (slug: string) => string;
+    /** What to say when nothing is about this thing yet. */
+    emptyHint?: string;
+};
+/**
+ * Every Horn about one thing, drawn.
+ *
+ * This is the whole of embedding Horns: a host that has an IRI — a rule, an action plan, a campaign, a
+ * person — puts this beside it and gets what Manta already knows about that thing, as pictures rather than
+ * links. It needs no saved Horn, no route of the host's and no Studio: the worker answers with the kept
+ * ones, or builds one from the rule or plan itself.
+ *
+ * The one thing a host must bring is the policy. A written view runs in the page's own realm, so the
+ * document has to carry `connect-src 'self'` and the rest of `contentSecurityPolicy()`; without it the
+ * views still draw, but nothing fences the code they came from.
+ */
+export declare function HornsAbout(props: HornsAboutProps): import("react").JSX.Element;

package/dist/embed/horns-about.js

@@ -0,0 +1,50 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useQuery } from "@tanstack/react-query";
+import { z } from "zod";
+import { isPresent } from "@manta-eu/lib/present";
+import { hornSchema } from "@manta-eu/horns";
+import { EmptyState, ErrorState, Loading } from "../components/states";
+import { problemFrom } from "../lib/problem";
+import { HornDrawn, hornsAboutPath } from "./horn-about";
+const listAnswer = z.object({
+    horns: z.array(z.object({
+        horn: hornSchema,
+        kept: z.boolean(),
+        slug: z.string().min(1).optional(),
+        revision: z.string().min(1).optional(),
+    })),
+    total: z.number().int().min(0),
+});
+/**
+ * Every Horn about one thing, drawn.
+ *
+ * This is the whole of embedding Horns: a host that has an IRI — a rule, an action plan, a campaign, a
+ * person — puts this beside it and gets what Manta already knows about that thing, as pictures rather than
+ * links. It needs no saved Horn, no route of the host's and no Studio: the worker answers with the kept
+ * ones, or builds one from the rule or plan itself.
+ *
+ * The one thing a host must bring is the policy. A written view runs in the page's own realm, so the
+ * document has to carry `connect-src 'self'` and the rest of `contentSecurityPolicy()`; without it the
+ * views still draw, but nothing fences the code they came from.
+ */
+export function HornsAbout(props) {
+    const { datastoreId, about, limit, variables = {}, hornHref, emptyHint, ...draw } = props;
+    const listed = useQuery({
+        queryKey: ["horns-about", datastoreId, about, limit ?? "default"],
+        queryFn: async ({ signal }) => {
+            const response = await fetch(hornsAboutPath(datastoreId, about, limit), { signal });
+            if (!response.ok)
+                throw new Error(await problemFrom(response, `The answer was ${response.status}.`));
+            return listAnswer.parse(await response.json());
+        },
+    });
+    if (listed.isError)
+        return _jsx(ErrorState, { title: "Nothing could be shown for this", hint: listed.error.message });
+    if (!isPresent(listed.data))
+        return _jsx(Loading, { label: "Looking for what is known about this\u2026", rows: 2 });
+    const { horns, total } = listed.data;
+    if (horns.length === 0) {
+        return (_jsx(EmptyState, { title: "Nothing is about this yet", hint: emptyHint ?? "Once somebody makes a Horn about it, it will be drawn here." }));
+    }
+    return (_jsxs("div", { "data-horns-about": true, className: "flex w-full flex-col gap-8", children: [horns.map(({ horn, slug, revision }) => (_jsxs("section", { "data-horn": slug, className: "flex flex-col gap-3", children: [_jsxs("div", { className: "flex flex-col gap-1", children: [_jsx("h2", { className: "text-lg font-semibold text-default-foreground", children: isPresent(slug) && isPresent(hornHref) ? (_jsx("a", { href: hornHref(slug), className: "hover:underline", children: horn.title })) : (horn.title) }), isPresent(horn.summary) ? _jsx("p", { className: "text-muted-foreground text-sm", children: horn.summary }) : null] }), _jsx(HornDrawn, { datastoreId: datastoreId, horn: horn, cacheKey: revision ?? slug ?? about, variables: variables, ...draw })] }, slug ?? revision ?? horn.title))), total > horns.length ? (_jsxs("p", { className: "text-sm text-muted-foreground", children: [total - horns.length, " more ", total - horns.length === 1 ? "Horn is" : "Horns are", " about this."] })) : null] }));
+}

package/dist/index.d.ts

@@ -1,5 +1,9 @@
-export { AppRoutes, hornsRoutes } from "./app/routes.tsx";
+export { AppRoutes, hornsRoutes, type HornsRoutesOptions } from "./app/routes.tsx";
+export { hornsNavSections, type HornsNavItem, type HornsNavSection } from "./app/nav.ts";
 export { HornsApp } from "./standalone/app.tsx";
+export { HornAbout, HornDrawn, hornAboutPath, hornsAboutPath, hornSnapshotPath } from "./embed/horn-about.tsx";
+export type { HornAboutProps, HornDrawProps, HornDrawnProps } from "./embed/horn-about.tsx";
+export { HornsAbout, type HornsAboutProps } from "./embed/horns-about.tsx";
 export { AppShell } from "./components/app-shell.tsx";
 export { signInHref } from "./lib/manta/sign-in.ts";
 export { useSparqlSelect } from "./lib/manta/sparql-select.ts";

package/dist/index.js

@@ -7,9 +7,16 @@
 // What the browser needs beyond this is the stylesheet: `@manta-eu/horns-client/styles.css`, built here
 // rather than compiled by the host, so a host with no Tailwind still gets the app looking like Manta.
 export { AppRoutes, hornsRoutes } from "./app/routes.js";
+// What a host with a shell of its own draws as navigation, so a page cannot be in one list and not the other.
+export { hornsNavSections } from "./app/nav.js";
 // The session gate, and the only thing that provides the AuthContext every Horns page reads. A host
 // splicing `hornsRoutes()` into a router of its own mounts this above them, or provides that context itself.
 export { HornsApp } from "./standalone/app.js";
+// A thing's Horn, drawn inside a host's own screen: it asks the worker for the kept Horn or one built
+// from the plan or rule itself, so a host needs no saved Horn and no route of its own.
+export { HornAbout, HornDrawn, hornAboutPath, hornsAboutPath, hornSnapshotPath } from "./embed/horn-about.js";
+// Every Horn about one thing: what a host with an IRI embeds.
+export { HornsAbout } from "./embed/horns-about.js";
 export { AppShell } from "./components/app-shell.js";
 export { signInHref } from "./lib/manta/sign-in.js";
 export { useSparqlSelect } from "./lib/manta/sparql-select.js";

package/dist/lib/manta/studio-conversation.d.ts

@@ -0,0 +1,241 @@
+import type { Horn } from "@manta-eu/horns";
+import { type StudioStep } from "../studio-progress";
+export type StudioConversationState = {
+    draft: Horn | null;
+};
+export type StudioTurn = {
+    reply: string;
+    horn: Horn | undefined;
+};
+/** One Studio conversation. The draft is the object's and arrives through state sync. */
+export type StudioConversationArgs = {
+    datastoreId: string;
+    conversation: string;
+    /** Draws the Horn as it stands and says what is wrong with it. The page is the only thing that can. */
+    look: (why: string) => Promise<string>;
+};
+export declare function useStudioConversation(args: StudioConversationArgs): {
+    ask: (said: string) => Promise<StudioTurn>;
+    open: (horn: Horn) => Promise<void>;
+    steps: readonly StudioStep[];
+    draft: {
+        iri: string;
+        slug: string;
+        title: string;
+        datastoreId: string;
+        realm: "hiremanta-com" | "journey-travel";
+        schemaVersion: 1;
+        revision: number;
+        layout: {
+            kind: "grid";
+            columns: 12;
+            items: {
+                viewId: string;
+                x: number;
+                y: number;
+                w: number;
+                h: number;
+            }[];
+        };
+        variables: {
+            id: string;
+            label: string;
+            type: "string" | "number" | "date" | "iri" | "enum" | "dateRange";
+            default?: import("zod").JSONType | undefined;
+            options?: {
+                values: import("zod").JSONType[];
+            } | {
+                binding: {
+                    kind: "select";
+                    sparql: string;
+                    params: string[];
+                    limit: number;
+                    derivations: string[];
+                    columns: {
+                        name: string;
+                        type: "string" | "number" | "boolean" | "date" | "iri";
+                    }[];
+                } | {
+                    kind: "lens";
+                    classIri: string;
+                    limit: number;
+                    derivations: string[];
+                    fields: {
+                        name: string;
+                        path: string;
+                        type: "string" | "number" | "boolean" | "date" | "iri";
+                    }[];
+                    rows?: "value" | "entity" | undefined;
+                } | {
+                    kind: "query";
+                    query: {
+                        item: string;
+                        revision: string;
+                        hash: string;
+                    };
+                    params: string[];
+                    limit: number;
+                };
+            } | undefined;
+            urlParam?: string | undefined;
+        }[];
+        views: ({
+            id: string;
+            title: string;
+            binding: {
+                kind: "select";
+                sparql: string;
+                params: string[];
+                limit: number;
+                derivations: string[];
+                columns: {
+                    name: string;
+                    type: "string" | "number" | "boolean" | "date" | "iri";
+                }[];
+            } | {
+                kind: "lens";
+                classIri: string;
+                limit: number;
+                derivations: string[];
+                fields: {
+                    name: string;
+                    path: string;
+                    type: "string" | "number" | "boolean" | "date" | "iri";
+                }[];
+                rows?: "value" | "entity" | undefined;
+            } | {
+                kind: "query";
+                query: {
+                    item: string;
+                    revision: string;
+                    hash: string;
+                };
+                params: string[];
+                limit: number;
+            };
+            render: {
+                kind: "component";
+                component: {
+                    item: string;
+                    revision: string;
+                    hash: string;
+                };
+                props: import("zod").JSONType;
+            } | {
+                kind: "tsx";
+                source: string;
+                reviewed?: {
+                    hash: string;
+                    at: string;
+                } | undefined;
+            };
+            emits?: {
+                event: string;
+                setsVariable: string;
+            }[] | undefined;
+        } | {
+            id: string;
+            ref: {
+                item: string;
+                revision: string;
+                hash: string;
+            };
+        })[];
+        derivations: ({
+            id: string;
+            predicateIri: string;
+            appliesTo: string;
+            datatype: string;
+            pattern: string;
+            status: "query" | "staged" | "materialized";
+            promotedRuleIri?: string | undefined;
+        } | {
+            id: string;
+            ref: {
+                item: string;
+                revision: string;
+                hash: string;
+            };
+        })[];
+        actions: ({
+            kind: "kg-update";
+            insert: string;
+            allowedPredicates: string[];
+            allowedClasses: string[];
+            id: string;
+            label: string;
+            params: {
+                id: string;
+                type: "string" | "number" | "date" | "iri" | "enum";
+                required: boolean;
+                classIri?: string | undefined;
+                values?: import("zod").JSONType[] | undefined;
+            }[];
+            confirm: true;
+            delete?: string | undefined;
+            where?: string | undefined;
+            criteria?: {
+                ask: string;
+            } | undefined;
+        } | {
+            kind: "action-shape";
+            actionShapeIri: string;
+            operation: "update" | "addition";
+            mapping: Record<string, string>;
+            id: string;
+            label: string;
+            params: {
+                id: string;
+                type: "string" | "number" | "date" | "iri" | "enum";
+                required: boolean;
+                classIri?: string | undefined;
+                values?: import("zod").JSONType[] | undefined;
+            }[];
+            confirm: true;
+            criteria?: {
+                ask: string;
+            } | undefined;
+        } | {
+            id: string;
+            ref: {
+                item: string;
+                revision: string;
+                hash: string;
+            };
+        })[];
+        dependencies: {
+            kind: "view" | "action" | "query" | "component" | "derivation" | "horn";
+            ref: {
+                item: string;
+                revision: string;
+                hash: string;
+            };
+        }[];
+        lock: {
+            lockVersion: 1;
+            entries: {
+                kind: "view" | "action" | "query" | "component" | "derivation" | "horn";
+                ref: {
+                    item: string;
+                    revision: string;
+                    hash: string;
+                };
+                requiredBy: string[];
+            }[];
+        };
+        runtime: {
+            kit: string;
+        };
+        summary?: string | undefined;
+        audience?: string | undefined;
+        about?: string[] | undefined;
+        baseRevision?: number | undefined;
+        style?: {
+            theme?: "light" | "dark" | undefined;
+            accent?: "blue" | "orange" | "green" | "amber" | "pink" | "forest" | "indigo" | "red" | undefined;
+            density?: "compact" | "comfortable" | undefined;
+            radius?: "sharp" | "soft" | "round" | undefined;
+        } | undefined;
+    } | undefined;
+    pending: boolean;
+};

package/dist/lib/manta/studio-conversation.js

@@ -0,0 +1,83 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import { useAgent } from "agents/react";
+import { useAgentChat } from "agents/chat/react";
+import { isPresent } from "@manta-eu/lib/present";
+import { studioReplyOf, studioStepsOf } from "../studio-progress";
+// One array, so a turn with no steps does not re-render the page every tick.
+const emptySteps = [];
+/** The reply and the draft arrive separately; the stream finishes first. */
+const draftGraceMs = 3_000;
+export function useStudioConversation(args) {
+    // No leading slash: the socket client builds `${host}/${basePath}` and adds the separator itself.
+    const at = `api/d/${encodeURIComponent(args.datastoreId)}/studio/${encodeURIComponent(args.conversation)}`;
+    const agent = useAgent({ agent: "studio", name: args.conversation, basePath: at });
+    const look = useRef(args.look);
+    look.current = args.look;
+    const chat = useAgentChat({
+        agent,
+        credentials: "include",
+        getInitialMessages: null,
+        resume: true,
+        tools: {
+            look_at_it: {
+                execute: (input) => {
+                    const why = typeof input === "object" && input !== null && "why" in input ? String(input.why) : "";
+                    return look.current(why);
+                },
+            },
+        },
+    });
+    const [tick, setTick] = useState(0);
+    const waiting = useRef(undefined);
+    const before = useRef(chat.status);
+    const drawn = useRef(undefined);
+    if (isPresent(agent.state?.draft))
+        drawn.current = agent.state.draft;
+    useEffect(() => {
+        const held = waiting.current;
+        if (!isPresent(held)) {
+            before.current = chat.status;
+            return;
+        }
+        const settled = chat.status === "ready" || chat.status === "error";
+        if (!settled) {
+            before.current = chat.status;
+            return;
+        }
+        if (chat.status === "error") {
+            waiting.current = undefined;
+            held.reject(new Error("The Studio could not answer."));
+            return;
+        }
+        held.settledAt ??= Date.now();
+        const changed = drawn.current !== held.before;
+        if (!changed && Date.now() - held.settledAt < draftGraceMs) {
+            const again = setTimeout(() => setTick((count) => count + 1), 120);
+            before.current = chat.status;
+            return () => clearTimeout(again);
+        }
+        waiting.current = undefined;
+        const last = [...chat.messages].reverse().find((message) => message.role === "assistant");
+        held.resolve({ reply: studioReplyOf(last?.parts ?? []), horn: drawn.current });
+        before.current = chat.status;
+        return;
+    }, [chat.status, chat.messages, tick, agent.state]);
+    /** Tells the object which Horn it is about. */
+    const open = useCallback(async (horn) => {
+        const response = await fetch(`/${at}/open`, {
+            method: "POST",
+            credentials: "include",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ horn }),
+        });
+        if (!response.ok)
+            throw new Error("This Horn could not be opened in the Studio.");
+    }, [at]);
+    const ask = useCallback((said) => new Promise((resolve, reject) => {
+        waiting.current = { resolve, reject, before: drawn.current };
+        void chat.sendMessage({ text: said });
+    }), [chat]);
+    const running = chat.status === "ready" ? undefined : [...chat.messages].reverse()[0];
+    const steps = running?.role === "assistant" ? studioStepsOf(running.parts ?? []) : emptySteps;
+    return { ask, open, steps, draft: agent.state?.draft ?? undefined, pending: chat.status !== "ready" };
+}

package/dist/lib/studio-progress.d.ts

@@ -3,5 +3,12 @@ export type StudioStep = {
     title: string;
     detail?: string;
 };
-/** One line for one streamed event, or nothing for an event not worth a line of its own. */
-export declare function studioProgressLine(line: Record<string, unknown>): StudioStep | undefined;
+export type MessagePart = {
+    type: string;
+    toolName?: unknown;
+    text?: unknown;
+};
+/** What the turn has done so far. The same tool twice running is one line with a count. */
+export declare function studioStepsOf(parts: readonly MessagePart[]): StudioStep[];
+/** The answer: what was said after the last tool call. Anything before it is narration. */
+export declare function studioReplyOf(parts: readonly MessagePart[]): string;

package/dist/lib/studio-progress.js

@@ -1,38 +1,63 @@
-import { match } from "ts-pattern";
-import { isRecord } from "@manta-eu/horns";
-// What a Horn turn is doing, in words, from the events the route streams. A tool name is the model's
-// vocabulary; the person watching wants to know what is being looked at.
 const toolLines = {
     list_classes: "Looking at what this datastore holds",
     describe_class: "Reading how a kind of thing is described",
     components_for_class: "Looking for components that already fit",
+    find_components: "Looking through the design system",
+    read_component_api: "Reading how a component works",
+    list_computed: "Looking at what Manta works out",
+    list_rules: "Reading the rules",
     run_sparql: "Querying the datastore",
     investigate_data: "Investigating the data",
+    ask_manta_for_rule: "Asking Manta for a rule",
     propose_horn_patch: "Changing the Horn",
+    propose_plan: "Putting a plan up",
     propose_library_item: "Offering a part for the library",
     report_harness_issue: "Noting a problem with the tools",
+    look_at_it: "Looking at what it drew",
 };
-// A turn can start a loop of its own. Its steps are the same steps, said by somebody else.
-const agentNames = { investigate: "Investigating" };
-/** One line for one streamed event, or nothing for an event not worth a line of its own. */
-export function studioProgressLine(line) {
-    const event = line["event"];
-    if (!isRecord(event))
-        return undefined;
-    const name = typeof event["name"] === "string" ? event["name"] : "";
-    const detail = typeof event["detail"] === "string" ? event["detail"] : undefined;
-    const agent = typeof event["agent"] === "string" ? (agentNames[event["agent"]] ?? event["agent"]) : undefined;
-    const step = (title) => title === undefined
-        ? undefined
-        : { title: agent === undefined ? title : `${agent} · ${title}`, ...(detail === undefined ? {} : { detail }) };
-    return match(event["type"])
-        .with("reading", () => step("Reading the Horn and the data behind it"))
-        .with("round", () => (event["step"] === 1 && agent === undefined ? step("Thinking") : undefined))
-        .with("tool-call", () => event["repeated"] === true || name === "propose_horn_patch"
-        ? undefined
-        : step(toolLines[name] ?? `Using ${name}`))
-        .with("proposal-accepted", () => (name === "propose_horn_patch" ? step("Changed the Horn") : undefined))
-        .with("proposal-rejected", () => step("That change did not hold up against the data, trying again"))
-        .with("rehydrated", () => step("Starting over from the Horn as it stands"))
-        .otherwise(() => undefined);
+// A dynamic tool part carries its name separately.
+function toolNameOf(part) {
+    if (typeof part.toolName === "string")
+        return part.toolName;
+    return part.type.startsWith("tool-") ? part.type.slice("tool-".length) : undefined;
+}
+const narrationLimit = 240;
+function wordsOf(part) {
+    return typeof part.text === "string" ? part.text.trim() : "";
+}
+/** What the turn has done so far. The same tool twice running is one line with a count. */
+export function studioStepsOf(parts) {
+    const steps = [];
+    let repeats = 0;
+    let narration = "";
+    for (const part of parts) {
+        const name = toolNameOf(part);
+        if (name === undefined) {
+            const said = wordsOf(part);
+            if (said !== "")
+                narration = said;
+            continue;
+        }
+        const title = toolLines[name] ?? `Using ${name}`;
+        const detail = narration === "" ? undefined : narration.slice(0, narrationLimit);
+        narration = "";
+        const last = steps[steps.length - 1];
+        if (last?.title === title && detail === undefined) {
+            repeats += 1;
+            last.detail = `${repeats + 1} times`;
+            continue;
+        }
+        repeats = 0;
+        steps.push({ title, ...(detail === undefined ? {} : { detail }) });
+    }
+    return steps;
+}
+/** The answer: what was said after the last tool call. Anything before it is narration. */
+export function studioReplyOf(parts) {
+    const lastTool = parts.map((part) => toolNameOf(part) !== undefined).lastIndexOf(true);
+    return parts
+        .slice(lastTool + 1)
+        .map(wordsOf)
+        .filter((said) => said !== "")
+        .join("\n\n");
 }