@adecore/agents-react 0.41.1 → 0.43.0

package/dist/chat/actions.js

@@ -61,6 +61,10 @@ export function transportActions(transport) {
       chatId,
       turnId
     })).diff,
+    toolOutput: async (chatId, itemId) => (await transport.request('chat.toolOutput', {
+      chatId,
+      itemId
+    })).output,
     stopSubagent: async (chatId, toolUseId) => {
       await transport.request('chat.stopSubagent', {
         chatId,

package/dist/chat/logic/lightbox.d.ts

@@ -0,0 +1,31 @@
+export declare const MIN_SCALE = 1;
+export declare const MAX_SCALE = 8;
+export declare const BUTTON_STEP = 1.5;
+export interface View {
+    readonly scale: number;
+    readonly x: number;
+    readonly y: number;
+}
+export declare const START: View;
+export interface Size {
+    readonly width: number;
+    readonly height: number;
+}
+export interface Bounds {
+    readonly image: Size;
+    readonly frame: Size;
+}
+export interface Point {
+    readonly x: number;
+    readonly y: number;
+}
+export interface Wheel {
+    readonly deltaX: number;
+    readonly deltaY: number;
+    readonly ctrlKey: boolean;
+}
+export declare function clamped(view: View, bounds: Bounds): View;
+export declare function zoomed(view: View, factor: number, point: Point, bounds: Bounds): View;
+export declare function panned(view: View, deltaX: number, deltaY: number, bounds: Bounds): View;
+export declare function wheeled(view: View, wheel: Wheel, point: Point, bounds: Bounds): View;
+export declare function stepped(index: number, count: number, step: -1 | 1): number | null;

package/dist/chat/logic/lightbox.js

@@ -0,0 +1,61 @@
+export const MIN_SCALE = 1;
+export const MAX_SCALE = 8;
+export const BUTTON_STEP = 1.5;
+// A trackpad pinch arrives as small ctrl-wheel deltas; a mouse notch with Ctrl is clamped so it does not jump past the detail.
+const PINCH_SPEED = 0.01;
+const PINCH_LIMIT = 50;
+export const START = {
+  scale: 1,
+  x: 0,
+  y: 0
+};
+/* Keeps an edge of the picture from leaving its side of the stage, so a flick of two fingers never loses it. */
+export function clamped(view, bounds) {
+  const maxX = Math.max(0, (bounds.image.width * view.scale - bounds.frame.width) / 2);
+  const maxY = Math.max(0, (bounds.image.height * view.scale - bounds.frame.height) / 2);
+  return {
+    scale: view.scale,
+    x: Math.min(maxX, Math.max(-maxX, view.x)),
+    y: Math.min(maxY, Math.max(-maxY, view.y))
+  };
+}
+/*
+ * Zooms around a point, which is what makes a pinch over a detail feel like a magnifier instead of
+ * a slider. The pixel under the fingers stays where it is while everything else moves away from it.
+ * `x` and `y` are offsets from the middle of the stage, so a scale of 1 is always centered.
+ */
+export function zoomed(view, factor, point, bounds) {
+  const scale = Math.min(MAX_SCALE, Math.max(MIN_SCALE, view.scale * factor));
+  if (scale === MIN_SCALE) {
+    return START;
+  }
+  const ratio = scale / view.scale;
+  return clamped({
+    scale,
+    x: point.x - (point.x - view.x) * ratio,
+    y: point.y - (point.y - view.y) * ratio
+  }, bounds);
+}
+export function panned(view, deltaX, deltaY, bounds) {
+  if (view.scale <= MIN_SCALE) {
+    return view;
+  }
+  return clamped({
+    scale: view.scale,
+    x: view.x + deltaX,
+    y: view.y + deltaY
+  }, bounds);
+}
+/* A pinch zooms (Chromium reports it as a wheel with Ctrl held) and two fingers pan the zoomed picture. */
+export function wheeled(view, wheel, point, bounds) {
+  if (wheel.ctrlKey) {
+    const delta = Math.min(PINCH_LIMIT, Math.max(-PINCH_LIMIT, wheel.deltaY));
+    return zoomed(view, Math.exp(-delta * PINCH_SPEED), point, bounds);
+  }
+  return panned(view, -wheel.deltaX, -wheel.deltaY, bounds);
+}
+/* The image a step away, or null at either end: the row does not wrap around. */
+export function stepped(index, count, step) {
+  const next = index + step;
+  return next < 0 || next >= count ? null : next;
+}

package/dist/chat/logic/timeline.d.ts

@@ -81,6 +81,7 @@ export type TimelineRow = {
     diff: ChatCheckpointDiff | null;
     checkpoint: boolean;
     baseMoved?: BaseMoved;
+    heldBack?: boolean;
 } | {
     kind: 'turn-fold';
     id: string;

package/dist/chat/logic/timeline.js

@@ -436,6 +436,9 @@ function changedFilesRow(turn, items) {
         from: turn.checkpointHead,
         to: turn.checkpointHeadAfter
       }
+    } : {}),
+    ...(turn.checkpointDiffRef ? {
+      heldBack: true
     } : {})
   };
 }

