@librechat/agents 3.3.5 → 3.3.7

package/dist/types/tools/intentArg.d.ts

@@ -0,0 +1,181 @@
+/**
+ * @fileoverview Tool intent labels.
+ *
+ * Lets a tool declare, as the FIRST property of its input schema, an `intent`
+ * string: one model-authored sentence stating what that specific call is about
+ * to do ("Searching for OAuth handling in the callback router"). Because the
+ * property is first, it is the first key providers stream in the tool-call
+ * args, so a host UI can render it as the call's live status label before the
+ * rest of the args exist. When the call settles, {@link applyOutcome} edits
+ * the sentence in place into its outcome form — a tool-supplied replacement
+ * (`outcome`) or a tool-supplied span edit (`outcome_patch`). Absent either,
+ * the label is left exactly as the model wrote it: completion is a UI state
+ * (the shimmer stopping, the icon settling), not a tense change.
+ *
+ * The arg is always optional (never listed in `required`): the same schemas
+ * are callable from programmatic tool calling, where no UI renders a label
+ * and forcing generated code to fabricate one would be pure cost. Tool bodies
+ * must call {@link stripIntent} before using their args so no tool receives a
+ * parameter it did not declare.
+ */
+import type { JsonSchemaType, OutcomePatch } from '@/types';
+/** Argument carrying the model-authored label for a tool call. */
+export declare const INTENT_ARG = "intent";
+/**
+ * Opening words of {@link INTENT_DESCRIPTION}, and the discriminator that
+ * tells the injected LABEL apart from a tool's own business parameter that
+ * merely shares the name `intent`.
+ *
+ * Exported because host applications reimplement the same strip/sanitize
+ * passes and would otherwise duplicate this as a string literal: if the two
+ * copies drift, the host silently stops recognizing SDK-native labels and
+ * fails OPEN (labels stay in schemas, opt-outs stop working) with no error.
+ * Any edit to the description must preserve this prefix verbatim.
+ */
+export declare const INTENT_LABEL_MARKER = "ALWAYS write this field FIRST";
+/**
+ * Model-facing instruction for the injected `intent` property.
+ *
+ * Deliberately terse — it is repeated on every opted-in tool schema, on every
+ * request, so each sentence is paid for many times over. What remains is
+ * load-bearing: first-position placement (the entire streaming mechanism),
+ * the one-sentence present-progressive form, who reads it, and the sibling
+ * rule, without which models emit identical labels for parallel calls to one
+ * tool and defeat the feature's headline case.
+ */
+export declare const INTENT_DESCRIPTION: string;
+/**
+ * Canonical (frozen) shape of the injected property. Always embed a COPY
+ * (`{ ...INTENT_PROPERTY }`): LangChain's JSON-schema validator stamps a
+ * `__absolute_uri__` marker onto every subschema it dereferences, which
+ * throws on a frozen object — and a single shared instance would be stamped
+ * with one schema's URI while embedded in many.
+ */
+export declare const INTENT_PROPERTY: JsonSchemaType;
+/**
+ * Discriminates the intent LABEL property from a tool's own business
+ * parameter that merely shares the name: the label contract always opens
+ * with the same instruction. Removal/sanitize passes must never strip a
+ * parameter the tool actually needs.
+ */
+export declare function isIntentLabelProperty(property: unknown): boolean;
+/**
+ * Schema shape accepted by {@link withoutIntent}.
+ *
+ * `required` is widened to `readonly string[]` because the SDK's own native
+ * schemas are declared `as const` — their `required` is a readonly tuple, and
+ * a mutable `string[]` parameter would reject the very schemas this helper
+ * exists for (TS2345), forcing embedders to cast to use the advertised API.
+ */
+export type IntentStrippableSchema = Omit<JsonSchemaType, 'required'> & {
+    required?: readonly string[];
+};
+/**
+ * Returns a copy of `parameters` without the injected intent LABEL — the
+ * opt-out for consumers that render no status label and should not pay for
+ * the property.
+ *
+ * The SDK's native schemas carry the label unconditionally, so without this
+ * an embedder has no lever at all: `withIntent` is applied at module scope.
+ * Marker-guarded, so a tool's own business parameter named `intent` is never
+ * removed. Returns the input unchanged when there is nothing to strip.
+ *
+ * `required` is pruned alongside the property: a schema that lists `intent`
+ * as required (strict-mode normalization does exactly that, since OpenAI
+ * strict function schemas require every property to appear in `required`)
+ * would otherwise be left naming a property it no longer declares, which is
+ * invalid JSON Schema and gets rejected by the provider instead of quietly
+ * opting out.
+ */
+export declare function withoutIntent(parameters?: IntentStrippableSchema): JsonSchemaType | undefined;
+/**
+ * Returns a copy of the parameters schema with `intent` prepended as the
+ * FIRST property (object key order is insertion order and every provider
+ * serializer preserves it — first key in the schema means first key in the
+ * streamed input). Never mutates the input; no-op when the schema already
+ * declares `intent`. The property is not added to `required`.
+ */
+export declare function withIntent(parameters?: JsonSchemaType): JsonSchemaType;
+/**
+ * Reads the model-authored intent from tool-call args (handles stringified
+ * args). Returns undefined when absent, empty, or not a string.
+ */
+export declare function readIntent(args: unknown): string | undefined;
+/**
+ * Returns the args without the `intent` key so downstream consumers that did
+ * not declare it never receive it. Parses stringified JSON object args;
+ * returns the value unchanged when the key is absent.
+ */
+export declare function stripIntent(args: unknown): unknown;
+/**
+ * Resolves the settled label for a call from its model-authored `intent` and
+ * the tool's result fields, in precedence order:
+ *
+ *  1. `outcome` — full replacement authored by the tool.
+ *  2. `outcome_patch` — first occurrence of `from` in the intent replaced
+ *     with `to` (case-sensitive); no-op when `from` is absent or empty.
+ *  3. Otherwise the intent is returned UNCHANGED.
+ *
+ * There is deliberately no mechanical present-progressive→past-tense rewrite.
+ * Such a transform can only be a closed list of English verbs, which makes it
+ * wrong in three ways at once: it never fires for the non-English labels this
+ * feature expects (the model answers in the user's language), it fires for
+ * some sibling calls and not others inside one group — "Searched…" beside
+ * "Recording…" — and it quietly enumerates a vocabulary in a feature whose
+ * premise is that the sentence is free-form. Completion is conveyed by UI
+ * state (the shimmer stopping, the icon settling), which is language-neutral
+ * and always consistent; a tool that wants past tense says so explicitly via
+ * `outcome` or `outcome_patch`.
+ *
+ * Returns undefined when there is neither an intent nor an outcome, so
+ * callers fall back to their default label. Pure and dependency-free — host
+ * UIs needing identical logic can import or mirror it.
+ */
+export declare function applyOutcome(intent: string | undefined, result?: {
+    outcome?: string;
+    outcome_patch?: OutcomePatch;
+}): string | undefined;
+/**
+ * Resolves the settled label to emit on a completion event: only when the
+ * tool actually authored `outcome`/`outcome_patch` fields. Returns undefined
+ * otherwise, so the wire never carries a label the host already has — a bare
+ * intent needs no settled form, because it is displayed unchanged and the UI
+ * conveys completion through its own state. Hosts must NOT rewrite it (see
+ * {@link applyOutcome} for why a tense transform is deliberately absent). The
+ * result is collapsed to a bounded single line before emission.
+ *
+ * For failed calls (`isError`), only tool-AUTHORED text may label the call:
+ * an explicit `outcome`, or a patch whose `from` actually matches the intent.
+ * An unmatched patch resolves to undefined rather than silently reusing the
+ * in-flight intent, so a failure is never labelled as though it succeeded.
+ */
+export declare function resolveToolOutcome(args: unknown, fields?: {
+    outcome?: string;
+    outcome_patch?: OutcomePatch;
+} | null, options?: {
+    isError?: boolean;
+}): string | undefined;
+/**
+ * Reads the outcome fields off a tool-execution result: the typed
+ * `outcome`/`outcome_patch` fields when present, else the artifact channel
+ * (see {@link readOutcomeFields}) — so a `content_and_artifact` tool authors
+ * its label the same way on the direct and event-driven paths.
+ */
+export declare function outcomeFieldsFromResult(result: {
+    outcome?: string;
+    outcome_patch?: OutcomePatch;
+    artifact?: unknown;
+}): {
+    outcome?: string;
+    outcome_patch?: OutcomePatch;
+} | undefined;
+/**
+ * Extracts validated `outcome`/`outcome_patch` fields from an arbitrary
+ * value — the artifact channel through which an in-process
+ * `content_and_artifact` tool authors its settled label. Returns undefined
+ * when neither field is usable.
+ */
+export declare function readOutcomeFields(source: unknown): {
+    outcome?: string;
+    outcome_patch?: OutcomePatch;
+} | undefined;

