@jini-ai/chat 0.6.6 → 0.6.10

package/dist/react/features/chat-pane/create-mcp-ui-tool-caller.js

@@ -25,6 +25,47 @@ function errorFrom(body, status) {
     }
     return error;
 }
+/**
+ * The deadline's abort becomes a readable timeout; every other failure (a network error, a non-2xx
+ * rejection) passes through unchanged.
+ */
+function timeoutAware(error, timeoutMs) {
+    return error instanceof Error && error.name === 'AbortError'
+        ? new Error(`Timed out after ${timeoutMs}ms waiting for the server.`)
+        : error;
+}
+/** One POST of a confirmed action and its parsed answer; a non-2xx response rejects via {@link errorFrom}. */
+async function postToolCall({ call, endpoint, headers, signal, fetch }) {
+    // `{name, arguments}` on the MCP-UI side becomes `{toolName, params}` on the wire: `arguments`
+    // is a reserved word in a JS function scope and reads badly in a server handler, and the
+    // renamed pair matches what the reference implementation's redemption route already accepts.
+    const request = {
+        toolName: call.name,
+        params: { ...call.arguments },
+    };
+    const response = await fetch(endpoint, {
+        method: 'POST',
+        // Same-origin cookie session is the usual authenticator for the human's second step.
+        credentials: 'same-origin',
+        headers: { ...headers, 'content-type': 'application/json' },
+        body: JSON.stringify(request),
+        signal,
+    });
+    const raw = await response.text();
+    let parsed = raw;
+    if (raw.length > 0) {
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            // Left as text — a proxy's HTML error page is more useful surfaced verbatim than swapped
+            // for a generic "invalid JSON", which would hide what actually answered.
+        }
+    }
+    if (!response.ok)
+        throw errorFrom(parsed, response.status);
+    return parsed;
+}
 /**
  * Builds an {@link McpUiToolCallHandler} that POSTs `{toolName, params}` and returns the parsed
  * response.
@@ -45,46 +86,9 @@ export function createMcpUiToolCaller({ baseUrl, fetch }, options = {}) {
     return async (call) => {
         const controller = new AbortController();
         const timer = setTimeout(() => controller.abort(), timeoutMs);
-        try {
-            // `{name, arguments}` on the MCP-UI side becomes `{toolName, params}` on the wire: `arguments`
-            // is a reserved word in a JS function scope and reads badly in a server handler, and the
-            // renamed pair matches what the reference implementation's redemption route already accepts.
-            const request = {
-                toolName: call.name,
-                params: { ...call.arguments },
-            };
-            const response = await fetch(endpoint, {
-                method: 'POST',
-                // Same-origin cookie session is the usual authenticator for the human's second step.
-                credentials: 'same-origin',
-                headers: { ...options.headers, 'content-type': 'application/json' },
-                body: JSON.stringify(request),
-                signal: controller.signal,
-            });
-            const raw = await response.text();
-            let parsed = raw;
-            if (raw.length > 0) {
-                try {
-                    parsed = JSON.parse(raw);
-                }
-                catch {
-                    // Left as text — a proxy's HTML error page is more useful surfaced verbatim than swapped
-                    // for a generic "invalid JSON", which would hide what actually answered.
-                }
-            }
-            if (!response.ok)
-                throw errorFrom(parsed, response.status);
-            return parsed;
-        }
-        catch (error) {
-            if (error instanceof Error && error.name === 'AbortError') {
-                throw new Error(`Timed out after ${timeoutMs}ms waiting for the server.`);
-            }
-            throw error;
-        }
-        finally {
-            clearTimeout(timer);
-        }
+        return postToolCall({ call, endpoint, headers: options.headers, signal: controller.signal, fetch })
+            .catch((error) => { throw timeoutAware(error, timeoutMs); })
+            .finally(() => clearTimeout(timer));
     };
 }
 //# sourceMappingURL=create-mcp-ui-tool-caller.js.map

package/dist/react/features/chat-pane/create-mid-run-message-poster.d.ts

@@ -1,8 +1,8 @@
 /**
  * @module create-mid-run-message-poster
  *
- * The client half of a mid-run message: a ready-made {@link DeliverMidRunMessage} that posts text the
- * human sent while a run streams to that run's live agent. Pass it as `ChatPane`'s
+ * The client half of a mid-run message: a ready-made {@link DeliverMidRunMessage} that posts the
+ * human's text and attachment refs to the live agent. Pass it as `ChatPane`'s
  * `deliverMidRunMessage`.
  *
  * ```tsx
@@ -10,14 +10,14 @@
  * ```
  *
  * Sibling of `create-typed-answer-poster.ts`. The route is `@jini-ai/daemon`'s
- * `POST /api/runs/:runId/messages`: `202` when the agent took the text into its running turn, `409`
+ * `POST /api/runs/:runId/messages`: `202` when the agent took the whole turn, `409`
  * with `details.delivery` when it did not.
  *
  * ## Why it resolves an outcome instead of throwing
  *
  * The pane acts differently on each outcome and must never drop the text: `'unsupported'` stops the
- * run and sends the text as the next turn; `'not-running'` and `'failed'` queue it behind the run,
- * which is already ending (or may be — never cut short a run the host could not reach). A 404 means
+ * run for text-only turns, or queues an attachment turn intact; `'not-running'` queues behind the
+ * ending run; `'failed'` retains the draft for retry. A 404 means
  * the daemon never saw this run (a host-side run such as a BYOK API turn), so it is `'unsupported'`
  * too: no live process to steer, but an interrupt still works.
  */
