@assistant-ui/react-ai-sdk 1.3.30 → 1.3.32

package/dist/assistant-stream/dist/core/tool/schema-utils.d.ts

@@ -0,0 +1,15 @@
+import { JSONSchema7 } from "../../node_modules/.pnpm/@types_json-schema@7.0.15/node_modules/@types/json-schema/index.js";
+import { ProviderOptions } from "./tool-types.js";
+//#region ../assistant-stream/dist/core/tool/schema-utils.d.ts
+//#region src/core/tool/schema-utils.d.ts
+/**
+ * Type for a tool definition with JSON Schema parameters.
+ */
+type ToolJSONSchema = {
+  description?: string;
+  parameters: JSONSchema7;
+  providerOptions?: ProviderOptions;
+};
+//#endregion
+export { ToolJSONSchema };
+//# sourceMappingURL=schema-utils.d.ts.map

package/dist/assistant-stream/dist/core/tool/schema-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-utils.d.ts","names":["description","parameters","JSONSchema7","providerOptions","ProviderOptions","filter","name","Tool","tool","StandardSchemaV1","schema","Record","tools","ToToolsJSONSchemaOptions","options","ToolJSONSchema"],"sources":["../../../../../../assistant-stream/dist/core/tool/schema-utils.d.ts"],"mappings":";;;;AAEyD;;;AAAA,KAMpD,cAAA;EACHA,WAAAA;EACAC,UAAAA,EAAY,WAAA;EACZE,eAAAA,GAAkB,eAAe;AAAA"}

package/dist/{packages/assistant-stream → assistant-stream}/dist/core/tool/schema-utils.js

