ai 7.0.102 → 7.0.104

package/src/tool-search/prepare-tool-search.ts

@@ -0,0 +1,143 @@
+import {
+  experimental_getToolCaller,
+  type ToolSet,
+  type InferToolSetContext,
+  type Experimental_SandboxSession as SandboxSession,
+} from '@ai-sdk/provider-utils';
+import { InvalidArgumentError } from '../error/invalid-argument-error';
+import {
+  DIRECT_TOOL_CALL,
+  type ResolvedToolCallers,
+} from '../generate-text/tool-caller-configuration';
+import { resolveToolDescription } from '../prompt/prepare-tools';
+import { getOwn } from '../util/get-own';
+import { isToolSearch } from './tool-search';
+
+/** Create discovery state for one generation, never for a shared tool instance. */
+export function createToolSearchState({
+  tools,
+  toolCallers,
+}: {
+  tools: ToolSet | undefined;
+  toolCallers: ResolvedToolCallers | undefined;
+}): (
+  activeTools: ToolSet | undefined,
+  options?: {
+    toolsContext?: InferToolSetContext<ToolSet>;
+    experimental_sandbox?: SandboxSession;
+  },
+) => ToolSet | undefined {
+  const searchTools = Object.entries(tools ?? {}).filter(
+    ([, tool]) => tool.deferLoading || isToolSearch(tool),
+  );
+  if (searchTools.length === 0) {
+    return activeTools => activeTools;
+  }
+
+  const discovered = new Set<string>();
+  // An omitted entry permits direct calls; an explicit empty list permits none.
+  const getCallers = (name: string) =>
+    getOwn(toolCallers, name) ?? [DIRECT_TOOL_CALL];
+
+  for (const [name, tool] of searchTools) {
+    const callers = getCallers(name);
+    if (
+      callers.some(name => {
+        if (name === DIRECT_TOOL_CALL) {
+          return false;
+        }
+        const caller = experimental_getToolCaller(tools?.[name]);
+        return caller?.type !== 'local' || caller.prepareModelMessage == null;
+      }) ||
+      (isToolSearch(tool) && tool.deferLoading)
+    ) {
+      throw new InvalidArgumentError({
+        parameter: 'tools',
+        value: name,
+        message: `tool "${name}" must be callable directly or through code mode with toolDiscovery: 'conversation'. The search tool itself must not defer loading.`,
+      });
+    }
+  }
+
+  return (activeTools, { toolsContext = {}, experimental_sandbox } = {}) => {
+    if (activeTools == null) {
+      return undefined;
+    }
+
+    // Snapshot eligibility before binding callers. Newly discovered tools are
+    // intentionally absent from this step's execution bindings and catalog.
+    const entries = Object.entries(activeTools);
+    return Object.fromEntries(
+      entries
+        .filter(([name, tool]) => !tool.deferLoading || discovered.has(name))
+        .map(([searchName, tool]) => {
+          if (!isToolSearch(tool)) {
+            return [searchName, tool];
+          }
+
+          const callers = getCallers(searchName).filter(
+            name =>
+              name === DIRECT_TOOL_CALL || Object.hasOwn(activeTools, name),
+          );
+          const candidates = entries.filter(
+            ([name, candidate]) =>
+              candidate.deferLoading &&
+              !isToolSearch(candidate) &&
+              callers.some(caller => getCallers(name).includes(caller)),
+          );
+
+          return [
+            searchName,
+            {
+              ...tool,
+              execute: ({ query }: { query: string }) => {
+                const terms = [...new Set(tokenize(query))];
+                const matches = candidates
+                  .map(([name, candidate]) => {
+                    const description = resolveToolDescription({
+                      tool: candidate,
+                      toolName: name,
+                      toolsContext,
+                      experimental_sandbox,
+                    });
+                    const nameTerms = tokenize(name);
+                    const descriptionTerms = tokenize(description ?? '');
+                    const score = terms.reduce(
+                      (score, term) =>
+                        score +
+                        (nameTerms.includes(term) ? 2 : 0) +
+                        (descriptionTerms.includes(term) ? 1 : 0),
+                      0,
+                    );
+                    return { name, description, score };
+                  })
+                  .filter(match => match.score > 0)
+                  .sort((a, b) => b.score - a.score)
+                  .slice(0, 5);
+
+                for (const { name } of matches) {
+                  discovered.add(name);
+                }
+
+                return {
+                  tools: matches.map(({ name, description }) => ({
+                    name,
+                    ...(description == null ? {} : { description }),
+                  })),
+                };
+              },
+            },
+          ];
+        }),
+    );
+  };
+}
+
+function tokenize(text: string): string[] {
+  return (
+    text
+      .replace(/([a-z\d])([A-Z])/g, '$1 $2')
+      .toLowerCase()
+      .match(/[\p{L}\p{N}]+/gu) ?? []
+  );
+}

package/src/tool-search/tool-search.ts