package/dist/types/tools/ptcTimeout.d.ts

@@ -1,3 +1,4 @@
+import type { JsonSchemaType } from '@/types';
 export declare const DEFAULT_CODE_API_RUN_TIMEOUT_MS = 15000;
 export declare const MIN_CODE_API_RUN_TIMEOUT_MS = 1000;
 export declare const MAX_CODE_API_RUN_TIMEOUT_SCHEMA_MS = 300000;
@@ -11,6 +12,7 @@ type TimeoutSchema = {
 export type ProgrammaticToolCallingJsonSchema = {
     type: 'object';
     properties: {
+        intent: JsonSchemaType;
         code: {
             type: 'string';
             minLength: number;

package/dist/types/tools/search/schema.d.ts

@@ -36,6 +36,15 @@ export declare const newsSchema: {
 export declare const WebSearchToolSchema: {
     readonly type: "object";
     readonly properties: {
+        readonly intent: {
+            readonly type: "string" | "number" | "integer" | "float" | "boolean" | "array" | "object";
+            readonly enum?: string[];
+            readonly items?: import("../..").JsonSchemaType;
+            readonly properties?: Record<string, import("../..").JsonSchemaType>;
+            readonly required?: string[];
+            readonly description?: string;
+            readonly additionalProperties?: boolean | import("../..").JsonSchemaType;
+        };
         readonly query: {
             readonly type: "string";
             readonly description: string;
@@ -72,6 +81,15 @@ export declare const WebSearchToolDefinition: {
     readonly schema: {
         readonly type: "object";
         readonly properties: {
+            readonly intent: {
+                readonly type: "string" | "number" | "integer" | "float" | "boolean" | "array" | "object";
+                readonly enum?: string[];
+                readonly items?: import("../..").JsonSchemaType;
+                readonly properties?: Record<string, import("../..").JsonSchemaType>;
+                readonly required?: string[];
+                readonly description?: string;
+                readonly additionalProperties?: boolean | import("../..").JsonSchemaType;
+            };
             readonly query: {
                 readonly type: "string";
                 readonly description: string;

package/dist/types/tools/search/tool.d.ts

@@ -2,6 +2,24 @@ import { DynamicStructuredTool } from '@langchain/core/tools';
 import type * as t from './types';
 import { DATE_RANGE } from './schema';
 import { createSearchAPI } from './search';
+/**
+ * Settled label for a `web_search` call's intent (see `intentArg.ts`).
+ *
+ * Counts the result kinds `formatResultsForLLM` actually renders —
+ * `references` only tracks links embedded in extracted highlights, so it
+ * undercounts ordinary results and can overcount when one highlight embeds
+ * several links.
+ *
+ * A caught provider or processing failure is reported through `data.error`
+ * while the tool still returns NORMALLY, so that case must author its own
+ * label: the `ToolMessage` carries success status, so without an authored
+ * outcome the in-flight intent ("Searching…") would stand as the settled
+ * label and present a failed search as an ordinary one.
+ *
+ * Returns undefined for a genuine zero-result search, leaving the
+ * model-authored intent to stand unchanged as the label.
+ */
+export declare function resolveSearchOutcome(data: t.SearchResultData, query: string): string | undefined;
 /**
  * Executes parallel searches and merges the results,
  * deduplicating top stories by link

package/dist/types/tools/toolOutputReferences.d.ts

@@ -69,8 +69,18 @@ export type ResolveResult<T> = {
  * point in time, ignoring any subsequent registrations.
  */
 export interface ToolOutputResolveView {
-    resolve<T>(args: T): ResolveResult<T>;
+    resolve<T>(args: T, options?: ResolveOptions): ResolveResult<T>;
 }
+/**
+ * Per-call resolution options. `substituteIntentKey` opts the top-level
+ * `intent` key back INTO placeholder substitution: the exemption protects
+ * the injected display label, but a tool whose own schema declares a
+ * business parameter named `intent` (the injectors skip such tools) still
+ * needs references piped into it like any other argument.
+ */
+export type ResolveOptions = {
+    substituteIntentKey?: boolean;
+};
 /**
  * Pre-resolved arg map keyed by `toolCallId`. Used by the mixed
  * direct+event dispatch path to feed event calls' resolved args
@@ -166,7 +176,7 @@ export declare class ToolOutputReferenceRegistry {
      * the serialized args, the original input is returned without
      * walking the tree.
      */
-    resolve<T>(runId: string | undefined, args: T): ResolveResult<T>;
+    resolve<T>(runId: string | undefined, args: T, options?: ResolveOptions): ResolveResult<T>;
     /**
      * Captures a frozen snapshot of `runId`'s current entries and
      * returns a view that resolves placeholders against *only* that

package/dist/types/types/stream.d.ts

@@ -98,6 +98,19 @@ export type ProcessedToolCall = {
     id: string;
     output: string;
     progress: number;
+    /**
+     * Settled label for the call, resolved from the tool-supplied
+     * `outcome`/`outcome_patch` result fields against the model-authored
+     * `intent` arg. Present ONLY when the tool authored one.
+     *
+     * When absent, display the `intent` arg unchanged — do NOT rewrite its
+     * tense. A gerund→past-tense rewrite can only be a closed list of English
+     * verbs, so it never fires for the non-English labels this feature expects
+     * and fires for some sibling calls but not others within one group.
+     * Completion belongs to UI state (the shimmer stopping, the icon settling),
+     * which is language-neutral and always consistent.
+     */
+    outcome?: string;
 };
 export type ProcessedContent = {
     type: ContentType;
@@ -265,6 +278,11 @@ export type ToolCallPart = {
     id?: string;
     /** If provided, the output of the tool call */
     output?: ToolResultContent['content'];
+    /**
+     * Tool-authored settled label for the call (see `ProcessedToolCall.outcome`),
+     * preserved through aggregation so it survives persistence/reload.
+     */
+    outcome?: string;
     /** Auth URL */
     auth?: string;
     /** Expiration time */

package/dist/types/types/tools.d.ts

@@ -224,8 +224,16 @@ export type ToolNodeConstructorParams = ToolRefs & ToolNodeOptions;
 export type ToolEndEvent = {
     /** The Step Id of the Tool Call */
     id: string;
-    /** The Completed Tool Call */
-    tool_call: ToolCall;
+    /**
+     * The Completed Tool Call. Carries the tool-authored `outcome` label when
+     * present (see `ProcessedToolCall.outcome`) so `ON_RUN_STEP_COMPLETED`
+     * consumers can read it without an unsafe cast.
+     */
+    tool_call: ToolCall & {
+        output?: string;
+        progress?: number;
+        outcome?: string;
+    };
     /** The content index of the tool call */
     index: number;
     type?: 'tool_call';
@@ -486,6 +494,16 @@ export type InjectedMessage = {
     /** Only set when source is 'skill', for compaction preservation */
     skillName?: string;
 };
+/**
+ * In-place edit of a call's model-authored `intent` label: the first
+ * occurrence of `from` in the intent is replaced with `to` (case-sensitive).
+ * Lets a tool settle the label while preserving the model's own phrasing,
+ * e.g. `{ from: 'Searching', to: 'Searched' }`.
+ */
+export type OutcomePatch = {
+    from: string;
+    to: string;
+};
 /** Result for a single tool call in event-driven execution */
 export type ToolExecuteResult = {
     /** Matches ToolCallRequest.id */
@@ -498,6 +516,13 @@ export type ToolExecuteResult = {
     status: 'success' | 'error';
     /** Error message if status is 'error' */
     errorMessage?: string;
+    /**
+     * Settled human-readable label for this call, replacing the model-authored
+     * `intent` arg in the UI. Full replacement; wins over `outcome_patch`.
+     */
+    outcome?: string;
+    /** In-place edit of the model-authored `intent` label (see {@link OutcomePatch}). */
+    outcome_patch?: OutcomePatch;
     /**
      * Messages to inject into graph state after the ToolMessage for this call.
      * Placed after tool results to respect provider message ordering (tool_call -> tool_result adjacency).

package/package.json

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

package/src/index.ts

@@ -26,6 +26,7 @@ export * from './tools/ReadFile';
 export * from './tools/skillCatalog';
 export * from './tools/ToolSearch';
 export * from './tools/ToolNode';
+export * from './tools/intentArg';
 export * from './tools/schema';
 export * from './tools/handlers';
 export * from './tools/local';

package/src/llm/openai/index.ts

@@ -51,6 +51,7 @@ import {
   projectOpenAIResponsesToolMessageContent,
   projectToolStreamContentForProvider,
 } from '@/messages/core';
+import { INTENT_ARG, isIntentLabelProperty } from '@/tools/intentArg';
 import { isReasoningModel, _convertMessagesToOpenAIParams } from './utils';
 import { dropRepeatedScalarMetadata } from './streamMetadata';
 
@@ -1003,6 +1004,65 @@ function createAbortHandler(controller: AbortController): () => void {
  * @param {Object} [fields] Additional fields to add to the OpenAI tool.
  * @returns {ToolDefinition} The inputted tool in OpenAI tool format.
  */
+/**
+ * OpenAI strict function schemas require every property to appear in
+ * `required`. The optional `intent` label (see `tools/intentArg.ts`) is
+ * deliberately NOT required — the same schema is callable from programmatic
+ * tool calling — so a tool auto-marked `strict: true` (the non-streaming
+ * `json_schema` structured-output path) would be rejected as invalid before
+ * execution. That path never streams a live label anyway, so the
+ * marker-identified property is dropped there; every other path keeps it.
+ */
+function stripIntentFromStrictTools<T extends object>(params: T): T {
+  const record = params as { tools?: unknown[] };
+  const tools = record.tools;
+  if (!Array.isArray(tools) || tools.length === 0) {
+    return params;
+  }
+  const nextTools = tools.map((tool) => {
+    const candidate = tool as {
+      strict?: boolean;
+      parameters?: { properties?: Record<string, unknown>; required?: unknown };
+      function?: {
+        strict?: boolean;
+        parameters?: {
+          properties?: Record<string, unknown>;
+          required?: unknown;
+        };
+      };
+    };
+    /** Chat-completions tools nest under `function`; responses-API tools are flat. */
+    const holder = candidate.function ?? candidate;
+    if (holder.strict !== true) {
+      return tool;
+    }
+    const parameters = holder.parameters;
+    const properties = parameters?.properties;
+    if (properties == null || !isIntentLabelProperty(properties[INTENT_ARG])) {
+      return tool;
+    }
+    const required = Array.isArray(parameters?.required)
+      ? (parameters.required as unknown[])
+      : [];
+    if (required.includes(INTENT_ARG)) {
+      return tool;
+    }
+    const { [INTENT_ARG]: _omit, ...restProps } = properties;
+    const nextParams = { ...parameters, properties: restProps };
+    if (candidate.function != null) {
+      return {
+        ...candidate,
+        function: { ...candidate.function, parameters: nextParams },
+      };
+    }
+    return { ...candidate, parameters: nextParams };
+  });
+  if (nextTools.every((tool, index) => tool === tools[index])) {
+    return params;
+  }
+  return { ...params, tools: nextTools } as T;
+}
+
 export function _convertToOpenAITool(
   tool: BindToolsInput,
   fields?: {
@@ -1184,10 +1244,12 @@ class LibreChatOpenAICompletions extends OriginalChatOpenAICompletions {
     options?: this['ParsedCallOptions'],
     extra?: { streaming?: boolean }
   ): ReturnType<OriginalChatOpenAICompletions['invocationParams']> {
-    return applyManagedRequestParams(super.invocationParams(options, extra), {
-      promptCacheExplicit: this.promptCacheExplicit,
-      safetyIdentifier: this.safetyIdentifier,
-    });
+    return stripIntentFromStrictTools(
+      applyManagedRequestParams(super.invocationParams(options, extra), {
+        promptCacheExplicit: this.promptCacheExplicit,
+        safetyIdentifier: this.safetyIdentifier,
+      })
+    );
   }
 
   protected _getReasoningParams(
@@ -1640,7 +1702,7 @@ class LibreChatOpenAIResponses extends OriginalChatOpenAIResponses {
         ]),
       ];
     }
-    return params;
+    return stripIntentFromStrictTools(params);
   }
 
   async completionWithRetry(
@@ -1741,10 +1803,12 @@ class LibreChatAzureOpenAICompletions extends OriginalAzureChatOpenAICompletions
     options?: this['ParsedCallOptions'],
     extra?: { streaming?: boolean }
   ): ReturnType<OriginalAzureChatOpenAICompletions['invocationParams']> {
-    return applyManagedRequestParams(super.invocationParams(options, extra), {
-      promptCacheExplicit: this.promptCacheExplicit,
-      safetyIdentifier: this.safetyIdentifier,
-    });
+    return stripIntentFromStrictTools(
+      applyManagedRequestParams(super.invocationParams(options, extra), {
+        promptCacheExplicit: this.promptCacheExplicit,
+        safetyIdentifier: this.safetyIdentifier,
+      })
+    );
   }
 
   protected _getReasoningParams(
@@ -1888,7 +1952,7 @@ class LibreChatAzureOpenAIResponses extends OriginalAzureChatOpenAIResponses {
         ]),
       ];
     }
-    return params;
+    return stripIntentFromStrictTools(params);
   }
 
   async completionWithRetry(

package/src/llm/openai/llm.spec.ts

@@ -1206,6 +1206,111 @@ describe('ChatOpenAICompletions strict tools for structured output', () => {
       toolStrict({ response_format: { type: 'json_object' } })
     ).toBeUndefined();
   });
+
+  describe('optional intent labels under strict mode', () => {
+    const intentTool = {
+      type: 'function' as const,
+      function: {
+        name: 'search_mcp_docs',
+        description: 'Search docs',
+        parameters: {
+          type: 'object',
+          properties: {
+            intent: {
+              type: 'string',
+              description:
+                'ALWAYS write this field FIRST, before any other argument. One short sentence…',
+            },
+            query: { type: 'string' },
+          },
+          required: ['query'],
+        },
+      },
+    };
+
+    function toolProperties(options: Record<string, unknown>): string[] {
+      const model = new ChatOpenAI({ model: 'gpt-4', apiKey: 'test-key' });
+      const completions = completionsOf<InvocationParamsDelegate>(model);
+      const params = completions.invocationParams({
+        tools: [intentTool],
+        ...options,
+      }) as unknown as {
+        tools?: { function: { parameters: { properties: object } } }[];
+      };
+      return Object.keys(params.tools?.[0]?.function.parameters.properties ?? {});
+    }
+
+    it('drops the optional label when strict is auto-enabled (invalid otherwise)', () => {
+      expect(toolProperties({ response_format: jsonSchemaResponseFormat })).toEqual(['query']);
+    });
+
+    it('keeps the label on non-strict requests', () => {
+      expect(toolProperties({})).toEqual(['intent', 'query']);
+    });
+
+    /**
+     * The Responses API flattens tools to `{type, name, parameters, strict}`
+     * and does NOT infer strict from a `json_schema` response_format the way
+     * Completions does — an explicit `strict` (per-call option or on the tool)
+     * is what turns it on there.
+     */
+    function responsesToolProperties(
+      options: Record<string, unknown>
+    ): string[] {
+      const model = new ChatOpenAI({ model: 'gpt-4', apiKey: 'test-key' });
+      const responses = (
+        model as unknown as {
+          responses: {
+            invocationParams: (o: Record<string, unknown>) => {
+              tools?: { parameters?: { properties?: object } }[];
+            };
+          };
+        }
+      ).responses;
+      const params = responses.invocationParams({
+        tools: [intentTool],
+        ...options,
+      });
+      return Object.keys(params.tools?.[0]?.parameters?.properties ?? {});
+    }
+
+    it('drops the label on the RESPONSES delegate under strict too', () => {
+      expect(responsesToolProperties({ strict: true })).toEqual(['query']);
+    });
+
+    it('keeps the label on a non-strict RESPONSES request', () => {
+      expect(responsesToolProperties({})).toEqual(['intent', 'query']);
+    });
+
+    it('spares a business `intent` param even under strict', () => {
+      const businessTool = {
+        type: 'function' as const,
+        function: {
+          name: 'create_record',
+          parameters: {
+            type: 'object',
+            properties: {
+              intent: { type: 'string', description: 'CRM intent category' },
+              title: { type: 'string' },
+            },
+            required: ['intent', 'title'],
+          },
+        },
+      };
+      const model = new ChatOpenAI({ model: 'gpt-4', apiKey: 'test-key' });
+      const completions = completionsOf<InvocationParamsDelegate>(model);
+      const params = completions.invocationParams({
+        tools: [businessTool],
+        response_format: jsonSchemaResponseFormat,
+      }) as unknown as {
+        tools?: { function: { parameters: { properties: object } } }[];
+      };
+      expect(Object.keys(params.tools?.[0]?.function.parameters.properties ?? {})).toEqual([
+        'intent',
+        'title',
+      ]);
+    });
+  });
 });
 
 describe('ChatOpenAI._streamChatModelEvents (native, fork)', () => {

package/src/stream.ts

@@ -39,6 +39,7 @@ import {
   calculateMaxToolResultChars,
   truncateToolResultContent,
 } from '@/utils/truncation';
+import { resolveToolOutcome, outcomeFieldsFromResult } from '@/tools/intentArg';
 import { TOOL_OUTPUT_REF_PATTERN } from '@/tools/toolOutputReferences';
 import { safeDispatchCustomEvent } from '@/utils/events';
 import { isGoogleLike } from '@/utils/llm';
@@ -859,6 +860,11 @@ async function dispatchEagerToolCompletions(args: {
         maxToolResultChars
       ).content;
     }
+    const outcome = resolveToolOutcome(
+      record.request.args,
+      outcomeFieldsFromResult(result),
+      { isError: result.status === 'error' }
+    );
 
     try {
       const dispatched = await safeDispatchCustomEvent(
@@ -878,6 +884,7 @@ async function dispatchEagerToolCompletions(args: {
               id: result.toolCallId,
               output,
               progress: 1,
+              ...(outcome != null && { outcome }),
             } as t.ProcessedToolCall,
           },
         },
@@ -2160,7 +2167,7 @@ export function createContentAggregator(): t.ContentAggregatorResult {
         toolCallContentIndexMap.delete(existingToolCallId);
       }
 
-      const newToolCall: ToolCall & t.PartMetadata = {
+      const newToolCall: ToolCall & t.PartMetadata & { outcome?: string } = {
         id,
         name,
         args,
@@ -2180,6 +2187,10 @@ export function createContentAggregator(): t.ContentAggregatorResult {
       if (finalUpdate) {
         newToolCall.progress = 1;
         newToolCall.output = contentPart.tool_call.output;
+        const outcome = (contentPart.tool_call as t.ToolCallPart).outcome;
+        if (outcome != null) {
+          newToolCall.outcome = outcome;
+        }
       }
 
       contentParts[index] = {