@@ -30,7 +30,7 @@ export interface CreateMidRunMessagePosterOptions extends UserTextRedactionOptio
     readonly headers?: Readonly<Record<string, string>>;
 }
 /**
- * Builds a {@link DeliverMidRunMessage} that POSTs `{text}` to `${baseUrl}/api/runs/:runId/messages`.
+ * Posts text and optional opaque attachment refs to `${baseUrl}/api/runs/:runId/messages`.
  *
  * @param deps.baseUrl - Origin to call; `''` for same-origin.
  * @param deps.fetch - The fetch to use (the browser's, in production).

package/dist/react/features/chat-pane/create-mid-run-message-poster.js

@@ -1,8 +1,8 @@
 /**
  * @module create-mid-run-message-poster
  *
- * The client half of a mid-run message: a ready-made {@link DeliverMidRunMessage} that posts text the
- * human sent while a run streams to that run's live agent. Pass it as `ChatPane`'s
+ * The client half of a mid-run message: a ready-made {@link DeliverMidRunMessage} that posts the
+ * human's text and attachment refs to the live agent. Pass it as `ChatPane`'s
  * `deliverMidRunMessage`.
  *
  * ```tsx
@@ -10,14 +10,14 @@
  * ```
  *
  * Sibling of `create-typed-answer-poster.ts`. The route is `@jini-ai/daemon`'s
- * `POST /api/runs/:runId/messages`: `202` when the agent took the text into its running turn, `409`
+ * `POST /api/runs/:runId/messages`: `202` when the agent took the whole turn, `409`
  * with `details.delivery` when it did not.
  *
  * ## Why it resolves an outcome instead of throwing
  *
  * The pane acts differently on each outcome and must never drop the text: `'unsupported'` stops the
- * run and sends the text as the next turn; `'not-running'` and `'failed'` queue it behind the run,
- * which is already ending (or may be — never cut short a run the host could not reach). A 404 means
+ * run for text-only turns, or queues an attachment turn intact; `'not-running'` queues behind the
+ * ending run; `'failed'` retains the draft for retry. A 404 means
  * the daemon never saw this run (a host-side run such as a BYOK API turn), so it is `'unsupported'`
  * too: no live process to steer, but an interrupt still works.
  */