package/dist/chat/ui/AnsiOutput.d.ts

@@ -1,5 +1,6 @@
-export declare function AnsiOutput({ text, limit, tailLines }: {
+export declare function AnsiOutput({ text, limit, tailLines, marksOmitted }: {
     text: string;
-    limit?: number;
+    limit?: number | undefined;
     tailLines?: number;
+    marksOmitted?: boolean;
 }): import("react").JSX.Element;

package/dist/chat/ui/AnsiOutput.js

@@ -1,61 +1,65 @@
 import { c as _c } from "react/compiler-runtime";
 import { useTranslation } from 'react-i18next';
 import { parseAnsi } from '../logic/ansi.js';
+/* `marksOmitted` off leaves out the count of what the limit cut, for a text that is itself only a beginning. */
 import { Fragment as _Fragment, jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 export function AnsiOutput(t0) {
-  const $ = _c(11);
+  const $ = _c(12);
   const {
     text,
     limit,
-    tailLines
+    tailLines,
+    marksOmitted: t1
   } = t0;
+  const marksOmitted = t1 === undefined ? true : t1;
   const {
     t
   } = useTranslation("agent-chat");
   let omitted;
-  let t1;
+  let t2;
   if ($[0] !== limit || $[1] !== tailLines || $[2] !== text) {
     const {
       tokens,
-      omitted: t2
+      omitted: t3
     } = parseAnsi(text, {
       limit,
       tailLines
     });
-    omitted = t2;
-    t1 = tokens.map(_temp);
+    omitted = t3;
+    t2 = tokens.map(_temp);
     $[0] = limit;
     $[1] = tailLines;
     $[2] = text;
     $[3] = omitted;
-    $[4] = t1;
+    $[4] = t2;
   } else {
     omitted = $[3];
-    t1 = $[4];
+    t2 = $[4];
   }
-  let t2;
-  if ($[5] !== omitted || $[6] !== t) {
-    t2 = omitted > 0 && `\n${t("work.moreCharacters", {
+  let t3;
+  if ($[5] !== marksOmitted || $[6] !== omitted || $[7] !== t) {
+    t3 = marksOmitted && omitted > 0 && `\n${t("work.moreCharacters", {
       count: omitted
     })}`;
-    $[5] = omitted;
-    $[6] = t;
-    $[7] = t2;
+    $[5] = marksOmitted;
+    $[6] = omitted;
+    $[7] = t;
+    $[8] = t3;
   } else {
-    t2 = $[7];
+    t3 = $[8];
   }
-  let t3;
-  if ($[8] !== t1 || $[9] !== t2) {
-    t3 = /*#__PURE__*/_jsxs(_Fragment, {
-      children: [t1, t2]
+  let t4;
+  if ($[9] !== t2 || $[10] !== t3) {
+    t4 = /*#__PURE__*/_jsxs(_Fragment, {
+      children: [t2, t3]
     });
-    $[8] = t1;
     $[9] = t2;
     $[10] = t3;
+    $[11] = t4;
   } else {
-    t3 = $[10];
+    t4 = $[11];
   }
-  return t3;
+  return t4;
 }
 function _temp(token, index) {
   return /*#__PURE__*/_jsx("span", {

package/dist/chat/ui/ImageView.d.ts

@@ -1,5 +1,8 @@
 import { type ReactNode } from 'react';
 import type { ResourceUrl } from '../../host.js';
+export declare function ImageGroup({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
 export interface ImageThumbProps {
     source: ResourceUrl;
     alt: string;