@librechat/agents 3.3.3 → 3.3.4

package/dist/types/utils/toolContent.d.ts

@@ -0,0 +1,107 @@
+import { ToolMessage, type BaseMessage } from '@langchain/core/messages';
+type ToolContent = BaseMessage['content'];
+/**
+ * Serializes values that providers render as JSON without throwing on values
+ * such as bigint or circular diagnostic metadata.
+ */
+export declare function serializeStructuredValue(value: unknown): string;
+type StructuredWorkState = {
+    remaining: number;
+    characterRemaining: number;
+    exceeded: boolean;
+    failurePlaceholder?: string;
+    propertyCache: WeakMap<object, Map<string, unknown>>;
+    propertyCacheEntries: number;
+};
+export type BoundedStructuredSerialization = {
+    /** Provider-facing head/tail preview, bounded by `maxChars`. */
+    content: string;
+    /** Exact serialized prefix up to the defensive traversal-work ceiling. */
+    prefix: string;
+    /** Exact length, or `Number.MAX_SAFE_INTEGER` when traversal was capped. */
+    originalChars: number;
+    truncated: boolean;
+};
+/**
+ * Serializes structured output while retaining at most the requested provider
+ * preview and registry prefix. The traversal never calls `toJSON` and never
+ * materializes the complete serialized string when it exceeds those limits.
+ *
+ * `prefixChars` is useful for the tool-output registry: it receives the exact
+ * serialized prefix up to `registry.perOutputLimit`, while `content` retains
+ * the provider-facing head/tail truncation behavior at `maxChars`. Property
+ * accessors are represented by a fixed placeholder instead of being invoked.
+ */
+export declare function serializeStructuredValueBounded(value: unknown, maxChars: number, prefixChars?: number, work?: StructuredWorkState): BoundedStructuredSerialization;
+export declare function isAtomicToolContentBlock(value: unknown): boolean;
+/**
+ * Produces the text representation providers use for structured tool results.
+ * Text-only block arrays stay readable; opaque blocks use canonical JSON.
+ */
+export declare function serializeToolContent(content: unknown): string;
+export declare function getToolContentCharLength(content: unknown): number;
+/**
+ * Produces provider-facing tool-result text without ever exceeding `maxChars`.
+ */
+export declare function serializeToolContentBounded(content: unknown, maxChars: number): string;
+export type CompactToolContentResult = {
+    content: ToolContent;
+    changed: boolean;
+    originalChars: number;
+};
+export type CacheControlledTextToolContent = [
+    {
+        type: 'text';
+        text: string;
+        cache_control: {
+            type: 'ephemeral';
+            ttl?: '1h';
+        };
+    }
+];
+/** Reads one safe text block and returns its bounded text payload. */
+export declare function getBoundedSingleTextToolContent(content: unknown, maxChars: number): string | undefined;
+/**
+ * Canonicalizes the single cache-decorated text block produced by tail prompt
+ * caching without invoking accessors or custom serialization hooks.
+ */
+export declare function getBoundedCacheControlledTextToolContent(content: unknown, maxChars: number): CacheControlledTextToolContent | undefined;
+export type ComputerCallOutputScreenshot = {
+    type: 'input_image';
+    image_url: string;
+    detail?: InputImageDetail;
+} | {
+    type: 'input_image';
+    file_id: string;
+    detail?: InputImageDetail;
+} | {
+    type: 'computer_screenshot';
+    image_url: string;
+} | {
+    type: 'computer_screenshot';
+    file_id: string;
+};
+type InputImageDetail = 'low' | 'high' | 'auto' | 'original';
+/**
+ * Selects the exact screenshot shape accepted by LangChain's Responses
+ * converter without invoking accessors or user-defined serialization hooks.
+ */
+export declare function getComputerCallOutputScreenshot(content: unknown): ComputerCallOutputScreenshot | undefined;
+/** Returns the provider image URL when a screenshot is URL-backed. */
+export declare function getComputerCallOutputImageUrl(content: unknown): string | undefined;
+/** Returns whether content can be sent as a native computer screenshot. */
+export declare function isComputerCallOutputContent(content: unknown): content is ToolContent;
+/** Returns whether a ToolMessage carries the native computer-output marker. */
+export declare function hasComputerCallOutputMarker(message: BaseMessage): boolean;
+/** Native Responses computer screenshots are indivisible provider payloads. */
+export declare function isComputerCallOutputMessage(message: BaseMessage): boolean;
+/**
+ * Bounds structured tool output without slicing binary/media payloads.
+ * Purely textual/structured arrays become a universally valid string tool
+ * result. For mixed-media arrays, compactable blocks become one text preview
+ * while atomic blocks remain intact.
+ */
+export declare function compactToolContent(content: unknown, maxChars: number): CompactToolContentResult;
+/** Clones a ToolMessage while retaining fields omitted by ad-hoc clones. */
+export declare function cloneToolMessageWithContent(message: ToolMessage, content: ToolContent, artifact?: unknown): ToolMessage;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "3.3.3",
+  "version": "3.3.4",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/esm/main.mjs",
   "types": "./dist/types/index.d.ts",