@@ -38,7 +38,7 @@ async function deliveryFor(response) {
     return response.status === 404 ? 'unsupported' : 'failed';
 }
 /**
- * Builds a {@link DeliverMidRunMessage} that POSTs `{text}` to `${baseUrl}/api/runs/:runId/messages`.
+ * Posts text and optional opaque attachment refs to `${baseUrl}/api/runs/:runId/messages`.
  *
  * @param deps.baseUrl - Origin to call; `''` for same-origin.
  * @param deps.fetch - The fetch to use (the browser's, in production).
@@ -48,7 +48,7 @@ async function deliveryFor(response) {
 export function createMidRunMessagePoster({ baseUrl, fetch }, options = {}) {
     const origin = baseUrl.replace(/\/$/u, '');
     const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-    return async ({ runId, text }) => {
+    return async ({ runId, text, attachments }) => {
         const result = (options.redactUserText ?? redactUserText)({ text });
         if (result.secretRedacted)
             options.onSecretRedacted?.({ secretRedacted: true, count: result.count });
@@ -59,7 +59,7 @@ export function createMidRunMessagePoster({ baseUrl, fetch }, options = {}) {
             // Same-origin cookie session: the human's own credentials authorize steering their run.
             credentials: 'same-origin',
             headers: { ...options.headers, 'content-type': 'application/json' },
-            body: JSON.stringify({ text: result.text }),
+            body: JSON.stringify({ text: result.text, ...(attachments?.length ? { attachmentIds: attachments.map(attachment => attachment.path) } : {}) }),
             signal: controller.signal,
         }).then(deliveryFor, () => 'failed');
         clearTimeout(timer);

package/dist/react/features/chat-pane/create-typed-answer-poster.d.ts

@@ -22,9 +22,9 @@
  *
  * ## Why it resolves an outcome instead of throwing
  *
- * The pane must tell three cases apart and act differently on each, never by queueing the text as a
- * new run: 202 delivered it; 409 means nothing is waiting any more (answered, expired, or never
- * open); anything else is a failure the human can retry. A rejection would collapse the last two.
+ * The pane tells three cases apart: 202 delivered the answer; 409 means nothing is waiting and
+ * permits one ordinary-message fallback; other failures retain the draft for retry. A rejection
+ * would collapse the last two and risk resending an answer whose delivery was uncertain.
  */
 import { type UserTextRedactionOptions } from '../../../core/user-text-redaction.js';
 import type { DeliverTypedAnswer } from './types.js';

package/dist/react/features/chat-pane/create-typed-answer-poster.js

@@ -22,9 +22,9 @@
  *
  * ## Why it resolves an outcome instead of throwing
  *
- * The pane must tell three cases apart and act differently on each, never by queueing the text as a
- * new run: 202 delivered it; 409 means nothing is waiting any more (answered, expired, or never
- * open); anything else is a failure the human can retry. A rejection would collapse the last two.
+ * The pane tells three cases apart: 202 delivered the answer; 409 means nothing is waiting and
+ * permits one ordinary-message fallback; other failures retain the draft for retry. A rejection
+ * would collapse the last two and risk resending an answer whose delivery was uncertain.
  */
 import { redactUserText } from '../../../core/user-text-redaction.js';
 /**

package/dist/react/features/chat-pane/hooks/useAgentRuntimePicker.hooks.d.ts

@@ -38,7 +38,10 @@ export declare function runtimeOptionLabel({ options, value, fallback }: {
     fallback: string;
 }): string;
 /**
- * Computes a viewport-bounded fixed position for the body-portaled picker.
+ * Computes a viewport-bounded fixed position for the body-portaled picker, centred on the trigger
+ * and clamped into the viewport and (when given) into `bounds`. `bounds` (the composer box) keeps a
+ * popover centred on an icon near a narrow dock's left edge from spilling onto the page beside it,
+ * the same clamp `runtimeDropUpPosition` applies to the model/effort drop-ups.
  *
  * @complexity Time/space: O(1).
  * @overallScore 100/100
@@ -46,6 +49,8 @@ export declare function runtimeOptionLabel({ options, value, fallback }: {
 export declare function runtimePopoverPosition({ trigger, placement }: {
     trigger: DOMRect;
     placement: RuntimePickerPlacement;
+}, { bounds }?: {
+    bounds?: Pick<DOMRect, 'left' | 'right'>;
 }): CSSProperties;
 /** `Tab` wraps focus around the popover's control list instead of leaving it (the popover is a
  * modal-ish dialog). Returns the index to wrap TO, or `null` when `Tab` should behave natively

package/dist/react/features/chat-pane/hooks/useAgentRuntimePicker.hooks.js

@@ -38,16 +38,21 @@ export function runtimeOptionLabel({ options, value, fallback }) {
     return options?.find((option) => option.id === value)?.label ?? value;
 }
 /**
- * Computes a viewport-bounded fixed position for the body-portaled picker.
+ * Computes a viewport-bounded fixed position for the body-portaled picker, centred on the trigger
+ * and clamped into the viewport and (when given) into `bounds`. `bounds` (the composer box) keeps a
+ * popover centred on an icon near a narrow dock's left edge from spilling onto the page beside it,
+ * the same clamp `runtimeDropUpPosition` applies to the model/effort drop-ups.
  *
  * @complexity Time/space: O(1).
  * @overallScore 100/100
  */