@@ -30,21 +30,30 @@ function toJSONSchema(schema) {
 	return schema;
 }
 function defaultToolFilter(_name, tool) {
-	return !tool.disabled && tool.type !== "backend";
+	return !tool.disabled && tool.type !== "backend" && (tool.type !== "frontend" || tool.execute !== void 0);
+}
+function toolHasUploadableParameters(tool) {
+	return tool.parameters !== void 0 && !tool.unstable_backendDefault?.parameters;
 }
 /**
 * Converts a record of tools to a record of tool definitions with JSON Schema parameters.
 * By default, filters out disabled tools and backend tools.
+*
+* Entries are emitted in alphabetical order so the resulting request body is
+* byte-identical regardless of the order in which tools were registered. This
+* keeps provider prompt caches stable across renders that mount tools in
+* different orders.
 */
 function toToolsJSONSchema(tools, options = {}) {
 	if (!tools) return {};
 	const filter = options.filter ?? defaultToolFilter;
-	return Object.fromEntries(Object.entries(tools).filter(([name, tool]) => filter(name, tool) && tool.parameters).map(([name, tool]) => [name, {
+	return Object.fromEntries(Object.entries(tools).filter(([name, tool]) => filter(name, tool)).filter((entry) => toolHasUploadableParameters(entry[1])).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([name, tool]) => [name, {
 		...tool.description && { description: tool.description },
-		parameters: toJSONSchema(tool.parameters)
+		parameters: toJSONSchema(tool.parameters),
+		...tool.providerOptions && { providerOptions: tool.providerOptions }
 	}]));
 }
 //#endregion
-export { toToolsJSONSchema };
+export { toJSONSchema, toToolsJSONSchema };
 
 //# sourceMappingURL=schema-utils.js.map

package/dist/assistant-stream/dist/core/tool/schema-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-utils.js","names":[],"sources":["../../../../../../assistant-stream/dist/core/tool/schema-utils.js"],"sourcesContent":["//#region src/core/tool/schema-utils.ts\nfunction isStandardSchema(schema) {\n\treturn typeof schema === \"object\" && schema !== null && \"~standard\" in schema && typeof schema[\"~standard\"] === \"object\";\n}\nfunction hasToJSONSchemaMethod(schema) {\n\treturn typeof schema === \"object\" && schema !== null && \"toJSONSchema\" in schema && typeof schema.toJSONSchema === \"function\";\n}\nfunction hasToJSONMethod(schema) {\n\treturn typeof schema === \"object\" && schema !== null && \"toJSON\" in schema && typeof schema.toJSON === \"function\";\n}\n/**\n* Converts a schema to JSONSchema7.\n* Supports:\n* - StandardSchemaV1 with ~standard.toJSONSchema (e.g., Zod v4)\n* - StandardSchemaV1 with ~standard.jsonSchema.input() (e.g., Zod v4)\n* - Objects with toJSONSchema() method (e.g., Zod v4)\n* - Objects with toJSON() method\n* - Plain JSONSchema7 objects (must have a \"type\" property)\n*/\nfunction toJSONSchema(schema) {\n\tif (isStandardSchema(schema)) {\n\t\tconst toJSONSchemaMethod = schema[\"~standard\"].toJSONSchema;\n\t\tif (typeof toJSONSchemaMethod === \"function\") return toJSONSchemaMethod();\n\t\tconst jsonSchema = schema[\"~standard\"].jsonSchema;\n\t\tif (typeof jsonSchema === \"object\" && jsonSchema !== null && typeof jsonSchema.input === \"function\") return jsonSchema.input();\n\t}\n\tif (hasToJSONSchemaMethod(schema)) return schema.toJSONSchema();\n\tif (hasToJSONMethod(schema)) return schema.toJSON();\n\tif (isStandardSchema(schema)) throw new Error(\"Could not convert schema to JSON Schema. The schema implements Standard Schema but does not support JSON Schema conversion. If you are using Zod, please upgrade to Zod v4 (npm install zod@latest). Alternatively, pass a plain JSON Schema object instead.\");\n\treturn schema;\n}\n/**\n* Returns a copy of the JSON Schema with `required` removed recursively,\n* making every property optional. Array item schemas are left unchanged.\n*/\nfunction toPartialJSONSchema(schema) {\n\tconst { required: _, ...result } = schema;\n\tif (result.properties) result.properties = Object.fromEntries(Object.entries(result.properties).map(([key, prop]) => {\n\t\tif (typeof prop === \"object\" && prop !== null && !Array.isArray(prop)) {\n\t\t\tconst p = prop;\n\t\t\treturn [key, p.properties != null ? toPartialJSONSchema(p) : prop];\n\t\t}\n\t\treturn [key, prop];\n\t}));\n\treturn result;\n}\nfunction defaultToolFilter(_name, tool) {\n\treturn !tool.disabled && tool.type !== \"backend\" && (tool.type !== \"frontend\" || tool.execute !== void 0);\n}\nfunction toolHasUploadableParameters(tool) {\n\treturn tool.parameters !== void 0 && !tool.unstable_backendDefault?.parameters;\n}\n/**\n* Converts a record of tools to a record of tool definitions with JSON Schema parameters.\n* By default, filters out disabled tools and backend tools.\n*\n* Entries are emitted in alphabetical order so the resulting request body is\n* byte-identical regardless of the order in which tools were registered. This\n* keeps provider prompt caches stable across renders that mount tools in\n* different orders.\n*/\nfunction toToolsJSONSchema(tools, options = {}) {\n\tif (!tools) return {};\n\tconst filter = options.filter ?? defaultToolFilter;\n\treturn Object.fromEntries(Object.entries(tools).filter(([name, tool]) => filter(name, tool)).filter((entry) => toolHasUploadableParameters(entry[1])).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([name, tool]) => [name, {\n\t\t...tool.description && { description: tool.description },\n\t\tparameters: toJSONSchema(tool.parameters),\n\t\t...tool.providerOptions && { providerOptions: tool.providerOptions }\n\t}]));\n}\n//#endregion\nexport { toJSONSchema, toPartialJSONSchema, toToolsJSONSchema };\n\n//# sourceMappingURL=schema-utils.js.map"],"mappings":";AACA,SAAS,iBAAiB,QAAQ;CACjC,OAAO,OAAO,WAAW,YAAY,WAAW,QAAQ,eAAe,UAAU,OAAO,OAAO,iBAAiB;AACjH;AACA,SAAS,sBAAsB,QAAQ;CACtC,OAAO,OAAO,WAAW,YAAY,WAAW,QAAQ,kBAAkB,UAAU,OAAO,OAAO,iBAAiB;AACpH;AACA,SAAS,gBAAgB,QAAQ;CAChC,OAAO,OAAO,WAAW,YAAY,WAAW,QAAQ,YAAY,UAAU,OAAO,OAAO,WAAW;AACxG;;;;;;;;;;AAUA,SAAS,aAAa,QAAQ;CAC7B,IAAI,iBAAiB,MAAM,GAAG;EAC7B,MAAM,qBAAqB,OAAO,aAAa;EAC/C,IAAI,OAAO,uBAAuB,YAAY,OAAO,mBAAmB;EACxE,MAAM,aAAa,OAAO,aAAa;EACvC,IAAI,OAAO,eAAe,YAAY,eAAe,QAAQ,OAAO,WAAW,UAAU,YAAY,OAAO,WAAW,MAAM;CAC9H;CACA,IAAI,sBAAsB,MAAM,GAAG,OAAO,OAAO,aAAa;CAC9D,IAAI,gBAAgB,MAAM,GAAG,OAAO,OAAO,OAAO;CAClD,IAAI,iBAAiB,MAAM,GAAG,MAAM,IAAI,MAAM,8PAA8P;CAC5S,OAAO;AACR;AAgBA,SAAS,kBAAkB,OAAO,MAAM;CACvC,OAAO,CAAC,KAAK,YAAY,KAAK,SAAS,cAAc,KAAK,SAAS,cAAc,KAAK,YAAY,KAAK;AACxG;AACA,SAAS,4BAA4B,MAAM;CAC1C,OAAO,KAAK,eAAe,KAAK,KAAK,CAAC,KAAK,yBAAyB;AACrE;;;;;;;;;;AAUA,SAAS,kBAAkB,OAAO,UAAU,CAAC,GAAG;CAC/C,IAAI,CAAC,OAAO,OAAO,CAAC;CACpB,MAAM,SAAS,QAAQ,UAAU;CACjC,OAAO,OAAO,YAAY,OAAO,QAAQ,KAAK,EAAE,QAAQ,CAAC,MAAM,UAAU,OAAO,MAAM,IAAI,CAAC,EAAE,QAAQ,UAAU,4BAA4B,MAAM,EAAE,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,OAAO,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,CAAC,EAAE,KAAK,CAAC,MAAM,UAAU,CAAC,MAAM;EACjO,GAAG,KAAK,eAAe,EAAE,aAAa,KAAK,YAAY;EACvD,YAAY,aAAa,KAAK,UAAU;EACxC,GAAG,KAAK,mBAAmB,EAAE,iBAAiB,KAAK,gBAAgB;CACpE,CAAC,CAAC,CAAC;AACJ"}

package/dist/{packages/assistant-stream → assistant-stream}/dist/core/tool/tool-types.d.ts

@@ -38,6 +38,32 @@ type ToolModelContentPart = {
  * ];
  * ```
  */
+/**
+ * Per-provider metadata forwarded into the wire request body verbatim.
+ * assistant-ui does not interpret these values; downstream adapters (AI SDK,
+ * custom routes) pass them to the model provider as-is.
+ *
+ * The outer key is the provider name (`anthropic`, `openai`, ...); the inner
+ * object is whatever shape that provider's SDK expects under
+ * `tool.providerOptions[providerName]`. Use this to enable provider-specific
+ * tool behaviors such as Anthropic's `defer_loading`
+ * (`{ anthropic: { deferLoading: true } }`) without adding provider-aware
+ * code in assistant-ui.
+ */
+type ProviderOptions = Record<string, Record<string, unknown>>;
+/**
+ * Controls how a tool call's UI is presented relative to the assistant's
+ * chain-of-thought trace.
+ *
+ * - `"inline"` — the tool call is part of the reasoning trace and is folded
+ *   into the chain-of-thought grouping alongside other routine tool calls.
+ * - `"standalone"` — the tool call is surfaced on its own, outside the
+ *   chain-of-thought grouping (e.g. a human-in-the-loop prompt, a generative
+ *   UI surface, or an important action UI worth showing prominently).
+ *
+ * This is a client-side presentation hint only; it does not affect how the
+ * tool is exposed to or executed by the model.
+ */
 //#endregion
-export { ToolModelContentPart };
+export { ProviderOptions, ToolModelContentPart };
 //# sourceMappingURL=tool-types.d.ts.map

package/dist/assistant-stream/dist/core/tool/tool-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-types.d.ts","names":["type","text","data","mediaType","filename","TArgs","TResult","toolCallId","input","output","options","ToolModelContentPart","Promise","Record","get","PathT","TypePath","fieldPath","TypeAtPath","streamValues","AsyncIterableStream","DeepPartial","streamText","U","forEach","Array","ToolResponse","args","ToolCallArgsReader","response","ToolCallResponseReader","result","abortSignal","AbortSignal","human","payload","ToolExecutionContext","context","ToolCallReader","reader","ToolExecuteFunction","streamCall","ToolStreamCallFunction","display","ToolDisplay","ToolBase","description","parameters","disabled","execute","toModelOutput","experimental_onSchemaValidationError","providerOptions","StandardSchemaV1","JSONSchema7","ToolModelOutputFunction","OnSchemaValidationErrorFunction","ProviderOptions","providerId","supportsDeferredResults","url","headers","redirect","command","env","cwd","server","McpServerConfig","FrontendTool","BackendTool","HumanTool","ProviderTool","McpTool","ToolWithoutType","BackendToolDeclaration","Omit"],"sources":["../../../../../../assistant-stream/dist/core/tool/tool-types.d.ts"],"mappings":";;KAOK,oBAAA;EAEMC,4EADmED,IAAAA,UACnEC;EAAAA,SAAAA,IAAAA;AAAAA;EAQAE,4EANmEH,IAAAA;EAOnEI;;AAAQ;AAkGiE;EAlGzEA,SAFAF,IAAAA,UAiHS;EAAA,SAhHTC,SAAAA,UAgHkB;EAAA,SA/GlBC,QAAAA;AAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA+GN,eAAA,GAAkB,MAAM,SAAS,MAAA"}

package/dist/assistant-stream/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { ProviderOptions, ToolModelContentPart } from "./core/tool/tool-types.js";
+import { ToolJSONSchema } from "./core/tool/schema-utils.js";

package/dist/{node_modules → assistant-stream/dist/node_modules}/.pnpm/@types_json-schema@7.0.15/node_modules/@types/json-schema/index.d.ts

@@ -1,3 +1,4 @@
+//#region ../assistant-stream/dist/node_modules/.pnpm/@types_json-schema@7.0.15/node_modules/@types/json-schema/index.d.ts
 //#region ../../node_modules/.pnpm/@types+json-schema@7.0.15/node_modules/@types/json-schema/index.d.ts
 // ==================================================================================================
 // JSON Schema Draft 07
@@ -15,12 +16,10 @@ type JSONSchema7TypeName = "string" //
  * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1.1
  */
 type JSONSchema7Type = string //
-| number | boolean | JSONSchema7Object | JSONSchema7Array | null;
-// Workaround for infinite type recursion
+| number | boolean | JSONSchema7Object | JSONSchema7Array | null; // Workaround for infinite type recursion
 interface JSONSchema7Object {
   [key: string]: JSONSchema7Type;
-}
-// Workaround for infinite type recursion
+} // Workaround for infinite type recursion
 // https://github.com/Microsoft/TypeScript/issues/3496#issuecomment-128553540
 interface JSONSchema7Array extends Array<JSONSchema7Type> {}
 /**
@@ -135,7 +134,7 @@ interface JSONSchema7 {
   readOnly?: boolean | undefined;
   writeOnly?: boolean | undefined;
   examples?: JSONSchema7Type | undefined;
-}
+} //#endregion
 //#endregion
 export { JSONSchema7 };
 //# sourceMappingURL=index.d.ts.map

package/dist/assistant-stream/dist/node_modules/.pnpm/@types_json-schema@7.0.15/node_modules/@types/json-schema/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":["JSONSchema7Object","JSONSchema7Array","key","JSONSchema7Type","Array","JSONSchema7","$id","$ref","$schema","JSONSchema7Version","$comment","$defs","JSONSchema7Definition","type","JSONSchema7TypeName","enum","const","multipleOf","maximum","exclusiveMaximum","minimum","exclusiveMinimum","maxLength","minLength","pattern","items","additionalItems","maxItems","minItems","uniqueItems","contains","maxProperties","minProperties","required","properties","patternProperties","additionalProperties","dependencies","propertyNames","if","then","else","allOf","anyOf","oneOf","not","format","contentMediaType","contentEncoding","definitions","title","description","default","readOnly","writeOnly","examples"],"sources":["../../../../../../../../../../assistant-stream/dist/node_modules/.pnpm/@types_json-schema@7.0.15/node_modules/@types/json-schema/index.d.ts"],"x_google_ignoreList":[0],"mappings":";;;;;;;AAUwB;;;;AAAA,KAAnB,mBAAA;AAAA;;;;AAU2B;KAJ3B,eAAA;AAAA,qBACgB,iBAAA,GAAoB,gBAAgB;AAAA,UAE/C,iBAAA;EAAA,CACPE,GAAAA,WAAc,eAAe;AAAA;AAAA;AAAA,UAItB,gBAAA,SAAyB,KAAK,CAAC,eAAA;AAYlB;AAAA;;;;AAKiB;AAAA;;;;;AALjB,KAAlB,kBAAA;;;;;KAKA,qBAAA,GAAwB,WAAW;AAAA,UAC9B,WAAA;EACRI,GAAAA;EACAC,IAAAA;EACAC,OAAAA,GAAU,kBAAA;EACVE,QAAAA;EAmDiB;;;;EA9CjBC,KAAAA;IAAAA,CACGT,GAAAA,WAAc,qBAAA;EAAA;EA2DT;;;EAtDRW,IAAAA,GAAO,mBAAA,GAAsB,mBAAA;EAC7BE,IAAAA,GAAO,eAAA;EACPC,KAAAA,GAAQ,eAAA;EA6EkB;;;EAzE1BC,UAAAA;EACAC,OAAAA;EACAC,gBAAAA;EACAC,OAAAA;EACAC,gBAAAA;EAfiBT;;;EAmBjBU,SAAAA;EACAC,SAAAA;EACAC,OAAAA;EAdAR;;;EAkBAS,KAAAA,GAAQ,qBAAA,GAAwB,qBAAA;EAChCC,eAAAA,GAAkB,qBAAA;EAClBC,QAAAA;EACAC,QAAAA;EACAC,WAAAA;EACAC,QAAAA,GAAW,qBAAA;EATXN;;;EAaAO,aAAAA;EACAC,aAAAA;EACAC,QAAAA;EACAC,UAAAA;IAAAA,CACGhC,GAAAA,WAAc,qBAAA;EAAA;EAEjBiC,iBAAAA;IAAAA,CACGjC,GAAAA,WAAc,qBAAA;EAAA;EAEjBkC,oBAAAA,GAAuB,qBAAA;EACvBC,YAAAA;IAAAA,CACGnC,GAAAA,WAAc,qBAAA;EAAA;EAEjBoC,aAAAA,GAAgB,qBAAA;EAPhBH;;;EAWAI,EAAAA,GAAK,qBAAA;EACLC,IAAAA,GAAO,qBAAA;EACPC,IAAAA,GAAO,qBAAA;EARJvC;;;EAYHwC,KAAAA,GAAQ,qBAAA;EACRC,KAAAA,GAAQ,qBAAA;EACRC,KAAAA,GAAQ,qBAAA;EACRC,GAAAA,GAAM,qBAAA;EARCjC;;;EAYPkC,MAAAA;EAPQlC;;;EAWRmC,gBAAAA;EACAC,eAAAA;EATAH;;;EAaAI,WAAAA;IAAAA,CACG/C,GAAAA,WAAc,qBAAA;EAAA;EAAdA;;;EAKHgD,KAAAA;EACAC,WAAAA;EACAC,OAAAA,GAAU,eAAA;EACVC,QAAAA;EACAC,SAAAA;EACAC,QAAAA,GAAW,eAAA;AAAA"}

package/dist/assistant-stream/dist/resumable/createResumableAssistantStreamResponse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createResumableAssistantStreamResponse.d.ts","names":["context","ResumableStreamContext","streamId","callback","AssistantStreamController","controller","PromiseLike","encoder","AssistantStreamEncoder","headers","HeadersInit","CreateResumableAssistantStreamResponseOptions","options","Promise","Response","missingResponse","CreateResumeAssistantStreamResponseOptions"],"sources":["../../../../../assistant-stream/dist/resumable/createResumableAssistantStreamResponse.d.ts"],"mappings":";;cAKc,0BAAA"}

package/dist/assistant-stream/dist/resumable/createResumableAssistantStreamResponse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createResumableAssistantStreamResponse.js","names":[],"sources":["../../../../../assistant-stream/dist/resumable/createResumableAssistantStreamResponse.js"],"sourcesContent":["import { DataStreamEncoder } from \"../core/serialization/data-stream/DataStream.js\";\nimport { createAssistantStream } from \"../core/modules/assistant-stream.js\";\n//#region src/resumable/createResumableAssistantStreamResponse.ts\nconst RESUMABLE_STREAM_ID_HEADER = \"x-resumable-stream-id\";\nasync function createResumableAssistantStreamResponse(options) {\n\tconst encoder = (options.encoder ?? (() => new DataStreamEncoder()))();\n\tconst stream = await options.context.run(options.streamId, () => {\n\t\treturn createAssistantStream(options.callback).pipeThrough(encoder);\n\t});\n\treturn new Response(stream, { headers: mergeHeaders(encoder.headers, options.headers, options.streamId) });\n}\nasync function createResumeAssistantStreamResponse(options) {\n\tconst stream = await options.context.resume(options.streamId);\n\tif (!stream) return options.missingResponse?.() ?? defaultMissingResponse();\n\tconst encoder = (options.encoder ?? (() => new DataStreamEncoder()))();\n\treturn new Response(stream, { headers: mergeHeaders(encoder.headers, options.headers, options.streamId) });\n}\nfunction defaultMissingResponse() {\n\treturn new Response(JSON.stringify({ error: \"stream not found\" }), {\n\t\tstatus: 404,\n\t\theaders: { \"Content-Type\": \"application/json\" }\n\t});\n}\nfunction mergeHeaders(encoderHeaders, extra, streamId) {\n\tconst merged = new Headers(encoderHeaders ?? {});\n\tif (extra) for (const [key, value] of new Headers(extra)) merged.set(key, value);\n\tmerged.set(RESUMABLE_STREAM_ID_HEADER, streamId);\n\treturn merged;\n}\n//#endregion\nexport { RESUMABLE_STREAM_ID_HEADER, createResumableAssistantStreamResponse, createResumeAssistantStreamResponse };\n\n//# sourceMappingURL=createResumableAssistantStreamResponse.js.map"],"mappings":";AAGA,MAAM,6BAA6B"}

package/dist/assistant-stream/dist/utils/json/json-value.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-value.d.ts","names":["ReadonlyJSONObject","ReadonlyJSONArray","key","ReadonlyJSONValue"],"sources":["../../../../../../assistant-stream/dist/utils/json/json-value.d.ts"],"mappings":";;KACK,iBAAA,sCAAuD,kBAAA,GAAqB,iBAAiB;AAAA,KAC7F,kBAAA;EAAA,UACOE,GAAAA,WAAc,iBAAiB;AAAA;AAAA,KAEtC,iBAAA,YAA6B,iBAAiB"}

package/dist/frontendTools.d.ts

@@ -1,11 +1,38 @@
-import { JSONSchema7 } from "./node_modules/.pnpm/@types_json-schema@7.0.15/node_modules/@types/json-schema/index.js";
+import { ToolJSONSchema } from "./assistant-stream/dist/core/tool/schema-utils.js";
 import { ToolSet } from "ai";
 
 //#region src/frontendTools.d.ts
-declare const frontendTools: (tools: Record<string, {
-  description?: string;
-  parameters: JSONSchema7;
-}>) => ToolSet;
+declare const defaultToModelOutput: ({
+  output
+}: {
+  output: unknown;
+}) => {
+  type: "content";
+  value: ({
+    type: "text";
+    text: string;
+    data?: never;
+    mediaType?: never;
+  } | {
+    type: "image-data";
+    data: string;
+    mediaType: string;
+    text?: never;
+  } | {
+    filename?: string;
+    type: "file-data";
+    data: string;
+    mediaType: string;
+    text?: never;
+  })[];
+} | {
+  type: "text";
+  value: string;
+} | {
+  type: "json";
+  value: import("ai").JSONValue;
+};
+declare const frontendTools: (tools: Record<string, ToolJSONSchema>) => ToolSet;
 //#endregion
-export { frontendTools };
+export { defaultToModelOutput, frontendTools };
 //# sourceMappingURL=frontendTools.d.ts.map

package/dist/frontendTools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"frontendTools.d.ts","names":[],"sources":["../src/frontendTools.ts"],"mappings":";;;;cAqCa,aAAA,GACX,KAAA,EAAO,MAAA;EAAiB,WAAA;EAAsB,UAAA,EAAY,WAAA;AAAA,OACzD,OAAA"}
+{"version":3,"file":"frontendTools.d.ts","names":[],"sources":["../src/frontendTools.ts"],"mappings":";;;;cAKa,oBAAA;EAAwB;AAAA;EAAc,MAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;cAQtC,aAAA,GAAiB,KAAA,EAAO,MAAA,SAAe,cAAA,MAAkB,OAAA"}

package/dist/frontendTools.js

@@ -1,42 +1,19 @@
 import { unwrapModelContentEnvelope } from "./modelContentEnvelope.js";
+import { toAISDKContent, toAISDKDefaultOutput } from "./toolOutputConversion.js";
 import { jsonSchema } from "ai";
 //#region src/frontendTools.ts
-const toAISDKContent = (parts) => ({
-	type: "content",
-	value: parts.map((part) => {
-		if (part.type === "text") return {
-			type: "text",
-			text: part.text
-		};
-		return part.mediaType.startsWith("image/") ? {
-			type: "image-data",
-			data: part.data,
-			mediaType: part.mediaType
-		} : {
-			type: "file-data",
-			data: part.data,
-			mediaType: part.mediaType,
-			...part.filename !== void 0 && { filename: part.filename }
-		};
-	})
-});
 const defaultToModelOutput = ({ output }) => {
-	const { modelContent } = unwrapModelContentEnvelope(output);
+	const { result, modelContent } = unwrapModelContentEnvelope(output);
 	if (modelContent !== void 0) return toAISDKContent(modelContent);
-	return typeof output === "string" ? {
-		type: "text",
-		value: output
-	} : {
-		type: "json",
-		value: output ?? null
-	};
+	return toAISDKDefaultOutput(result);
 };
 const frontendTools = (tools) => Object.fromEntries(Object.entries(tools).map(([name, t]) => [name, {
 	...t.description !== void 0 && { description: t.description },
 	inputSchema: jsonSchema(t.parameters),
-	toModelOutput: defaultToModelOutput
+	toModelOutput: defaultToModelOutput,
+	...t.providerOptions && { providerOptions: t.providerOptions }
 }]));
 //#endregion
-export { frontendTools };
+export { defaultToModelOutput, frontendTools };
 
 //# sourceMappingURL=frontendTools.js.map

package/dist/frontendTools.js.map

@@ -1 +1 @@
-{"version":3,"file":"frontendTools.js","names":[],"sources":["../src/frontendTools.ts"],"sourcesContent":["import { jsonSchema, type ToolSet } from \"ai\";\nimport type { JSONSchema7 } from \"json-schema\";\nimport type { ToolModelContentPart } from \"assistant-stream\";\nimport { unwrapModelContentEnvelope } from \"./modelContentEnvelope\";\n\nconst toAISDKContent = (parts: readonly ToolModelContentPart[]) => ({\n  type: \"content\" as const,\n  value: parts.map((part) => {\n    if (part.type === \"text\") {\n      return { type: \"text\" as const, text: part.text };\n    }\n    const isImage = part.mediaType.startsWith(\"image/\");\n    return isImage\n      ? {\n          type: \"image-data\" as const,\n          data: part.data,\n          mediaType: part.mediaType,\n        }\n      : {\n          type: \"file-data\" as const,\n          data: part.data,\n          mediaType: part.mediaType,\n          ...(part.filename !== undefined && { filename: part.filename }),\n        };\n  }),\n});\n\nconst defaultToModelOutput = ({ output }: { output: unknown }) => {\n  const { modelContent } = unwrapModelContentEnvelope(output);\n  if (modelContent !== undefined) {\n    return toAISDKContent(modelContent);\n  }\n  return typeof output === \"string\"\n    ? { type: \"text\" as const, value: output }\n    : { type: \"json\" as const, value: (output ?? null) as any };\n};\n\nexport const frontendTools = (\n  tools: Record<string, { description?: string; parameters: JSONSchema7 }>,\n): ToolSet =>\n  Object.fromEntries(\n    Object.entries(tools).map(([name, t]) => [\n      name,\n      {\n        ...(t.description !== undefined && { description: t.description }),\n        inputSchema: jsonSchema(t.parameters),\n        toModelOutput: defaultToModelOutput,\n      },\n    ]),\n  ) as ToolSet;\n"],"mappings":";;;AAKA,MAAM,kBAAkB,WAA4C;CAClE,MAAM;CACN,OAAO,MAAM,KAAK,SAAS;EACzB,IAAI,KAAK,SAAS,QAChB,OAAO;GAAE,MAAM;GAAiB,MAAM,KAAK;EAAK;EAGlD,OADgB,KAAK,UAAU,WAAW,QAC7B,IACT;GACE,MAAM;GACN,MAAM,KAAK;GACX,WAAW,KAAK;EAClB,IACA;GACE,MAAM;GACN,MAAM,KAAK;GACX,WAAW,KAAK;GAChB,GAAI,KAAK,aAAa,KAAA,KAAa,EAAE,UAAU,KAAK,SAAS;EAC/D;CACN,CAAC;AACH;AAEA,MAAM,wBAAwB,EAAE,aAAkC;CAChE,MAAM,EAAE,iBAAiB,2BAA2B,MAAM;CAC1D,IAAI,iBAAiB,KAAA,GACnB,OAAO,eAAe,YAAY;CAEpC,OAAO,OAAO,WAAW,WACrB;EAAE,MAAM;EAAiB,OAAO;CAAO,IACvC;EAAE,MAAM;EAAiB,OAAQ,UAAU;CAAa;AAC9D;AAEA,MAAa,iBACX,UAEA,OAAO,YACL,OAAO,QAAQ,KAAK,EAAE,KAAK,CAAC,MAAM,OAAO,CACvC,MACA;CACE,GAAI,EAAE,gBAAgB,KAAA,KAAa,EAAE,aAAa,EAAE,YAAY;CAChE,aAAa,WAAW,EAAE,UAAU;CACpC,eAAe;AACjB,CACF,CAAC,CACH"}
+{"version":3,"file":"frontendTools.js","names":[],"sources":["../src/frontendTools.ts"],"sourcesContent":["import { jsonSchema, type ToolSet } from \"ai\";\nimport type { ToolJSONSchema } from \"assistant-stream\";\nimport { unwrapModelContentEnvelope } from \"./modelContentEnvelope\";\nimport { toAISDKContent, toAISDKDefaultOutput } from \"./toolOutputConversion\";\n\nexport const defaultToModelOutput = ({ output }: { output: unknown }) => {\n  const { result, modelContent } = unwrapModelContentEnvelope(output);\n  if (modelContent !== undefined) {\n    return toAISDKContent(modelContent);\n  }\n  return toAISDKDefaultOutput(result);\n};\n\nexport const frontendTools = (tools: Record<string, ToolJSONSchema>): ToolSet =>\n  Object.fromEntries(\n    Object.entries(tools).map(([name, t]) => [\n      name,\n      {\n        ...(t.description !== undefined && { description: t.description }),\n        inputSchema: jsonSchema(t.parameters),\n        toModelOutput: defaultToModelOutput,\n        ...(t.providerOptions && { providerOptions: t.providerOptions }),\n      },\n    ]),\n  ) as ToolSet;\n"],"mappings":";;;;AAKA,MAAa,wBAAwB,EAAE,aAAkC;CACvE,MAAM,EAAE,QAAQ,iBAAiB,2BAA2B,MAAM;CAClE,IAAI,iBAAiB,KAAA,GACnB,OAAO,eAAe,YAAY;CAEpC,OAAO,qBAAqB,MAAM;AACpC;AAEA,MAAa,iBAAiB,UAC5B,OAAO,YACL,OAAO,QAAQ,KAAK,EAAE,KAAK,CAAC,MAAM,OAAO,CACvC,MACA;CACE,GAAI,EAAE,gBAAgB,KAAA,KAAa,EAAE,aAAa,EAAE,YAAY;CAChE,aAAa,WAAW,EAAE,UAAU;CACpC,eAAe;CACf,GAAI,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,gBAAgB;AAChE,CACF,CAAC,CACH"}

package/dist/generativeTools.d.ts

@@ -0,0 +1,60 @@
+import { ToolJSONSchema } from "./assistant-stream/dist/core/tool/schema-utils.js";
+import { ToolSet } from "ai";
+import { Toolkit } from "@assistant-ui/core/react";
+
+//#region src/generativeTools.d.ts
+interface GenerativeToolsOptions {
+  /**
+   * The server build of a generative toolkit (schema + server `execute`). Typed
+   * as the canonical {@link Toolkit} so callers don't need to cast; the server
+   * build carries `execute`, recovered internally as {@link ToolkitDefinition}.
+   */
+  toolkit: Toolkit;
+  /**
+   * Tools uploaded by the frontend (the request body's `tools`). Merged in
+   * alongside the `toolkit`; a server `execute` from `toolkit` takes precedence
+   * over an uploaded entry of the same name.
+   */
+  frontendTools?: Record<string, ToolJSONSchema>;
+}
+type AISDKToolkitOptions = {
+  toolkit: Toolkit;
+};
+type AISDKToolkitToolsOptions = {
+  /**
+   * Tools uploaded by the frontend request body.
+   */
+  frontend?: Record<string, ToolJSONSchema>;
+};
+/**
+ * Builds an AI SDK `ToolSet` for server-side use with `streamText` /
+ * `generateText` from a generative `toolkit` and the frontend-uploaded tools.
+ *
+ * Each toolkit tool's `execute` runs on the server. Pair this with the
+ * `"use generative"` compiler: import the toolkit in a server route (where it
+ * resolves to the server build — schema + `execute`, with `render` stripped) and
+ * pass it here. Tools without an `execute` are still exposed to the model but
+ * left for the client to fulfill. `frontendTools` lets the client contribute
+ * tools that aren't in the static toolkit. Use {@link AISDKToolkit} when the
+ * toolkit contains MCP entries.
+ *
+ * @example
+ * ```ts
+ * const { tools } = await req.json();
+ * streamText({
+ *   model,
+ *   messages,
+ *   tools: generativeTools({ toolkit: docsToolkit, frontendTools: tools }),
+ * });
+ * ```
+ */
+declare const generativeTools: (options: GenerativeToolsOptions) => ToolSet;
+declare class AISDKToolkit {
+  #private;
+  constructor(options: AISDKToolkitOptions);
+  tools(options?: AISDKToolkitToolsOptions): Promise<ToolSet>;
+  close(): Promise<void>;
+}
+//#endregion
+export { AISDKToolkit, AISDKToolkitOptions, AISDKToolkitToolsOptions, GenerativeToolsOptions, generativeTools };
+//# sourceMappingURL=generativeTools.d.ts.map

package/dist/generativeTools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generativeTools.d.ts","names":[],"sources":["../src/generativeTools.ts"],"mappings":";;;;;UAiCiB,sBAAA;;;AAAjB;;;EAME,OAAA,EAAS,OAAA;EAMsB;;;;;EAA/B,aAAA,GAAgB,MAAA,SAAe,cAAA;AAAA;AAAA,KAGrB,mBAAA;EACV,OAAA,EAAS,OAAO;AAAA;AAAA,KAGN,wBAAA;EAJA;;;EAQV,QAAA,GAAW,MAAM,SAAS,cAAA;AAAA;AAJ5B;;;;;;;;AAI0C;AAyB1C;;;;;;;;AAUC;AAED;;;;AAzCA,cA6Ba,eAAA,GAAmB,OAAA,EAAS,sBAAA,KAAyB,OAUjE;AAAA,cAEY,YAAA;EAAA;cAIC,OAAA,EAAS,mBAAA;EAIf,KAAA,CAAM,OAAA,GAAS,wBAAA,GAAgC,OAAA,CAAQ,OAAA;EASvD,KAAA,IAAS,OAAA;AAAA"}

package/dist/generativeTools.js

@@ -0,0 +1,153 @@
+import { unwrapModelContentEnvelope } from "./modelContentEnvelope.js";
+import { toAISDKContent, toAISDKDefaultOutput } from "./toolOutputConversion.js";
+import { frontendTools } from "./frontendTools.js";
+import { toJSONSchema } from "./assistant-stream/dist/core/tool/schema-utils.js";
+import { jsonSchema } from "ai";
+import { createMCPClient } from "@ai-sdk/mcp";
+import { Experimental_StdioMCPTransport } from "@ai-sdk/mcp/mcp-stdio";
+//#region src/generativeTools.ts
+const EMPTY_SCHEMA = {
+	type: "object",
+	properties: {}
+};
+const humanNotSupported = () => {
+	throw new Error("`human()` is not available during server-side tool execution.");
+};
+const neverAbort = new AbortController().signal;
+const parametersToInputSchema = (parameters) => jsonSchema(parameters ? toJSONSchema(parameters) : EMPTY_SCHEMA);
+/**
+* Builds an AI SDK `ToolSet` for server-side use with `streamText` /
+* `generateText` from a generative `toolkit` and the frontend-uploaded tools.
+*
+* Each toolkit tool's `execute` runs on the server. Pair this with the
+* `"use generative"` compiler: import the toolkit in a server route (where it
+* resolves to the server build — schema + `execute`, with `render` stripped) and
+* pass it here. Tools without an `execute` are still exposed to the model but
+* left for the client to fulfill. `frontendTools` lets the client contribute
+* tools that aren't in the static toolkit. Use {@link AISDKToolkit} when the
+* toolkit contains MCP entries.
+*
+* @example
+* ```ts
+* const { tools } = await req.json();
+* streamText({
+*   model,
+*   messages,
+*   tools: generativeTools({ toolkit: docsToolkit, frontendTools: tools }),
+* });
+* ```
+*/
+const generativeTools = (options) => {
+	assertNoMcpToolkitTools(options.toolkit);
+	return {
+		...options.frontendTools ? frontendTools(options.frontendTools) : {},
+		...toProviderToolSet(options.toolkit),
+		...toServerToolSet(options.toolkit)
+	};
+};
+var AISDKToolkit = class {
+	#toolkit;
+	#mcpClients = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.#toolkit = options.toolkit;
+	}
+	async tools(options = {}) {
+		return {
+			...options.frontend ? frontendTools(options.frontend) : {},
+			...await this.#mcpTools(),
+			...toProviderToolSet(this.#toolkit),
+			...toServerToolSet(this.#toolkit)
+		};
+	}
+	async close() {
+		const clientPromises = [...this.#mcpClients.values()];
+		this.#mcpClients.clear();
+		const results = await Promise.allSettled(clientPromises);
+		const clients = results.flatMap((result) => result.status === "fulfilled" ? [result.value] : []);
+		const closeResults = await Promise.allSettled(clients.map((client) => client.close()));
+		const errors = [...results.flatMap((result) => result.status === "rejected" ? [result.reason] : []), ...closeResults.flatMap((result) => result.status === "rejected" ? [result.reason] : [])];
+		if (errors.length === 1) throw errors[0];
+		if (errors.length > 1) throw new AggregateError(errors, "Failed to close one or more MCP clients");
+	}
+	async #mcpTools() {
+		const toolSets = await Promise.all(Object.entries(this.#toolkit).filter((entry) => isMcpToolkitTool(entry[1])).map(async ([name, tool]) => {
+			return [name, await (await this.#mcpClient(name, tool.server)).tools()];
+		}));
+		const tools = {};
+		const toolSources = /* @__PURE__ */ new Map();
+		for (const [serverName, toolSet] of toolSets) for (const [toolName, tool] of Object.entries(toolSet)) {
+			const existingServerName = toolSources.get(toolName);
+			if (existingServerName) throw new Error(`MCP tool name collision: "${toolName}" is exposed by both "${existingServerName}" and "${serverName}". Rename one of the toolkit entries or expose distinct MCP tool names.`);
+			toolSources.set(toolName, serverName);
+			tools[toolName] = tool;
+		}
+		return tools;
+	}
+	#mcpClient(name, config) {
+		const existing = this.#mcpClients.get(name);
+		if (existing) return existing;
+		let next;
+		next = createMCPClient(toMCPClientConfig(config)).catch((error) => {
+			if (this.#mcpClients.get(name) === next) this.#mcpClients.delete(name);
+			throw error;
+		});
+		this.#mcpClients.set(name, next);
+		return next;
+	}
+};
+const toMCPClientConfig = (config) => {
+	if (config.type === "stdio") return { transport: new Experimental_StdioMCPTransport({
+		command: config.command,
+		...config.args && { args: [...config.args] },
+		...config.env && { env: config.env },
+		...config.cwd && { cwd: config.cwd }
+	}) };
+	return { transport: {
+		type: config.type,
+		url: config.url,
+		...config.headers && { headers: config.headers },
+		...config.redirect && { redirect: config.redirect }
+	} };
+};
+const isMcpToolkitTool = (tool) => tool.type === "mcp" && !tool.disabled;
+const assertNoMcpToolkitTools = (toolkit) => {
+	const mcpToolName = Object.entries(toolkit).find(([, tool]) => isMcpToolkitTool(tool))?.[0];
+	if (!mcpToolName) return;
+	throw new Error(`MCP toolkit entry "${mcpToolName}" requires AISDKToolkit. Use new AISDKToolkit({ toolkit }).tools(...) instead of generativeTools(...).`);
+};
+const toAISDKToModelOutput = (toModelOutput) => async (options) => {
+	const { result, modelContent } = unwrapModelContentEnvelope(options.output);
+	if (modelContent !== void 0) return toAISDKContent(modelContent);
+	if (!toModelOutput) return toAISDKDefaultOutput(result);
+	return toAISDKContent(await toModelOutput({
+		...options,
+		output: result
+	}));
+};
+const toServerToolSet = (toolkit) => Object.fromEntries(Object.entries(toolkit).filter(([, t]) => t.type !== "mcp" && t.type !== "provider" && !t.disabled).map(([name, t]) => {
+	const execute = t.execute;
+	return [name, {
+		...t.description !== void 0 && { description: t.description },
+		inputSchema: parametersToInputSchema(t.parameters),
+		toModelOutput: toAISDKToModelOutput(t.toModelOutput),
+		...t.providerOptions && { providerOptions: t.providerOptions },
+		...execute && { execute: (args, callOptions) => execute(args, {
+			toolCallId: callOptions.toolCallId,
+			abortSignal: callOptions.abortSignal ?? neverAbort,
+			human: humanNotSupported
+		}) }
+	}];
+}));
+const toProviderToolSet = (toolkit) => Object.fromEntries(Object.entries(toolkit).filter((entry) => isProviderToolkitTool(entry[1])).map(([name, t]) => [name, {
+	type: "provider",
+	id: t.providerId,
+	args: t.args,
+	...t.parameters && { inputSchema: parametersToInputSchema(t.parameters) },
+	...t.providerOptions && { providerOptions: t.providerOptions },
+	...t.supportsDeferredResults !== void 0 && { supportsDeferredResults: t.supportsDeferredResults }
+}]));
+const isProviderToolkitTool = (tool) => tool.type === "provider" && !tool.disabled;
+//#endregion
+export { AISDKToolkit, generativeTools };
+
+//# sourceMappingURL=generativeTools.js.map

package/dist/generativeTools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generativeTools.js","names":["#toolkit","#mcpClients","#mcpTools","#mcpClient"],"sources":["../src/generativeTools.ts"],"sourcesContent":["import { jsonSchema, type ToolSet } from \"ai\";\nimport type { MCPClient, MCPClientConfig } from \"@ai-sdk/mcp\";\nimport { createMCPClient } from \"@ai-sdk/mcp\";\nimport { Experimental_StdioMCPTransport } from \"@ai-sdk/mcp/mcp-stdio\";\nimport {\n  toJSONSchema,\n  type Tool,\n  type McpServerConfig,\n  type ToolJSONSchema,\n  type ToolModelOutputFunction,\n} from \"assistant-stream\";\nimport type { Toolkit, ToolkitDefinition } from \"@assistant-ui/core/react\";\nimport { frontendTools } from \"./frontendTools\";\nimport { toAISDKContent, toAISDKDefaultOutput } from \"./toolOutputConversion\";\nimport {\n  unwrapModelContentEnvelope,\n  type ModelContentEnvelope,\n} from \"./modelContentEnvelope\";\n\nconst EMPTY_SCHEMA = { type: \"object\" as const, properties: {} };\n\nconst humanNotSupported = (): never => {\n  throw new Error(\n    \"`human()` is not available during server-side tool execution.\",\n  );\n};\n\n// AI SDK leaves `abortSignal` optional; assistant-ui's execute requires one.\nconst neverAbort = new AbortController().signal;\n\nconst parametersToInputSchema = (parameters: Tool[\"parameters\"] | undefined) =>\n  jsonSchema(parameters ? toJSONSchema(parameters) : EMPTY_SCHEMA);\n\nexport interface GenerativeToolsOptions {\n  /**\n   * The server build of a generative toolkit (schema + server `execute`). Typed\n   * as the canonical {@link Toolkit} so callers don't need to cast; the server\n   * build carries `execute`, recovered internally as {@link ToolkitDefinition}.\n   */\n  toolkit: Toolkit;\n  /**\n   * Tools uploaded by the frontend (the request body's `tools`). Merged in\n   * alongside the `toolkit`; a server `execute` from `toolkit` takes precedence\n   * over an uploaded entry of the same name.\n   */\n  frontendTools?: Record<string, ToolJSONSchema>;\n}\n\nexport type AISDKToolkitOptions = {\n  toolkit: Toolkit;\n};\n\nexport type AISDKToolkitToolsOptions = {\n  /**\n   * Tools uploaded by the frontend request body.\n   */\n  frontend?: Record<string, ToolJSONSchema>;\n};\n\n/**\n * Builds an AI SDK `ToolSet` for server-side use with `streamText` /\n * `generateText` from a generative `toolkit` and the frontend-uploaded tools.\n *\n * Each toolkit tool's `execute` runs on the server. Pair this with the\n * `\"use generative\"` compiler: import the toolkit in a server route (where it\n * resolves to the server build — schema + `execute`, with `render` stripped) and\n * pass it here. Tools without an `execute` are still exposed to the model but\n * left for the client to fulfill. `frontendTools` lets the client contribute\n * tools that aren't in the static toolkit. Use {@link AISDKToolkit} when the\n * toolkit contains MCP entries.\n *\n * @example\n * ```ts\n * const { tools } = await req.json();\n * streamText({\n *   model,\n *   messages,\n *   tools: generativeTools({ toolkit: docsToolkit, frontendTools: tools }),\n * });\n * ```\n */\nexport const generativeTools = (options: GenerativeToolsOptions): ToolSet => {\n  assertNoMcpToolkitTools(options.toolkit);\n  return {\n    ...(options.frontendTools ? frontendTools(options.frontendTools) : {}),\n    // `toolkit` last so its server-side `execute` wins over an uploaded entry of\n    // the same name. The cast recovers the declaration shape — the server build\n    // carries `execute`, which the canonical `Toolkit` type erases.\n    ...toProviderToolSet(options.toolkit),\n    ...toServerToolSet(options.toolkit as ToolkitDefinition),\n  };\n};\n\nexport class AISDKToolkit {\n  readonly #toolkit: Toolkit;\n  readonly #mcpClients = new Map<string, Promise<MCPClient>>();\n\n  constructor(options: AISDKToolkitOptions) {\n    this.#toolkit = options.toolkit;\n  }\n\n  async tools(options: AISDKToolkitToolsOptions = {}): Promise<ToolSet> {\n    return {\n      ...(options.frontend ? frontendTools(options.frontend) : {}),\n      ...(await this.#mcpTools()),\n      ...toProviderToolSet(this.#toolkit),\n      ...toServerToolSet(this.#toolkit as ToolkitDefinition),\n    };\n  }\n\n  async close(): Promise<void> {\n    const clientPromises = [...this.#mcpClients.values()];\n    this.#mcpClients.clear();\n    const results = await Promise.allSettled(clientPromises);\n    const clients = results.flatMap((result) =>\n      result.status === \"fulfilled\" ? [result.value] : [],\n    );\n    const closeResults = await Promise.allSettled(\n      clients.map((client) => client.close()),\n    );\n    const errors = [\n      ...results.flatMap((result) =>\n        result.status === \"rejected\" ? [result.reason] : [],\n      ),\n      ...closeResults.flatMap((result) =>\n        result.status === \"rejected\" ? [result.reason] : [],\n      ),\n    ];\n    if (errors.length === 1) throw errors[0];\n    if (errors.length > 1) {\n      throw new AggregateError(\n        errors,\n        \"Failed to close one or more MCP clients\",\n      );\n    }\n  }\n\n  async #mcpTools(): Promise<ToolSet> {\n    const toolSets = await Promise.all(\n      Object.entries(this.#toolkit)\n        .filter((entry): entry is [string, McpToolkitTool] =>\n          isMcpToolkitTool(entry[1]),\n        )\n        .map(async ([name, tool]) => {\n          const client = await this.#mcpClient(name, tool.server);\n          return [name, await client.tools()] as const;\n        }),\n    );\n\n    const tools: ToolSet = {};\n    const toolSources = new Map<string, string>();\n    for (const [serverName, toolSet] of toolSets) {\n      for (const [toolName, tool] of Object.entries(toolSet)) {\n        const existingServerName = toolSources.get(toolName);\n        if (existingServerName) {\n          throw new Error(\n            `MCP tool name collision: \"${toolName}\" is exposed by both \"${existingServerName}\" and \"${serverName}\". Rename one of the toolkit entries or expose distinct MCP tool names.`,\n          );\n        }\n        toolSources.set(toolName, serverName);\n        tools[toolName] = tool;\n      }\n    }\n    return tools;\n  }\n\n  #mcpClient(name: string, config: McpServerConfig): Promise<MCPClient> {\n    const existing = this.#mcpClients.get(name);\n    if (existing) return existing;\n    let next: Promise<MCPClient>;\n    next = createMCPClient(toMCPClientConfig(config)).catch((error) => {\n      if (this.#mcpClients.get(name) === next) {\n        this.#mcpClients.delete(name);\n      }\n      throw error;\n    });\n    this.#mcpClients.set(name, next);\n    return next;\n  }\n}\n\nconst toMCPClientConfig = (config: McpServerConfig): MCPClientConfig => {\n  if (config.type === \"stdio\") {\n    return {\n      transport: new Experimental_StdioMCPTransport({\n        command: config.command,\n        ...(config.args && { args: [...config.args] }),\n        ...(config.env && { env: config.env }),\n        ...(config.cwd && { cwd: config.cwd }),\n      }),\n    };\n  }\n\n  return {\n    transport: {\n      type: config.type,\n      url: config.url,\n      ...(config.headers && { headers: config.headers }),\n      ...(config.redirect && { redirect: config.redirect }),\n    },\n  };\n};\n\ntype ToolkitTool = Toolkit[string];\n\ntype McpToolkitTool = ToolkitTool & {\n  type: \"mcp\";\n  server: McpServerConfig;\n};\n\nconst isMcpToolkitTool = (tool: ToolkitTool): tool is McpToolkitTool =>\n  tool.type === \"mcp\" && !tool.disabled;\n\nconst assertNoMcpToolkitTools = (toolkit: Toolkit): void => {\n  const mcpToolName = Object.entries(toolkit).find(([, tool]) =>\n    isMcpToolkitTool(tool),\n  )?.[0];\n  if (!mcpToolName) return;\n\n  throw new Error(\n    `MCP toolkit entry \"${mcpToolName}\" requires AISDKToolkit. Use new AISDKToolkit({ toolkit }).tools(...) instead of generativeTools(...).`,\n  );\n};\n\ntype AISDKToModelOutputOptions<TArgs, TResult> = Omit<\n  Parameters<ToolModelOutputFunction<TArgs, TResult>>[0],\n  \"output\"\n> & {\n  output: TResult | ModelContentEnvelope<TResult>;\n};\n\nconst toAISDKToModelOutput =\n  <TArgs, TResult>(toModelOutput?: ToolModelOutputFunction<TArgs, TResult>) =>\n  async (options: AISDKToModelOutputOptions<TArgs, TResult>) => {\n    const { result, modelContent } = unwrapModelContentEnvelope(options.output);\n\n    if (modelContent !== undefined) {\n      return toAISDKContent(modelContent);\n    }\n\n    if (!toModelOutput) {\n      return toAISDKDefaultOutput(result);\n    }\n\n    const parts = await toModelOutput({\n      ...options,\n      output: result,\n    });\n    return toAISDKContent(parts);\n  };\n\nconst toServerToolSet = (toolkit: ToolkitDefinition): ToolSet =>\n  Object.fromEntries(\n    Object.entries(toolkit)\n      .filter(\n        ([, t]) => t.type !== \"mcp\" && t.type !== \"provider\" && !t.disabled,\n      )\n      .map(([name, t]) => {\n        const execute = t.execute;\n        return [\n          name,\n          {\n            ...(t.description !== undefined && { description: t.description }),\n            inputSchema: parametersToInputSchema(t.parameters),\n            toModelOutput: toAISDKToModelOutput(t.toModelOutput),\n            ...(t.providerOptions && { providerOptions: t.providerOptions }),\n            ...(execute && {\n              execute: (\n                args: unknown,\n                callOptions: { toolCallId: string; abortSignal?: AbortSignal },\n              ) =>\n                execute(args as never, {\n                  toolCallId: callOptions.toolCallId,\n                  abortSignal: callOptions.abortSignal ?? neverAbort,\n                  human: humanNotSupported,\n                }),\n            }),\n          },\n        ];\n      }),\n  ) as ToolSet;\n\nconst toProviderToolSet = (toolkit: Toolkit): ToolSet =>\n  Object.fromEntries(\n    Object.entries(toolkit)\n      .filter((entry): entry is [string, ProviderToolkitTool] =>\n        isProviderToolkitTool(entry[1]),\n      )\n      .map(([name, t]) => [\n        name,\n        {\n          type: \"provider\",\n          id: t.providerId,\n          args: t.args,\n          ...(t.parameters && {\n            inputSchema: parametersToInputSchema(t.parameters),\n          }),\n          ...(t.providerOptions && { providerOptions: t.providerOptions }),\n          ...(t.supportsDeferredResults !== undefined && {\n            supportsDeferredResults: t.supportsDeferredResults,\n          }),\n        },\n      ]),\n  ) as ToolSet;\n\ntype ProviderToolkitTool = Extract<Toolkit[string], { type: \"provider\" }>;\n\nconst isProviderToolkitTool = (\n  tool: Toolkit[string],\n): tool is ProviderToolkitTool => tool.type === \"provider\" && !tool.disabled;\n"],"mappings":"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"}

package/dist/index.d.ts

@@ -1,10 +1,11 @@
 /// <reference types="@assistant-ui/core/react" />
 import { frontendTools } from "./frontendTools.js";
+import { AISDKToolkit, AISDKToolkitOptions, AISDKToolkitToolsOptions, GenerativeToolsOptions, generativeTools } from "./generativeTools.js";
 import { useAISDKRuntime } from "./ui/use-chat/useAISDKRuntime.js";
 import { UseChatRuntimeOptions, useChatRuntime } from "./ui/use-chat/useChatRuntime.js";
-import { RESUMABLE_STREAM_ID_HEADER } from "./packages/assistant-stream/dist/resumable/createResumableAssistantStreamResponse.js";
+import { RESUMABLE_STREAM_ID_HEADER } from "./assistant-stream/dist/resumable/createResumableAssistantStreamResponse.js";
 import { AssistantChatResumableOptions, ResumableClientStorage, createResumableSessionStorage } from "./ui/resumable.js";
 import { AssistantChatTransport } from "./ui/use-chat/AssistantChatTransport.js";
 import { injectQuoteContext } from "./injectQuoteContext.js";
 import { ThreadTokenUsage, TokenUsageExtractableMessage, getThreadMessageTokenUsage, useThreadTokenUsage } from "./usage.js";
-export { type AssistantChatResumableOptions, AssistantChatTransport, RESUMABLE_STREAM_ID_HEADER, type ResumableClientStorage, type ThreadTokenUsage, type TokenUsageExtractableMessage, type UseChatRuntimeOptions, createResumableSessionStorage, frontendTools, getThreadMessageTokenUsage, injectQuoteContext, useAISDKRuntime, useChatRuntime, useThreadTokenUsage };
+export { AISDKToolkit, type AISDKToolkitOptions, type AISDKToolkitToolsOptions, type AssistantChatResumableOptions, AssistantChatTransport, type GenerativeToolsOptions, RESUMABLE_STREAM_ID_HEADER, type ResumableClientStorage, type ThreadTokenUsage, type TokenUsageExtractableMessage, type UseChatRuntimeOptions, createResumableSessionStorage, frontendTools, generativeTools, getThreadMessageTokenUsage, injectQuoteContext, useAISDKRuntime, useChatRuntime, useThreadTokenUsage };

package/dist/index.js

@@ -1,9 +1,10 @@
 import { frontendTools } from "./frontendTools.js";
+import { AISDKToolkit, generativeTools } from "./generativeTools.js";
 import { useAISDKRuntime } from "./ui/use-chat/useAISDKRuntime.js";
-import { RESUMABLE_STREAM_ID_HEADER } from "./packages/assistant-stream/dist/resumable/createResumableAssistantStreamResponse.js";
+import { RESUMABLE_STREAM_ID_HEADER } from "./assistant-stream/dist/resumable/createResumableAssistantStreamResponse.js";
 import { createResumableSessionStorage } from "./ui/resumable.js";
 import { AssistantChatTransport } from "./ui/use-chat/AssistantChatTransport.js";
 import { useChatRuntime } from "./ui/use-chat/useChatRuntime.js";
 import { injectQuoteContext } from "./injectQuoteContext.js";
 import { getThreadMessageTokenUsage, useThreadTokenUsage } from "./usage.js";
-export { AssistantChatTransport, RESUMABLE_STREAM_ID_HEADER, createResumableSessionStorage, frontendTools, getThreadMessageTokenUsage, injectQuoteContext, useAISDKRuntime, useChatRuntime, useThreadTokenUsage };
+export { AISDKToolkit, AssistantChatTransport, RESUMABLE_STREAM_ID_HEADER, createResumableSessionStorage, frontendTools, generativeTools, getThreadMessageTokenUsage, injectQuoteContext, useAISDKRuntime, useChatRuntime, useThreadTokenUsage };

package/dist/modelContentEnvelope.d.ts

@@ -1,14 +1,14 @@
-import { ToolModelContentPart } from "./packages/assistant-stream/dist/core/tool/tool-types.js";
+import { ToolModelContentPart } from "./assistant-stream/dist/core/tool/tool-types.js";
 //#region src/modelContentEnvelope.d.ts
 declare const ENVELOPE_KEY = "__aui_modelContent";
 type ModelContentEnvelope<TResult = unknown> = {
   readonly [ENVELOPE_KEY]: readonly ToolModelContentPart[];
   readonly value: TResult;
 };
-declare function isModelContentEnvelope(value: unknown): value is ModelContentEnvelope;
+declare function isModelContentEnvelope<TResult = unknown>(value: TResult | ModelContentEnvelope<TResult>): value is ModelContentEnvelope<TResult>;
 declare function wrapModelContentEnvelope<TResult>(result: TResult, modelContent: readonly ToolModelContentPart[]): ModelContentEnvelope<TResult>;
-declare function unwrapModelContentEnvelope(output: unknown): {
-  result: unknown;
+declare function unwrapModelContentEnvelope<TResult>(output: TResult | ModelContentEnvelope<TResult>): {
+  result: TResult;
   modelContent?: readonly ToolModelContentPart[];
 };
 //#endregion

package/dist/modelContentEnvelope.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"modelContentEnvelope.d.ts","names":[],"sources":["../src/modelContentEnvelope.ts"],"mappings":";;cAEM,YAAA;AAAA,KAEM,oBAAA;EAAA,UACA,YAAA,YAAwB,oBAAA;EAAA,SACzB,KAAA,EAAO,OAAA;AAAA;AAAA,iBAGF,sBAAA,CACd,KAAA,YACC,KAAA,IAAS,oBAAoB;AAAA,iBAShB,wBAAA,SAAA,CACd,MAAA,EAAQ,OAAA,EACR,YAAA,WAAuB,oBAAA,KACtB,oBAAA,CAAqB,OAAA;AAAA,iBAIR,0BAAA,CAA2B,MAAA;EACzC,MAAA;EACA,YAAA,YAAwB,oBAAoB;AAAA"}
+{"version":3,"file":"modelContentEnvelope.d.ts","names":[],"sources":["../src/modelContentEnvelope.ts"],"mappings":";;cAEM,YAAA;AAAA,KAEM,oBAAA;EAAA,UACA,YAAA,YAAwB,oBAAA;EAAA,SACzB,KAAA,EAAO,OAAA;AAAA;AAAA,iBAGF,sBAAA,oBACd,KAAA,EAAO,OAAA,GAAU,oBAAA,CAAqB,OAAA,IACrC,KAAA,IAAS,oBAAA,CAAqB,OAAA;AAAA,iBASjB,wBAAA,UACd,MAAA,EAAQ,OAAA,EACR,YAAA,WAAuB,oBAAA,KACtB,oBAAA,CAAqB,OAAA;AAAA,iBAIR,0BAAA,UACd,MAAA,EAAQ,OAAA,GAAU,oBAAA,CAAqB,OAAA;EAEvC,MAAA,EAAQ,OAAA;EACR,YAAA,YAAwB,oBAAA;AAAA"}

package/dist/modelContentEnvelope.js.map

@@ -1 +1 @@
-{"version":3,"file":"modelContentEnvelope.js","names":[],"sources":["../src/modelContentEnvelope.ts"],"sourcesContent":["import type { ToolModelContentPart } from \"assistant-stream\";\n\nconst ENVELOPE_KEY = \"__aui_modelContent\";\n\nexport type ModelContentEnvelope<TResult = unknown> = {\n  readonly [ENVELOPE_KEY]: readonly ToolModelContentPart[];\n  readonly value: TResult;\n};\n\nexport function isModelContentEnvelope(\n  value: unknown,\n): value is ModelContentEnvelope {\n  return (\n    value != null &&\n    typeof value === \"object\" &&\n    ENVELOPE_KEY in value &&\n    Array.isArray((value as Record<string, unknown>)[ENVELOPE_KEY])\n  );\n}\n\nexport function wrapModelContentEnvelope<TResult>(\n  result: TResult,\n  modelContent: readonly ToolModelContentPart[],\n): ModelContentEnvelope<TResult> {\n  return { [ENVELOPE_KEY]: modelContent, value: result };\n}\n\nexport function unwrapModelContentEnvelope(output: unknown): {\n  result: unknown;\n  modelContent?: readonly ToolModelContentPart[];\n} {\n  if (isModelContentEnvelope(output)) {\n    return {\n      result: output.value,\n      modelContent: output[ENVELOPE_KEY],\n    };\n  }\n  return { result: output };\n}\n"],"mappings":";AAEA,MAAM,eAAe;AAOrB,SAAgB,uBACd,OAC+B;CAC/B,OACE,SAAS,QACT,OAAO,UAAU,YACjB,gBAAgB,SAChB,MAAM,QAAS,MAAkC,aAAa;AAElE;AAEA,SAAgB,yBACd,QACA,cAC+B;CAC/B,OAAO;GAAG,eAAe;EAAc,OAAO;CAAO;AACvD;AAEA,SAAgB,2BAA2B,QAGzC;CACA,IAAI,uBAAuB,MAAM,GAC/B,OAAO;EACL,QAAQ,OAAO;EACf,cAAc,OAAO;CACvB;CAEF,OAAO,EAAE,QAAQ,OAAO;AAC1B"}
+{"version":3,"file":"modelContentEnvelope.js","names":[],"sources":["../src/modelContentEnvelope.ts"],"sourcesContent":["import type { ToolModelContentPart } from \"assistant-stream\";\n\nconst ENVELOPE_KEY = \"__aui_modelContent\";\n\nexport type ModelContentEnvelope<TResult = unknown> = {\n  readonly [ENVELOPE_KEY]: readonly ToolModelContentPart[];\n  readonly value: TResult;\n};\n\nexport function isModelContentEnvelope<TResult = unknown>(\n  value: TResult | ModelContentEnvelope<TResult>,\n): value is ModelContentEnvelope<TResult> {\n  return (\n    value != null &&\n    typeof value === \"object\" &&\n    ENVELOPE_KEY in value &&\n    Array.isArray((value as Record<string, unknown>)[ENVELOPE_KEY])\n  );\n}\n\nexport function wrapModelContentEnvelope<TResult>(\n  result: TResult,\n  modelContent: readonly ToolModelContentPart[],\n): ModelContentEnvelope<TResult> {\n  return { [ENVELOPE_KEY]: modelContent, value: result };\n}\n\nexport function unwrapModelContentEnvelope<TResult>(\n  output: TResult | ModelContentEnvelope<TResult>,\n): {\n  result: TResult;\n  modelContent?: readonly ToolModelContentPart[];\n} {\n  if (isModelContentEnvelope(output)) {\n    return {\n      result: output.value,\n      modelContent: output[ENVELOPE_KEY],\n    };\n  }\n  return { result: output };\n}\n"],"mappings":";AAEA,MAAM,eAAe;AAOrB,SAAgB,uBACd,OACwC;CACxC,OACE,SAAS,QACT,OAAO,UAAU,YACjB,gBAAgB,SAChB,MAAM,QAAS,MAAkC,aAAa;AAElE;AAEA,SAAgB,yBACd,QACA,cAC+B;CAC/B,OAAO;GAAG,eAAe;EAAc,OAAO;CAAO;AACvD;AAEA,SAAgB,2BACd,QAIA;CACA,IAAI,uBAAuB,MAAM,GAC/B,OAAO;EACL,QAAQ,OAAO;EACf,cAAc,OAAO;CACvB;CAEF,OAAO,EAAE,QAAQ,OAAO;AAC1B"}