@jini-ai/chat 0.3.11 → 0.5.0

package/dist/core/run-events/entry.d.ts

@@ -0,0 +1,121 @@
+/** Framework-free daemon frame reduction, shared by live and saved chat turns.
+ * Preserve named frame vocabulary, terminal classifications, error-before-success precedence,
+ * compaction and paragraph boundaries so live and persisted turns agree. Notice strings, custom
+ * event names and excluded run-ID prefixes are explicit host inputs, never product wire defaults.
+ * Authenticated routing, ownership, boot repair and storage transactions remain host responsibilities. */
+import type { AgentEvent } from "../events.js";
+import type { ChatRunStatus } from "../messages.js";
+export interface RunAgentPayload {
+    readonly type: string;
+    readonly [key: string]: unknown;
+}
+export interface RunProtocolEventWire {
+    readonly runId: string;
+    readonly kind: "start" | "agent" | "stdout" | "stderr" | "error" | "end";
+    readonly payload: unknown;
+}
+/** Display a wire scalar or JSON value using the existing empty-null convention. */
+export declare function asString({ value }: {
+    value: unknown;
+}): string;
+/** Keep only numeric usage fields; omit absent fields without changing JSON output. */
+export declare function parseUsageEvent({ payload }: {
+    payload: RunAgentPayload;
+}): AgentEvent;
+/** Reduce one daemon payload; preserve UI envelopes and drop duplicate input fragments. */
+export declare function translateRunAgentPayload({ payload }: {
+    payload: RunAgentPayload;
+}): AgentEvent | null;
+/** Host-supplied status messages; no host branding or log path defaults. */
+export interface RunNotices {
+    readonly toolStepLimit: Extract<AgentEvent, {
+        kind: "status";
+    }>;
+    readonly interrupted: Extract<AgentEvent, {
+        kind: "status";
+    }>;
+    readonly neverStarted: Extract<AgentEvent, {
+        kind: "status";
+    }>;
+    readonly canceledLabel: string;
+    readonly failedLabel: string;
+    readonly terminalDetail: (args: {
+        outcome: TerminalOutcome;
+    }) => string;
+}
+/** A host notice for a run that used its tool-step budget. */
+export declare function terminalReasonNotice({ reason, notice }: {
+    reason: string;
+    notice: Extract<AgentEvent, {
+        kind: "status";
+    }>;
+}): AgentEvent | null;
+export interface TerminalOutcome {
+    readonly status: "failed" | "canceled";
+    readonly code: string;
+    readonly signal: string;
+    readonly resumable: string;
+}
+/** Read non-successful daemon classification without throwing on malformed frames. */
+export declare function readTerminalOutcome({ raw }: {
+    raw: string | undefined;
+}): TerminalOutcome | null;
+/** A visible terminal classification rendered with host-supplied copy. */
+export declare function terminalOutcomeNotice({ raw, notices }: {
+    raw: string | undefined;
+    notices: RunNotices;
+}): AgentEvent | null;
+/** Report a failed run; operator cancellation is not a failure. */
+export declare function terminalFailureError({ raw }: {
+    raw: string | undefined;
+}): Error | null;
+/** Read a wrapped daemon or bare provider terminal reason, failing soft. */
+export declare function readTerminalReason({ raw, wrapped }: {
+    raw: string | undefined;
+    wrapped: boolean;
+}): string;
+/** Parse the existing named SSE framing; bare keepalive frames return null. */
+export declare function parseFrame({ rawFrame }: {
+    rawFrame: string;
+}): {
+    event: string;
+    data: string;
+} | null;
+/** Decode the existing named SSE framing; cancellation always releases its reader. */
+export declare function readSseFrames({ body }: {
+    body: ReadableStream<Uint8Array>;
+}): AsyncGenerator<{
+    event: string;
+    data: string;
+}>;
+/** Identify runs held by the daemon using the host's excluded ID prefixes. */
+export declare function isDaemonRunId({ runId, excludedPrefixes }: {
+    runId: string;
+    excludedPrefixes: readonly string[];
+}): boolean;
+/** Copy the host's interruption notice into a saved turn. */
+export declare function runInterruptedNotice({ notice }: {
+    notice: Extract<AgentEvent, {
+        kind: "status";
+    }>;
+}): AgentEvent;
+/** Use the same paragraph-boundary rule as a live chat turn. */
+export declare function runContentFromEvents({ events }: {
+    events: readonly AgentEvent[];
+}): string;
+/** Compact adjacent text/thinking deltas for durable storage. */
+export declare function runEventsForSave({ events }: {
+    events: readonly AgentEvent[];
+}): AgentEvent[];
+export interface RunFrameOutcome {
+    readonly events: AgentEvent[];
+    readonly error?: Error;
+    readonly terminal?: Extract<ChatRunStatus, "succeeded" | "failed" | "canceled">;
+}
+/** Fold one named daemon frame into events, a failure and an optional terminal status. */
+export declare function translateRunFrame({ kind, raw, notices }: {
+    kind: string;
+    raw: string | undefined;
+    notices: RunNotices;
+}): RunFrameOutcome;
+//# sourceMappingURL=entry.d.ts.map