-export function runtimePopoverPosition({ trigger, placement }) {
+export function runtimePopoverPosition({ trigger, placement }, { bounds } = {}) {
     const margin = 12;
     const gap = 8;
-    const width = Math.min(320, window.innerWidth - margin * 2);
-    const left = Math.min(Math.max(trigger.left + trigger.width / 2 - width / 2, margin), window.innerWidth - width - margin);
+    const minLeft = Math.max(margin, bounds?.left ?? -Infinity);
+    const maxRight = Math.min(window.innerWidth - margin, bounds?.right ?? Infinity);
+    const width = Math.max(0, Math.min(320, maxRight - minLeft));
+    const left = Math.min(Math.max(trigger.left + trigger.width / 2 - width / 2, minLeft), maxRight - width);
     if (placement === 'up') {
         const availableHeight = Math.max(0, trigger.top - margin - gap);
         return {
@@ -205,8 +210,9 @@ export function useAgentRuntimePicker({ agents, value, placement, t, executionMo
             return;
         const update = () => {
             const rect = triggerRef.current?.getBoundingClientRect();
+            const bounds = triggerRef.current?.closest('.jini-composer')?.getBoundingClientRect();
             if (rect)
-                setPosition(runtimePopoverPosition({ trigger: rect, placement: placement }));
+                setPosition(runtimePopoverPosition({ trigger: rect, placement: placement }, bounds ? { bounds } : {}));
         };
         update();
         window.addEventListener('resize', update);

package/dist/react/features/chat-pane/hooks/useChatPane.hooks.d.ts

@@ -1,3 +1,4 @@
+import { type AcceptedChatInput } from '../../../../core/accepted-input.js';
 import type { UserTextRedactionOptions } from '../../../../core/user-text-redaction.js';
 import { type ChatPaneSendBlocker } from '../rules.js';
 import type { ChatPaneActivity, ChatPaneAgent, ChatPaneAttachmentUploadOptions, ChatPaneAgentSelection, ChatPaneRunContext, ChatPaneWorkingDirectoryAccess, DeliverMidRunMessage, DeliverTypedAnswer, TypedAnswerNotice } from '../types.js';
@@ -20,6 +21,8 @@ export interface UseChatPaneOptions extends UserTextRedactionOptions {
     initialDraft?: string;
     composerHistoryScope?: string;
     composerHistoryStorage?: ComposerHistoryStoragePort;
+    /** Recall retention; defaults to 100. */
+    composerHistoryCap?: number;
     /** Forwarded verbatim to `useComposer`; see `validateAttachments` there for the contract. */
     validateAttachments?: (attachments: readonly ChatAttachment[]) => Promise<readonly ChatAttachment[]>;
     uploadAttachments?: (files: File[], options?: ChatPaneAttachmentUploadOptions) => Promise<ChatAttachment[]>;
@@ -85,20 +88,22 @@ export interface UseChatPaneResult extends UseChatPaneWorkingDirectoryResult {
      * was silently swallowed.
      */
     queuedPrompt: string | null;
+    /** Individual queued messages, in send order, with their own staged files. */
+    queuedMessages: readonly AcceptedChatInput[];
+    /** Drops only the named queued message. */
+    cancelQueuedMessage: (input: {
+        id: string;
+    }, options?: {}) => void;
     /** Drops the queued prompt without ever sending it. */
     cancelQueued: () => void;
     /**
-     * Why the last typed answer was NOT sent, or `null`. Set when `deliverTypedAnswer` reports the
-     * question no longer waiting or could not be reached, and when {@link send} holds back an answer
-     * whose question has since closed; the draft stays in the composer. Cleared by the next send and
-     * by `reset()`.
+     * Delivery failure for the last typed answer, or `null`. Failures retain the draft; a definitive
+     * not-pending refusal queues one ordinary message instead. Cleared by the next send and `reset()`.
      */
     typedAnswerNotice: TypedAnswerNotice | null;
     /**
      * Sends the composer draft as an ordinary next turn (queued behind a running run, as {@link send}
-     * does) even though it was typed as an answer to a question that has since closed. The one way
-     * past {@link send}'s hold on such a draft other than clearing it: the human chose a new, possibly
-     * paid, run on purpose.
+     * does), bypassing typed-answer routing.
      */
     sendAsNewMessage: () => Promise<void>;
     /**