@@ -0,0 +1,59 @@
+import { jsonSchema, tool, type Tool } from '@ai-sdk/provider-utils';
+
+const toolSearchSymbol = Symbol.for('vercel.ai.toolSearch');
+
+type ToolSearchInput = { query: string };
+type ToolSearchOutput = {
+  tools: Array<{ name: string; description?: string }>;
+};
+
+/**
+ * Search deferred tools by name and description. The surrounding generation
+ * binds the search registry and makes matches available on the next step.
+ * Use directly or through code mode with `toolDiscovery: 'conversation'`.
+ */
+export function toolSearch(): Tool<ToolSearchInput, ToolSearchOutput> & {
+  type: 'function';
+} {
+  return Object.assign(
+    tool({
+      description:
+        'Search for tools by keywords in their names and descriptions. Returns up to five matching tools. Matches become available on the next model step, after this execution finishes. Wait for their tool definitions before calling the discovered tools. If no tools match, try different keywords.',
+      inputSchema: jsonSchema<ToolSearchInput>({
+        type: 'object',
+        properties: { query: { type: 'string', minLength: 1 } },
+        required: ['query'],
+        additionalProperties: false,
+      }),
+      outputSchema: jsonSchema<ToolSearchOutput>({
+        type: 'object',
+        properties: {
+          tools: {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                name: { type: 'string' },
+                description: { type: 'string' },
+              },
+              required: ['name'],
+              additionalProperties: false,
+            },
+          },
+        },
+        required: ['tools'],
+        additionalProperties: false,
+      }),
+      execute: () => {
+        throw new Error('toolSearch must be bound by an AI SDK generation.');
+      },
+    }),
+    { type: 'function' as const, [toolSearchSymbol]: true },
+  );
+}
+
+export function isToolSearch(tool: Tool): boolean {
+  return (
+    (tool as Tool & { [toolSearchSymbol]?: boolean })[toolSearchSymbol] === true
+  );
+}

package/src/ui/convert-to-model-messages.ts

@@ -33,6 +33,7 @@ import {
   type ToolUIPart,
   type UIMessage,
 } from './ui-messages';
+import { warnIfUIMessageHasDeprecatedRawInput } from './warn-if-ui-message-has-deprecated-raw-input';
 /**
  * Converts an array of UI messages from useChat into an array of ModelMessages that can be used
  * with the AI functions (e.g. `streamText`, `generateText`).
@@ -56,6 +57,8 @@ export async function convertToModelMessages<UI_MESSAGE extends UIMessage>(
 ): Promise<ModelMessage[]> {
   const modelMessages: ModelMessage[] = [];
 
+  warnIfUIMessageHasDeprecatedRawInput(messages);
+
   if (options?.ignoreIncompleteToolCalls) {
     messages = messages.map(message => ({
       ...message,

package/src/ui/process-ui-message-stream.ts

@@ -31,6 +31,8 @@ import {
   type UIMessage,
   type UIMessagePart,
 } from './ui-messages';
+import { warnIfUIMessageHasDeprecatedRawInput } from './warn-if-ui-message-has-deprecated-raw-input';
+
 export type StreamingUIMessageState<UI_MESSAGE extends UIMessage> = {
   message: UI_MESSAGE;
   activeTextParts: Record<string, TextUIPart>;
@@ -737,6 +739,8 @@ export function processUIMessageStream<UI_MESSAGE extends UIMessage>({
                   providerMetadata: chunk.providerMetadata,
                   toolMetadata: chunk.toolMetadata,
                 });
+
+                warnIfUIMessageHasDeprecatedRawInput([state.message]);
               }
 
               write();

package/src/ui/ui-messages.ts

@@ -363,7 +363,11 @@ export type UIToolInvocation<TOOL extends UITool | Tool> = {
   | {
       state: 'output-error';
       input: asUITool<TOOL>['input'] | undefined;
-      rawInput?: unknown; // TODO AI SDK 6: remove this field, input should be unknown
+      /**
+       * @deprecated Use `input` instead. This field will be removed in the next
+       * major version.
+       */
+      rawInput?: unknown;
       output?: never;
       errorText: string;
       callProviderMetadata?: ProviderMetadata;

package/src/ui/validate-ui-messages.ts

@@ -20,6 +20,7 @@ import type {
   ToolUIPart,
   UIMessage,
 } from './ui-messages';
+import { warnIfUIMessageHasDeprecatedRawInput } from './warn-if-ui-message-has-deprecated-raw-input';
 
 const toolMetadataSchema: ZodType<JSONObject> = z.record(
   z.string(),
@@ -484,6 +485,8 @@ async function safeValidateUIMessagesInternal<UI_MESSAGE extends UIMessage>(
       schema: uiMessagesSchema,
     });
 
+    warnIfUIMessageHasDeprecatedRawInput(validatedMessages);
+
     if (metadataSchema) {
       for (const [msgIdx, message] of validatedMessages.entries()) {
         await validateTypes({

package/src/ui/warn-if-ui-message-has-deprecated-raw-input.ts

@@ -0,0 +1,36 @@
+import { logWarnings } from '../logger/log-warnings';
+
+const rawInputDeprecationWarning = {
+  type: 'deprecated',
+  setting: 'rawInput in output-error UI message parts',
+  message:
+    'Use the "input" field instead. The "rawInput" field will be removed in the next major version.',
+} as const;
+
+export function warnIfUIMessageHasDeprecatedRawInput(
+  messages: ReadonlyArray<{
+    parts: ReadonlyArray<unknown>;
+  }>,
+): void {
+  const hasDeprecatedRawInput = messages.some(message =>
+    message.parts.some(
+      part =>
+        part != null &&
+        typeof part === 'object' &&
+        'type' in part &&
+        typeof part.type === 'string' &&
+        (part.type === 'dynamic-tool' || part.type.startsWith('tool-')) &&
+        'state' in part &&
+        part.state === 'output-error' &&
+        Object.prototype.hasOwnProperty.call(part, 'rawInput') &&
+        'rawInput' in part &&
+        part.rawInput !== undefined,
+    ),
+  );
+
+  if (hasDeprecatedRawInput) {
+    logWarnings({
+      warnings: [rawInputDeprecationWarning],
+    });
+  }
+}