package/dist/core/run-events/entry.js

@@ -0,0 +1,290 @@
+/** Framework-free daemon frame reduction, shared by live and saved chat turns.
+ * Preserve named frame vocabulary, terminal classifications, error-before-success precedence,
+ * compaction and paragraph boundaries so live and persisted turns agree. Notice strings, custom
+ * event names and excluded run-ID prefixes are explicit host inputs, never product wire defaults.
+ * Authenticated routing, ownership, boot repair and storage transactions remain host responsibilities. */
+import { assistantContentFromEvents } from "../assistant-content.js";
+import { mergeAdjacentTextEvents } from "../compact-events.js";
+function wireString(v) {
+    return typeof v === "string" ? v : v == null ? "" : JSON.stringify(v);
+}
+/** Display a wire scalar or JSON value using the existing empty-null convention. */
+export function asString({ value }) {
+    return wireString(value);
+}
+/** Keep only numeric usage fields; omit absent fields without changing JSON output. */
+export function parseUsageEvent({ payload }) {
+    const usage = (payload.usage ?? {});
+    return {
+        kind: "usage",
+        ...(typeof usage.input_tokens === "number" ? { inputTokens: usage.input_tokens } : {}),
+        ...(typeof usage.output_tokens === "number" ? { outputTokens: usage.output_tokens } : {}),
+        ...(typeof payload.costUsd === "number" ? { costUsd: payload.costUsd } : {}),
+        ...(typeof payload.durationMs === "number" ? { durationMs: payload.durationMs } : {}),
+    };
+}
+/** Reduce one daemon payload; preserve UI envelopes and drop duplicate input fragments. */
+export function translateRunAgentPayload({ payload }) {
+    switch (payload.type) {
+        case "status":
+            return { kind: "status", label: wireString(payload.label), ...(payload.detail ? { detail: wireString(payload.detail) } : {}) };
+        case "text_delta":
+            return { kind: "text", text: wireString(payload.delta) };
+        case "thinking_delta":
+            return { kind: "thinking", text: wireString(payload.delta) };
+        case "tool_use":
+            return { kind: "tool_use", id: wireString(payload.id), name: wireString(payload.name), input: payload.input };
+        case "tool_result":
+            return {
+                kind: "tool_result",
+                toolUseId: wireString(payload.toolUseId),
+                content: wireString(payload.content),
+                isError: Boolean(payload.isError),
+                ...(Array.isArray(payload.media) ? { media: payload.media } : {}),
+            };
+        case "usage":
+            return parseUsageEvent({ payload });
+        case "raw":
+            return { kind: "raw", line: wireString(payload.line) };
+        case "mcp-ui":
+            return { kind: "ext", name: "mcp-ui", data: payload.resource };
+        case "a2ui":
+            return { kind: "ext", name: "a2ui", data: payload.message };
+        case "thinking_start":
+            return null;
+        case "tool_input_delta":
+            return null;
+        default:
+            return { kind: "ext", name: payload.type, data: payload };
+    }
+}
+/** A host notice for a run that used its tool-step budget. */
+export function terminalReasonNotice({ reason, notice }) {
+    return reason === "max_tool_turns" ? { ...notice } : null;
+}
+function neverStarted(outcome) {
+    return outcome.status === "failed" && outcome.code === "none" && outcome.signal === "none" && outcome.resumable === "no";
+}
+/** Read non-successful daemon classification without throwing on malformed frames. */
+export function readTerminalOutcome({ raw }) {
+    if (!raw)
+        return null;
+    let payload;
+    try {
+        const frame = JSON.parse(raw);
+        if (!isRecord(frame) || !isRecord(frame.payload))
+            return null;
+        payload = frame.payload;
+    }
+    catch {
+        return null;
+    }
+    const status = payload.status;
+    if (status !== "failed" && status !== "canceled")
+        return null;
+    return {
+        status,
+        code: typeof payload.code === "number" ? String(payload.code) : "none",
+        signal: typeof payload.signal === "string" ? payload.signal : "none",
+        resumable: payload.resumable === true ? "yes" : "no",
+    };
+}
+/** A visible terminal classification rendered with host-supplied copy. */
+export function terminalOutcomeNotice({ raw, notices }) {
+    const outcome = readTerminalOutcome({ raw });
+    if (!outcome)
+        return null;
+    if (neverStarted(outcome))
+        return { ...notices.neverStarted };
+    return { kind: "status", label: outcome.status === "canceled" ? notices.canceledLabel : notices.failedLabel,
+        detail: notices.terminalDetail({ outcome }) };
+}
+/** Report a failed run; operator cancellation is not a failure. */
+export function terminalFailureError({ raw }) {
+    const outcome = readTerminalOutcome({ raw });
+    if (!outcome || outcome.status !== "failed")
+        return null;
+    if (neverStarted(outcome))
+        return new Error("The run failed before the agent started.");
+    return new Error(`The agent process exited without answering (exit code ${outcome.code}, signal ${outcome.signal}, resumable ${outcome.resumable}).`);
+}
+/** Read a wrapped daemon or bare provider terminal reason, failing soft. */
+export function readTerminalReason({ raw, wrapped }) {
+    if (!raw)
+        return "";
+    try {
+        const parsed = JSON.parse(raw);
+        const source = wrapped ? (parsed.payload ?? {}) : parsed;
+        return wireString(source.reason);
+    }
+    catch {
+        return "";
+    }
+}
+/** Parse the existing named SSE framing; bare keepalive frames return null. */
+export function parseFrame({ rawFrame }) {
+    let event = "message";
+    const dataLines = [];
+    for (const line of rawFrame.split("\n")) {
+        if (line.startsWith("event:"))
+            event = line.slice(6).trim();
+        else if (line.startsWith("data:"))
+            dataLines.push(line.slice(5).trim());
+    }
+    return dataLines.length > 0 ? { event, data: dataLines.join("\n") } : null;
+}
+/** Decode the existing named SSE framing; cancellation always releases its reader. */
+export async function* readSseFrames({ body }) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let ended = false;
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done) {
+                ended = true;
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            let boundary = buffer.indexOf("\n\n");
+            while (boundary !== -1) {
+                const rawFrame = buffer.slice(0, boundary);
+                buffer = buffer.slice(boundary + 2);
+                const frame = parseFrame({ rawFrame });
+                if (frame)
+                    yield frame;
+                boundary = buffer.indexOf("\n\n");
+            }
+        }
+    }
+    finally {
+        if (!ended)
+            await reader.cancel().catch(() => undefined);
+        reader.releaseLock();
+    }
+}
+/** Identify runs held by the daemon using the host's excluded ID prefixes. */
+export function isDaemonRunId({ runId, excludedPrefixes }) {
+    return runId.length > 0 && !excludedPrefixes.some(prefix => runId.startsWith(prefix));
+}
+/** Copy the host's interruption notice into a saved turn. */
+export function runInterruptedNotice({ notice }) {
+    return { ...notice };
+}
+/** Use the same paragraph-boundary rule as a live chat turn. */
+export function runContentFromEvents({ events }) {
+    return assistantContentFromEvents({ events });
+}
+/** Compact adjacent text/thinking deltas for durable storage. */
+export function runEventsForSave({ events }) {
+    return mergeAdjacentTextEvents({ events });
+}
+function parseWire(raw) {
+    if (!raw)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        return isRecord(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function parseJsonLine(line) {
+    if (!line.startsWith("{"))
+        return null;
+    try {
+        const value = JSON.parse(line);
+        return typeof value === "object" && value !== null ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+function numberOf(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function retryData(line) {
+    const attempt = numberOf(line.attempt);
+    const maxAttempts = numberOf(line.max_retries);
+    return { ...(attempt !== undefined ? { attempt } : {}), ...(maxAttempts !== undefined ? { maxAttempts } : {}), service: "Claude" };
+}
+function heartbeatStatus(line) {
+    if (line.type === "tool_progress") {
+        const elapsedSeconds = numberOf(line.elapsed_time_seconds);
+        return { kind: "status", code: "tool_progress", label: "tool_progress", ...(elapsedSeconds !== undefined ? { data: { elapsedSeconds } } : {}) };
+    }
+    if (line.type !== "system")
+        return null;
+    if (line.subtype === "api_retry") {
+        const detail = [numberOf(line.error_status), typeof line.error === "string" ? line.error : undefined].filter((p) => p !== undefined).join(" ");
+        return { kind: "status", code: "api_retry", label: "api_retry", ...(detail ? { detail } : {}), data: retryData(line) };
+    }
+    if (line.subtype === "thinking_tokens")
+        return { kind: "status", code: "thinking", label: "thinking" };
+    return null;
+}
+const ECHO_LINE = /^\{"type":"(?:stream_event|assistant|user)"/;
+function chunkEvent(raw) {
+    const frame = parseWire(raw);
+    if (!frame)
+        return [];
+    const chunk = wireString(frame.payload?.chunk);
+    const statuses = [];
+    let kept = "";
+    let droppedAny = false;
+    for (const piece of chunk.split(/(?<=\n)/)) {
+        if (ECHO_LINE.test(piece.trimStart())) {
+            droppedAny = true;
+            continue;
+        }
+        const line = parseJsonLine(piece.trim());
+        const status = line ? heartbeatStatus(line) : null;
+        if (status)
+            statuses.push(status);
+        kept += piece;
+    }
+    if (!droppedAny)
+        kept = chunk;
+    return kept.length > 0 ? [{ kind: "raw", line: kept }, ...statuses] : statuses;
+}
+function endOutcome(raw, notices) {
+    const events = [];
+    const reasonNotice = terminalReasonNotice({ reason: readTerminalReason({ raw, wrapped: true }), notice: notices.toolStepLimit });
+    if (reasonNotice)
+        events.push(reasonNotice);
+    const outcomeNotice = terminalOutcomeNotice({ raw, notices });
+    if (outcomeNotice)
+        events.push(outcomeNotice);
+    const error = terminalFailureError({ raw });
+    const outcome = readTerminalOutcome({ raw });
+    const terminal = outcome?.status ?? "succeeded";
+    return error ? { events, error, terminal } : { events, terminal };
+}
+/** Fold one named daemon frame into events, a failure and an optional terminal status. */
+export function translateRunFrame({ kind, raw, notices }) {
+    switch (kind) {
+        case "agent": {
+            const frame = parseWire(raw);
+            const translated = frame && isRecord(frame.payload) && typeof frame.payload.type === "string" ? translateRunAgentPayload({ payload: frame.payload }) : null;
+            return { events: translated ? [translated] : [] };
+        }
+        case "stdout":
+        case "stderr":
+            return { events: chunkEvent(raw) };
+        case "error": {
+            const frame = parseWire(raw);
+            const message = wireString(frame?.payload?.message) || "agent run failed";
+            return { events: [{ kind: "status", label: message }], error: new Error(message) };
+        }
+        case "end":
+            return endOutcome(raw, notices);
+        default:
+            return { events: [] };
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=entry.js.map

package/dist/core/todos.d.ts

@@ -15,7 +15,9 @@ export interface TodoItem {
     activeForm?: string | undefined;
 }
 /** `true` when `name` is one of the accepted plan/TodoWrite tool-name spellings. */
-export declare function isTodoWriteToolName(name: string): boolean;
+export declare function isTodoWriteToolName({ name }: {
+    name: string;
+}): boolean;
 /**
  * Parse a plan-tool call's raw `input` into a normalized `TodoItem[]`,
  * tolerating the several shapes different agent runtimes emit (`todos` vs
@@ -26,15 +28,21 @@ export declare function isTodoWriteToolName(name: string): boolean;
  * @returns Normalized items; entries with no recognizable body text are dropped.
  * @complexity O(n) in the number of raw plan entries.
  */
-export declare function parseTodoWriteInput(input: unknown): TodoItem[];
+export declare function parseTodoWriteInput({ input }: {
+    input: unknown;
+}): TodoItem[];
 /**
  * Find the most recent plan-tool `tool_use` in a single turn's events and
  * return its parsed items, or `[]` if this turn never wrote a plan.
  * @complexity O(n), scanning from the end.
  */
-export declare function latestTodosFromEvents(events: AgentEvent[] | undefined): TodoItem[];
+export declare function latestTodosFromEvents({ events }: {
+    events: AgentEvent[] | undefined;
+}): TodoItem[];
 /** The subset of {@link latestTodosFromEvents} not yet marked `completed`. */
-export declare function unfinishedTodosFromEvents(events: AgentEvent[] | undefined): TodoItem[];
+export declare function unfinishedTodosFromEvents({ events }: {
+    events: AgentEvent[] | undefined;
+}): TodoItem[];
 /**
  * Walk a conversation in reverse to find the most recent plan-tool
  * `tool_use` across every message and return its raw (un-parsed) `input`, so
@@ -47,9 +55,11 @@ export declare function unfinishedTodosFromEvents(events: AgentEvent[] | undefin
  *   the first hit scanning backwards, so the common case (a recent plan
  *   update) is far cheaper.
  */
-export declare function latestTodoWriteInputFromMessages(messages: ReadonlyArray<{
-    events?: AgentEvent[] | undefined;
-}> | undefined): unknown | null;
+export declare function latestTodoWriteInputFromMessages({ messages }: {
+    messages: ReadonlyArray<{
+        events?: AgentEvent[] | undefined;
+    }> | undefined;
+}): unknown | null;
 /** Convenience alias for {@link latestTodoWriteInputFromMessages} matching the `latestTodoWriteInput()` name in the target API. */
 export declare const latestTodoWriteInput: typeof latestTodoWriteInputFromMessages;
 /**
@@ -66,5 +76,7 @@ export declare function latestTodoWriteInputForPinnedCard<T extends {
     events?: AgentEvent[] | undefined;
     runStatus?: ChatRunStatus | undefined;
     endedAt?: number | undefined;
-}>(messages: ReadonlyArray<T> | undefined): unknown | null;
+}>({ messages }: {
+    messages: ReadonlyArray<T> | undefined;
+}): unknown | null;
 //# sourceMappingURL=todos.d.ts.map

package/dist/core/todos.js

@@ -5,7 +5,7 @@ const TODO_WRITE_TOOL_NAMES = new Set([
     'update_plan',
 ]);
 /** `true` when `name` is one of the accepted plan/TodoWrite tool-name spellings. */
-export function isTodoWriteToolName(name) {
+export function isTodoWriteToolName({ name }) {
     return TODO_WRITE_TOOL_NAMES.has(name);
 }
 function normalizeTodoStatus(status) {
@@ -27,7 +27,7 @@ function normalizeTodoStatus(status) {
  * @returns Normalized items; entries with no recognizable body text are dropped.
  * @complexity O(n) in the number of raw plan entries.
  */
-export function parseTodoWriteInput(input) {
+export function parseTodoWriteInput({ input }) {
     if (!input || typeof input !== 'object')
         return [];
     const obj = input;
@@ -67,20 +67,20 @@ export function parseTodoWriteInput(input) {
  * return its parsed items, or `[]` if this turn never wrote a plan.
  * @complexity O(n), scanning from the end.
  */
-export function latestTodosFromEvents(events) {
+export function latestTodosFromEvents({ events }) {
     if (!events)
         return [];
     for (let i = events.length - 1; i >= 0; i -= 1) {
         const event = events[i];
-        if (event?.kind !== 'tool_use' || !isTodoWriteToolName(event.name))
+        if (event?.kind !== 'tool_use' || !isTodoWriteToolName({ name: event.name }))
             continue;
-        return parseTodoWriteInput(event.input);
+        return parseTodoWriteInput({ input: event.input });
     }
     return [];
 }
 /** The subset of {@link latestTodosFromEvents} not yet marked `completed`. */
-export function unfinishedTodosFromEvents(events) {
-    return latestTodosFromEvents(events).filter((todo) => todo.status !== 'completed');
+export function unfinishedTodosFromEvents({ events }) {
+    return latestTodosFromEvents({ events: events }).filter((todo) => todo.status !== 'completed');
 }
 /**
  * Walk a conversation in reverse to find the most recent plan-tool
@@ -94,7 +94,7 @@ export function unfinishedTodosFromEvents(events) {
  *   the first hit scanning backwards, so the common case (a recent plan
  *   update) is far cheaper.
  */
-export function latestTodoWriteInputFromMessages(messages) {
+export function latestTodoWriteInputFromMessages({ messages }) {
     if (!messages || messages.length === 0)
         return null;
     for (let mi = messages.length - 1; mi >= 0; mi -= 1) {
@@ -105,7 +105,7 @@ export function latestTodoWriteInputFromMessages(messages) {
             const event = events[ei];
             if (event?.kind !== 'tool_use')
                 continue;
-            if (!isTodoWriteToolName(event.name))
+            if (!isTodoWriteToolName({ name: event.name }))
                 continue;
             return event.input;
         }
@@ -150,7 +150,7 @@ function stoppedTodoWriteInput(input) {
  * @complexity Same as {@link latestTodoWriteInputFromMessages}, plus an O(m)
  *   remap of the winning turn's items when the run has ended.
  */
-export function latestTodoWriteInputForPinnedCard(messages) {
+export function latestTodoWriteInputForPinnedCard({ messages }) {
     if (!messages || messages.length === 0)
         return null;
     for (let mi = messages.length - 1; mi >= 0; mi -= 1) {
@@ -162,7 +162,7 @@ export function latestTodoWriteInputForPinnedCard(messages) {
             const event = events[ei];
             if (event?.kind !== 'tool_use')
                 continue;
-            if (!isTodoWriteToolName(event.name))
+            if (!isTodoWriteToolName({ name: event.name }))
                 continue;
             if (!hasTerminalRunEnded(message.runStatus, message.endedAt)) {
                 return event.input;

package/dist/core/tool-events.d.ts

@@ -14,5 +14,7 @@ import type { AgentEvent } from './events.js';
  *   `k` is the number of distinct `tool_use` ids seen — one linear pass with
  *   a `Set` membership check.
  */
-export declare function dedupeToolUsesById(events: AgentEvent[] | undefined): AgentEvent[];
+export declare function dedupeToolUsesById({ events }: {
+    events: AgentEvent[] | undefined;
+}): AgentEvent[];
 //# sourceMappingURL=tool-events.d.ts.map

package/dist/core/tool-events.js

@@ -13,7 +13,7 @@
  *   `k` is the number of distinct `tool_use` ids seen — one linear pass with
  *   a `Set` membership check.
  */
-export function dedupeToolUsesById(events) {
+export function dedupeToolUsesById({ events }) {
     if (!events || events.length === 0)
         return [];
     const seen = new Set();

package/dist/core/tool-output.d.ts

@@ -9,5 +9,7 @@
  * @returns The value re-serialized with two-space indentation, or `text` as given.
  * @complexity O(n) in `text.length`.
  */
-export declare function formatToolOutputForDisplay(text: string): string;
+export declare function formatToolOutputForDisplay({ text }: {
+    text: string;
+}): string;
 //# sourceMappingURL=tool-output.d.ts.map

package/dist/core/tool-output.js

@@ -9,7 +9,7 @@
  * @returns The value re-serialized with two-space indentation, or `text` as given.
  * @complexity O(n) in `text.length`.
  */
-export function formatToolOutputForDisplay(text) {
+export function formatToolOutputForDisplay({ text }) {
     const trimmed = text.trim();
     const first = trimmed[0];
     if (first !== '{' && first !== '[')

package/dist/core/tools.d.ts

@@ -7,7 +7,7 @@
  * `runtime/tool-renderers.ts`) — that is a presentational, React-facing
  * extension point that belongs to `@jini-ai/chat-react` (or
  * `@jini-ai/renderers-react`), not this framework-free package. See
- * source-map.md.
+ * archived provenance ledger.
  */
 import type { ToolResultEvent, ToolResultMediaBlock, ToolUseEvent } from './events.js';
 export { dedupeToolUsesById } from './tool-events.js';
@@ -40,12 +40,23 @@ export interface ToolRenderProps {
  * @param runSucceeded - Whether the (already-terminal) run succeeded. Ignored while `runStreaming` is true.
  * @complexity O(1).
  */
-export declare function deriveToolStatus(result: ToolResultEvent | undefined, runStreaming: boolean, runSucceeded?: boolean): ToolStatus;
+export declare function deriveToolStatus({ result, runStreaming }: {
+    result: ToolResultEvent | undefined;
+    runStreaming: boolean;
+}, { runSucceeded }?: {
+    runSucceeded?: (boolean) | undefined;
+}): ToolStatus;
 /**
  * Project a `tool_use`/`tool_result` pair plus run state into the render-prop
  * shape a tool-call UI consumes.
  *
  * @complexity O(1) — delegates its only branching to {@link deriveToolStatus}.
  */
-export declare function toRenderProps(use: ToolUseEvent, result: ToolResultEvent | undefined, runStreaming: boolean, runSucceeded?: boolean): ToolRenderProps;
+export declare function toRenderProps({ use, result, runStreaming }: {
+    use: ToolUseEvent;
+    result: ToolResultEvent | undefined;
+    runStreaming: boolean;
+}, { runSucceeded }?: {
+    runSucceeded?: (boolean) | undefined;
+}): ToolRenderProps;
 //# sourceMappingURL=tools.d.ts.map

package/dist/core/tools.js

@@ -15,7 +15,7 @@ export { dedupeToolUsesById } from './tool-events.js';
  * @param runSucceeded - Whether the (already-terminal) run succeeded. Ignored while `runStreaming` is true.
  * @complexity O(1).
  */
-export function deriveToolStatus(result, runStreaming, runSucceeded = false) {
+export function deriveToolStatus({ result, runStreaming }, { runSucceeded = false } = {}) {
     if (result)
         return result.isError ? 'error' : 'complete';
     if (runStreaming)
@@ -28,9 +28,9 @@ export function deriveToolStatus(result, runStreaming, runSucceeded = false) {
  *
  * @complexity O(1) — delegates its only branching to {@link deriveToolStatus}.
  */
-export function toRenderProps(use, result, runStreaming, runSucceeded = false) {
+export function toRenderProps({ use, result, runStreaming }, { runSucceeded = false } = {}) {
     return {
-        status: deriveToolStatus(result, runStreaming, runSucceeded),
+        status: deriveToolStatus({ result: result, runStreaming: runStreaming }, { runSucceeded: runSucceeded }),
         name: use.name,
         args: use.input,
         result: result?.content,