@ai-sdk/provider-utils 5.0.0-beta.20 → 5.0.0-beta.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/provider-utils",
-  "version": "5.0.0-beta.20",
+  "version": "5.0.0-beta.21",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,

package/src/get-error-message.ts

@@ -1,15 +1 @@
-export function getErrorMessage(error: unknown | undefined) {
-  if (error == null) {
-    return 'unknown error';
-  }
-
-  if (typeof error === 'string') {
-    return error;
-  }
-
-  if (error instanceof Error) {
-    return error.toString();
-  }
-
-  return JSON.stringify(error);
-}
+export { getErrorMessage } from '@ai-sdk/provider';

package/src/types/executable-tool.ts

@@ -0,0 +1,17 @@
+import { Tool } from './tool';
+
+/**
+ * A tool that is guaranteed to expose an execute function.
+ */
+export type ExecutableTool<TOOL extends Tool = Tool> = TOOL & {
+  execute: NonNullable<TOOL['execute']>;
+};
+
+/**
+ * Checks whether a tool exposes an execute function.
+ */
+export function isExecutableTool<TOOL extends Tool>(
+  tool: TOOL | undefined,
+): tool is ExecutableTool<TOOL> {
+  return tool != null && typeof tool.execute === 'function';
+}

package/src/types/execute-tool.ts

@@ -1,41 +1,40 @@
 import { isAsyncIterable } from '../is-async-iterable';
-import { Context } from './context';
-import { ToolExecuteFunction, ToolExecutionOptions } from './tool';
+import { ExecutableTool } from './executable-tool';
+import { InferToolContext } from './infer-tool-context';
+import { InferToolInput } from './infer-tool-input';
+import { InferToolOutput } from './infer-tool-output';
+import { Tool, ToolExecutionOptions } from './tool';
 
 /**
- * Executes a tool function, supporting both synchronous and streaming/asynchronous results.
+ * Executes a tool function and normalizes its results into a stream of outputs.
  *
- * This generator yields intermediate ("preliminary") outputs as they're produced, allowing callers
- * to stream partial tool results before completion. When execution is finished, it yields a final output,
- * ensuring all consumers receive a conclusive result.
- *
- * - If the tool's `execute` function returns an `AsyncIterable`, all intermediate values are yielded
- *   as `{ type: "preliminary", output }` except the last, which is yielded as `{ type: "final", output }`.
+ * - If the tool's `execute` function returns an `AsyncIterable`, each yielded value is emitted as
+ *   `{ type: "preliminary", output }`. After iteration completes, the last yielded value is emitted
+ *   again as `{ type: "final", output }`.
  * - If the tool returns a direct value or Promise, a single `{ type: "final", output }` is yielded.
  *
- * @template INPUT Input type for the tool execution.
- * @template OUTPUT Output type for the tool execution.
- * @template CONTEXT Context object extension for execution (extends Context).
- * @param params.execute The tool execute function.
- * @param params.input Input value to pass to the execute function.
+ * @param params.tool The tool whose `execute` function should be invoked.
+ * @param params.input The input value to pass to the tool.
  * @param params.options Additional options for tool execution.
- * @yields An object containing either a preliminary or final output from the tool.
+ * @yields A preliminary output for each streamed value, followed by a final output, or a single final
+ * output for non-streaming tools.
  */
-export async function* executeTool<INPUT, OUTPUT, CONTEXT extends Context>({
-  execute,
+export async function* executeTool<TOOL extends Tool>({
+  tool,
   input,
   options,
 }: {
-  execute: ToolExecuteFunction<INPUT, OUTPUT, CONTEXT>;
-  input: INPUT;
-  options: ToolExecutionOptions<NoInfer<CONTEXT>>;
+  tool: ExecutableTool<TOOL>;
+  input: InferToolInput<TOOL>;
+  options: ToolExecutionOptions<InferToolContext<TOOL>>;
 }): AsyncGenerator<
-  { type: 'preliminary'; output: OUTPUT } | { type: 'final'; output: OUTPUT }
+  | { type: 'preliminary'; output: InferToolOutput<TOOL> }
+  | { type: 'final'; output: InferToolOutput<TOOL> }
 > {
-  const result = execute(input, options);
+  const result = tool.execute(input, options);
 
   if (isAsyncIterable(result)) {
-    let lastOutput: OUTPUT | undefined;
+    let lastOutput: InferToolOutput<TOOL> | undefined;
     for await (const output of result) {
       lastOutput = output;
       yield { type: 'preliminary', output };

package/src/types/index.ts

@@ -16,6 +16,7 @@ export type {
 export type { Context } from './context';
 export type { DataContent } from './data-content';
 export { executeTool } from './execute-tool';
+export { isExecutableTool, type ExecutableTool } from './executable-tool';
 export type { InferToolContext } from './infer-tool-context';
 export type { InferToolInput } from './infer-tool-input';
 export type { InferToolOutput } from './infer-tool-output';