package/src/__tests__/stream.eagerEventExecution.test.ts

@@ -2498,6 +2498,80 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
     ).toBe(true);
   });
 
+  it('serializes bigint output before eager completion dispatch', async () => {
+    const graph = createGraph();
+    const completedEvents: Array<{ result: t.ToolEndEvent }> = [];
+    jest
+      .spyOn(events, 'safeDispatchCustomEvent')
+      .mockImplementation(async (event, data): Promise<void> => {
+        if (event === GraphEvents.ON_RUN_STEP_COMPLETED) {
+          completedEvents.push(data as { result: t.ToolEndEvent });
+          return;
+        }
+        if (event !== GraphEvents.ON_TOOL_EXECUTE) {
+          return;
+        }
+        const batch = data as t.ToolExecuteBatchRequest;
+        batch.resolve([
+          {
+            toolCallId: 'call_weather',
+            status: 'success',
+            content: [{ rowsRead: BigInt(42) }],
+          },
+        ]);
+      });
+
+    const handler = new ChatModelStreamHandler();
+    const metadata = { langgraph_node: 'agent' };
+    await handler.handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      {
+        chunk: {
+          content: '',
+          tool_call_chunks: [
+            {
+              id: 'call_weather',
+              name: 'weather',
+              args: '{"city":"NYC"}',
+              index: 0,
+            },
+          ],
+        } as unknown as t.StreamChunk,
+      },
+      metadata,
+      graph
+    );
+    await handler.handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      {
+        chunk: {
+          content: '',
+          tool_call_chunks: [
+            {
+              id: 'call_stock',
+              name: 'stock',
+              args: '{"ticker":"C',
+              index: 1,
+            },
+          ],
+        } as unknown as t.StreamChunk,
+      },
+      metadata,
+      graph
+    );
+
+    await graph.eagerEventToolExecutions.get('call_weather')?.promise;
+
+    expect(completedEvents).toHaveLength(1);
+    expect(
+      (
+        completedEvents[0].result as {
+          tool_call?: { output?: string };
+        }
+      ).tool_call?.output
+    ).toBe('[{"rowsRead":"42"}]');
+  });
+
   it('does not emit a stale eager completion after the active execution is invalidated', async () => {
     const graph = createGraph({
       getAgentContext: jest.fn(

package/src/agents/AgentContext.ts

@@ -1638,6 +1638,7 @@ export class AgentContext {
       provider: this.provider,
       tokenCounter,
       maxTokens: this.maxContextTokens,
+      maxToolResultChars: this.maxToolResultChars,
       thinkingEnabled: isThinkingEnabled(this.provider, this.clientOptions),
       indexTokenCountMap,
       contextPruningConfig: this.contextPruningConfig,