@assistant-ui/react-ai-sdk 1.3.28 → 1.3.31

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

@@ -35,16 +35,22 @@ function defaultToolFilter(_name, tool) {
 /**
 * 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) && tool.parameters).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\";\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) && tool.parameters).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;AACxC;;;;;;;;;;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,KAAK,KAAK,UAAU,EAAE,MAAM,CAAC,IAAI,CAAC,OAAO,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,CAAC,EAAE,KAAK,CAAC,MAAM,UAAU,CAAC,MAAM;EAC3L,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","FrontendTool","BackendTool","HumanTool","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: any;
+};
+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":";;;;cA0Ba,oBAAA;EAAwB;AAAA;EAAc,MAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;cAUtC,aAAA,GAAiB,KAAA,EAAO,MAAA,SAAe,cAAA,MAAkB,OAAA"}

package/dist/frontendTools.js

@@ -34,9 +34,10 @@ const defaultToModelOutput = ({ output }) => {
 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, 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\nexport const 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 = (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":";;;AAIA,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,MAAa,wBAAwB,EAAE,aAAkC;CACvE,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,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,44 @@
+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 ToolkitDeclaration}.
+   */
+  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>;
+}
+/**
+ * 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.
+ *
+ * @example
+ * ```ts
+ * const { tools } = await req.json();
+ * streamText({
+ *   model,
+ *   messages,
+ *   tools: generativeTools({ toolkit: docsToolkit, frontendTools: tools }),
+ * });
+ * ```
+ */
+declare const generativeTools: (options: GenerativeToolsOptions) => ToolSet;
+//#endregion
+export { 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":";;;;;UAgBiB,sBAAA;;;AAAjB;;;EAME,OAAA,EAAS,OAAA;EAMsB;;;;;EAA/B,aAAA,GAAgB,MAAA,SAAe,cAAA;AAAA;;;;AAAc;AAwB/C;;;;;;;;AAME;;;;;;;;;cANW,eAAA,GAAmB,OAAA,EAAS,sBAAA,KAAyB,OAMhE"}

package/dist/generativeTools.js

@@ -0,0 +1,55 @@
+import { defaultToModelOutput, frontendTools } from "./frontendTools.js";
+import { toJSONSchema } from "./assistant-stream/dist/core/tool/schema-utils.js";
+import { jsonSchema } from "ai";
+//#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;
+/**
+* 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.
+*
+* @example
+* ```ts
+* const { tools } = await req.json();
+* streamText({
+*   model,
+*   messages,
+*   tools: generativeTools({ toolkit: docsToolkit, frontendTools: tools }),
+* });
+* ```
+*/
+const generativeTools = (options) => ({
+	...options.frontendTools ? frontendTools(options.frontendTools) : {},
+	...toServerToolSet(options.toolkit)
+});
+const toServerToolSet = (toolkit) => Object.fromEntries(Object.entries(toolkit).filter(([, t]) => !t.disabled).map(([name, t]) => {
+	const execute = t.execute;
+	return [name, {
+		...t.description !== void 0 && { description: t.description },
+		inputSchema: jsonSchema(t.parameters ? toJSONSchema(t.parameters) : EMPTY_SCHEMA),
+		toModelOutput: t.toModelOutput ?? defaultToModelOutput,
+		...t.providerOptions && { providerOptions: t.providerOptions },
+		...execute && { execute: (args, callOptions) => execute(args, {
+			toolCallId: callOptions.toolCallId,
+			abortSignal: callOptions.abortSignal ?? neverAbort,
+			human: humanNotSupported
+		}) }
+	}];
+}));
+//#endregion
+export { generativeTools };
+
+//# sourceMappingURL=generativeTools.js.map

package/dist/generativeTools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generativeTools.js","names":[],"sources":["../src/generativeTools.ts"],"sourcesContent":["import { jsonSchema, type ToolSet } from \"ai\";\nimport { toJSONSchema, type ToolJSONSchema } from \"assistant-stream\";\nimport type { Toolkit, ToolkitDeclaration } from \"@assistant-ui/core/react\";\nimport { defaultToModelOutput, frontendTools } from \"./frontendTools\";\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\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 ToolkitDeclaration}.\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\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.\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  ...(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  ...toServerToolSet(options.toolkit as ToolkitDeclaration),\n});\n\nconst toServerToolSet = (toolkit: ToolkitDeclaration): ToolSet =>\n  Object.fromEntries(\n    Object.entries(toolkit)\n      .filter(([, t]) => !t.disabled)\n      .map(([name, t]) => {\n        const execute = t.execute;\n        return [\n          name,\n          {\n            ...(t.description !== undefined && { description: t.description }),\n            inputSchema: jsonSchema(\n              t.parameters ? toJSONSchema(t.parameters) : EMPTY_SCHEMA,\n            ),\n            toModelOutput: t.toModelOutput ?? defaultToModelOutput,\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"],"mappings":";;;;AAKA,MAAM,eAAe;CAAE,MAAM;CAAmB,YAAY,CAAC;AAAE;AAE/D,MAAM,0BAAiC;CACrC,MAAM,IAAI,MACR,+DACF;AACF;AAGA,MAAM,aAAa,IAAI,gBAAgB,EAAE;;;;;;;;;;;;;;;;;;;;;;AAsCzC,MAAa,mBAAmB,aAA8C;CAC5E,GAAI,QAAQ,gBAAgB,cAAc,QAAQ,aAAa,IAAI,CAAC;CAIpE,GAAG,gBAAgB,QAAQ,OAA6B;AAC1D;AAEA,MAAM,mBAAmB,YACvB,OAAO,YACL,OAAO,QAAQ,OAAO,EACnB,QAAQ,GAAG,OAAO,CAAC,EAAE,QAAQ,EAC7B,KAAK,CAAC,MAAM,OAAO;CAClB,MAAM,UAAU,EAAE;CAClB,OAAO,CACL,MACA;EACE,GAAI,EAAE,gBAAgB,KAAA,KAAa,EAAE,aAAa,EAAE,YAAY;EAChE,aAAa,WACX,EAAE,aAAa,aAAa,EAAE,UAAU,IAAI,YAC9C;EACA,eAAe,EAAE,iBAAiB;EAClC,GAAI,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,gBAAgB;EAC9D,GAAI,WAAW,EACb,UACE,MACA,gBAEA,QAAQ,MAAe;GACrB,YAAY,YAAY;GACxB,aAAa,YAAY,eAAe;GACxC,OAAO;EACT,CAAC,EACL;CACF,CACF;AACF,CAAC,CACL"}

package/dist/index.d.ts

@@ -1,11 +1,11 @@
-/// <reference types="@assistant-ui/core/store" />
 /// <reference types="@assistant-ui/core/react" />
 import { frontendTools } from "./frontendTools.js";
+import { 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 { 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 { 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 { AssistantChatTransport, RESUMABLE_STREAM_ID_HEADER, createResumableSessionStorage, frontendTools, generativeTools, getThreadMessageTokenUsage, injectQuoteContext, useAISDKRuntime, useChatRuntime, useThreadTokenUsage };

package/dist/modelContentEnvelope.d.ts

@@ -1,4 +1,4 @@
-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> = {

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,CACd,KAAA,YACC,KAAA,IAAS,oBAAoB;AAAA,iBAShB,wBAAA,UACd,MAAA,EAAQ,OAAA,EACR,YAAA,WAAuB,oBAAA,KACtB,oBAAA,CAAqB,OAAA;AAAA,iBAIR,0BAAA,CAA2B,MAAA;EACzC,MAAA;EACA,YAAA,YAAwB,oBAAoB;AAAA"}

package/dist/ui/resumable.d.ts

@@ -1,4 +1,4 @@
-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";
 //#region src/ui/resumable.d.ts
 type ResumableClientStorage = {
   getStreamId(): string | null;

package/dist/ui/resumable.js

@@ -1,5 +1,5 @@
 "use client";
-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";
 //#region src/ui/resumable.ts
 const DEFAULT_STORAGE_KEY = "aui-resumable-stream-id";
 /** `sessionStorage`-backed storage for the pending resumable stream id. */

package/dist/ui/use-chat/AssistantChatTransport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AssistantChatTransport.d.ts","names":[],"sources":["../../../src/ui/use-chat/AssistantChatTransport.ts"],"mappings":";;;;;KAeK,2BAAA,GAA8B,IAAI,CAAC,qBAAA;AAAA,KAM5B,iCAAA,oBAAqD,SAAA,IAC/D,4BAAA,CAA6B,UAAA;EAC3B,SAAA,GAAY,6BAAA;AAAA;AAAA,cAGH,sBAAA,oBACQ,SAAA,UACX,oBAAA,CAAqB,UAAA;EAAA,QACrB,OAAA;EAAA,QACA,iBAAA;EAAA,iBAGS,SAAA;cAEL,WAAA,GAAc,iCAAA,CAAkC,UAAA;EAkD5D,UAAA,CAAW,OAAA,EAAS,gBAAA;EAIpB,mBAAA,CAAA,GAAuB,6BAAA;EAIvB,+BAAA,CACE,MAAA,QAAc,2BAAA;AAAA"}
+{"version":3,"file":"AssistantChatTransport.d.ts","names":[],"sources":["../../../src/ui/use-chat/AssistantChatTransport.ts"],"mappings":";;;;;KAeK,2BAAA,GAA8B,IAAI,CAAC,qBAAA;AAAA,KAM5B,iCAAA,oBAAqD,SAAA,IAC/D,4BAAA,CAA6B,UAAA;EAC3B,SAAA,GAAY,6BAAA;AAAA;AAAA,cAGH,sBAAA,oBACQ,SAAA,UACX,oBAAA,CAAqB,UAAA;EAAA,QACrB,OAAA;EAAA,QACA,iBAAA;EAAA,iBAGS,SAAA;cAEL,WAAA,GAAc,iCAAA,CAAkC,UAAA;EAkD5D,UAAA,CAAW,OAAA,EAAS,gBAAA;EAIpB,mBAAA,IAAuB,6BAAA;EAIvB,+BAAA,CACE,MAAA,QAAc,2BAAA;AAAA"}

package/dist/ui/use-chat/AssistantChatTransport.js

@@ -1,5 +1,5 @@
-import { toToolsJSONSchema } from "../../packages/assistant-stream/dist/core/tool/schema-utils.js";
-import { RESUMABLE_STREAM_ID_HEADER } from "../../packages/assistant-stream/dist/resumable/createResumableAssistantStreamResponse.js";
+import { toToolsJSONSchema } from "../../assistant-stream/dist/core/tool/schema-utils.js";
+import { RESUMABLE_STREAM_ID_HEADER } from "../../assistant-stream/dist/resumable/createResumableAssistantStreamResponse.js";
 import { DefaultChatTransport } from "ai";
 //#region src/ui/use-chat/AssistantChatTransport.ts
 const FINISH_MARKER = "\"type\":\"finish\"";

package/dist/ui/use-chat/useAISDKRuntime.d.ts

@@ -1,9 +1,9 @@
-import { AppendMessage, AssistantRuntime, ExternalStoreAdapter, ThreadHistoryAdapter, ThreadSuggestion } from "@assistant-ui/core";
+import { AppendMessage, AssistantRuntime, ExternalStoreAdapter, ExternalStoreSharedOptions, ThreadHistoryAdapter } from "@assistant-ui/core";
 import { CreateUIMessage, UIMessage, useChat } from "@ai-sdk/react";
 
 //#region src/ui/use-chat/useAISDKRuntime.d.ts
 type CustomToCreateMessageFunction = <UI_MESSAGE extends UIMessage = UIMessage>(message: AppendMessage) => CreateUIMessage<UI_MESSAGE>;
-type AISDKRuntimeAdapter = {
+type AISDKRuntimeAdapter = ExternalStoreSharedOptions & {
   adapters?: (NonNullable<ExternalStoreAdapter["adapters"]> & {
     history?: ThreadHistoryAdapter | undefined;
   }) | undefined;
@@ -25,21 +25,8 @@ type AISDKRuntimeAdapter = {
    * (for example, an SSE reconnect endpoint keyed by turn id).
    */
   onResume?: ExternalStoreAdapter["onResume"];
-  /**
-   * Follow up suggestions to surface on the thread. Use this to drive
-   * dynamic suggestions from application state, tool results, or backend
-   * responses; flows into `thread.suggestions` and is rendered by
-   * components that read it (such as the shadcn `ThreadFollowupSuggestions`).
-   */
-  suggestions?: readonly ThreadSuggestion[] | undefined;
 };
-declare const useAISDKRuntime: <UI_MESSAGE extends UIMessage = UIMessage>(chatHelpers: ReturnType<typeof useChat<UI_MESSAGE>>, {
-  adapters,
-  toCreateMessage: customToCreateMessage,
-  cancelPendingToolCallsOnSend,
-  onResume,
-  suggestions
-}?: AISDKRuntimeAdapter) => AssistantRuntime;
+declare const useAISDKRuntime: <UI_MESSAGE extends UIMessage = UIMessage>(chatHelpers: ReturnType<typeof useChat<UI_MESSAGE>>, adapter?: AISDKRuntimeAdapter) => AssistantRuntime;
 //#endregion
 export { AISDKRuntimeAdapter, CustomToCreateMessageFunction, useAISDKRuntime };
 //# sourceMappingURL=useAISDKRuntime.d.ts.map

package/dist/ui/use-chat/useAISDKRuntime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useAISDKRuntime.d.ts","names":[],"sources":["../../../src/ui/use-chat/useAISDKRuntime.ts"],"mappings":";;;;KA0CY,6BAAA,uBACS,SAAA,GAAY,SAAA,EAE/B,OAAA,EAAS,aAAA,KACN,eAAA,CAAgB,UAAA;AAAA,KAYT,mBAAA;EACV,QAAA,IACK,WAAA,CAAY,oBAAA;IACX,OAAA,GAAU,oBAAA;EAAA;EAGhB,eAAA,GAAkB,6BAAA;EArBa;;;;;;;;EA8B/B,4BAAA;EA5BS;;;;;AACoB;AAY/B;EAuBE,QAAA,GAAW,oBAAA;;;;;;;EAOX,WAAA,YAAuB,gBAAA;AAAA;AAAA,cAGZ,eAAA,sBAAsC,SAAA,GAAY,SAAA,EAC7D,WAAA,EAAa,UAAA,QAAkB,OAAA,CAAQ,UAAA;EACvC,QAAA;EAAA,eAAA,EAAA,qBAAA;EAAA,4BAAA;EAAA,QAAA;EAAA;AAAA,IAMG,mBAAA,KAAwB,gBAAA"}
+{"version":3,"file":"useAISDKRuntime.d.ts","names":[],"sources":["../../../src/ui/use-chat/useAISDKRuntime.ts"],"mappings":";;;;KA4CY,6BAAA,uBACS,SAAA,GAAY,SAAA,EAE/B,OAAA,EAAS,aAAA,KACN,eAAA,CAAgB,UAAA;AAAA,KAYT,mBAAA,GAAsB,0BAAA;EAChC,QAAA,IACK,WAAA,CAAY,oBAAA;IACX,OAAA,GAAU,oBAAA;EAAA;EAGhB,eAAA,GAAkB,6BAAA;EArBa;;;;;;;;EA8B/B,4BAAA;EA5BS;;;;;AACoB;AAY/B;EAuBE,QAAA,GAAW,oBAAA;AAAA;AAAA,cAGA,eAAA,sBAAsC,SAAA,GAAY,SAAA,EAC7D,WAAA,EAAa,UAAA,QAAkB,OAAA,CAAQ,UAAA,IACvC,OAAA,GAAS,mBAAA,KAAwB,gBAAA"}

package/dist/ui/use-chat/useAISDKRuntime.js

@@ -10,15 +10,16 @@ import { toExportedMessageRepository, useExternalHistory } from "./useExternalHi
 import { useStreamingTiming } from "./useStreamingTiming.js";
 import { generateId, isToolUIPart } from "ai";
 import { useMemo, useRef, useState } from "react";
-import { useExternalStoreRuntime, useRuntimeAdapters, useToolInvocations } from "@assistant-ui/core/react";
-import { getExternalStoreMessages } from "@assistant-ui/core";
+import { useExternalStoreRuntime, useRuntimeAdapters } from "@assistant-ui/core/react";
+import { getExternalStoreMessages, pickExternalStoreSharedOptions } from "@assistant-ui/core";
 //#region src/ui/use-chat/useAISDKRuntime.ts
 const toUIMessage = (createMessage, fallbackRole) => ({
 	...createMessage,
 	id: createMessage.id ?? generateId(),
 	role: createMessage.role ?? fallbackRole
 });
-const useAISDKRuntime = (chatHelpers, { adapters, toCreateMessage: customToCreateMessage, cancelPendingToolCallsOnSend = true, onResume, suggestions } = {}) => {
+const useAISDKRuntime = (chatHelpers, adapter = {}) => {
+	const { adapters, toCreateMessage: customToCreateMessage, cancelPendingToolCallsOnSend = true, onResume } = adapter;
 	const contextAdapters = useRuntimeAdapters();
 	const [toolStatuses, setToolStatuses] = useState({});
 	const toolArgsKeyOrderCacheRef = useRef(/* @__PURE__ */ new Map());
@@ -28,6 +29,8 @@ const useAISDKRuntime = (chatHelpers, { adapters, toCreateMessage: customToCreat
 	const hasExecutingTools = Object.values(toolStatuses).some((s) => s?.type === "executing");
 	const isRunning = chatHelpers.status === "submitted" || chatHelpers.status === "streaming" || hasExecutingTools;
 	const messageTiming = useStreamingTiming(chatHelpers.messages, isRunning);
+	const lastMessage = chatHelpers.messages.at(-1);
+	const optimisticMessageId = isRunning && lastMessage?.role === "assistant" ? lastMessage.id : void 0;
 	const messages = AISDKMessageConverter.useThreadMessages({
 		isRunning,
 		messages: chatHelpers.messages,
@@ -37,41 +40,23 @@ const useAISDKRuntime = (chatHelpers, { adapters, toCreateMessage: customToCreat
 			toolArgsKeyOrderCache: toolArgsKeyOrderCacheRef.current,
 			toolLastInputCache: toolLastInputCacheRef.current,
 			mcpAppMetadataCache: mcpAppMetadataCacheRef.current,
+			...optimisticMessageId && { optimisticMessageId },
 			...chatHelpers.error && { error: chatHelpers.error.message }
 		}), [
 			toolStatuses,
 			messageTiming,
+			optimisticMessageId,
 			chatHelpers.error
 		])
 	});
 	const [runtimeRef] = useState(() => ({ get current() {
 		return runtime;
 	} }));
-	const toolInvocations = useToolInvocations({
-		state: {
-			messages,
-			isRunning
-		},
-		getTools: () => runtimeRef.current.thread.getModelContext().tools,
-		onResult: (command) => {
-			if (command.type === "add-tool-result") {
-				const output = command.modelContent !== void 0 ? wrapModelContentEnvelope(command.result, command.modelContent) : command.result;
-				chatHelpers.addToolResult({
-					tool: command.toolName,
-					toolCallId: command.toolCallId,
-					output,
-					options: { metadata: lastRunConfigRef.current }
-				});
-			}
-		},
-		setToolStatuses
-	});
 	const isLoading = useExternalHistory(runtimeRef, adapters?.history ?? contextAdapters?.history, AISDKMessageConverter.toThreadMessages, aiSDKV6FormatAdapter, (messages) => {
 		chatHelpers.setMessages(messages);
 	});
 	const completePendingToolCalls = async () => {
 		if (!cancelPendingToolCallsOnSend) return;
-		await toolInvocations.abort();
 		chatHelpers.setMessages((messages) => {
 			const lastMessage = messages.at(-1);
 			if (lastMessage?.role !== "assistant") return messages;
@@ -96,6 +81,8 @@ const useAISDKRuntime = (chatHelpers, { adapters, toCreateMessage: customToCreat
 	const runtime = useExternalStoreRuntime({
 		isRunning,
 		messages,
+		unstable_enableToolInvocations: true,
+		setToolStatuses,
 		setMessages: (messages) => chatHelpers.setMessages(messages.map(getVercelAIMessages).filter(Boolean).flat()),
 		onImport: (messages) => chatHelpers.setMessages(messages.map(getVercelAIMessages).filter(Boolean).flat()),
 		onExportExternalState: () => {
@@ -124,7 +111,6 @@ const useAISDKRuntime = (chatHelpers, { adapters, toCreateMessage: customToCreat
 		},
 		onCancel: async () => {
 			chatHelpers.stop();
-			await toolInvocations.abort();
 		},
 		onNew: async (message) => {
 			const createMessage = (customToCreateMessage ?? toCreateMessage)(message);
@@ -152,24 +138,25 @@ const useAISDKRuntime = (chatHelpers, { adapters, toCreateMessage: customToCreat
 			chatHelpers.setMessages(newMessages);
 			await chatHelpers.regenerate({ metadata: config.runConfig });
 		},
-		onAddToolResult: ({ toolCallId, result, isError }) => {
+		onAddToolResult: ({ toolCallId, toolName, result, isError, modelContent }) => {
 			const options = { metadata: lastRunConfigRef.current };
 			if (isError) chatHelpers.addToolOutput({
 				state: "output-error",
-				tool: toolCallId,
+				tool: toolName ?? toolCallId,
 				toolCallId,
 				errorText: typeof result === "string" ? result : JSON.stringify(result),
 				options
 			});
-			else chatHelpers.addToolOutput({
-				state: "output-available",
-				tool: toolCallId,
-				toolCallId,
-				output: result,
-				options
-			});
+			else {
+				const output = modelContent !== void 0 ? wrapModelContentEnvelope(result, modelContent) : result;
+				chatHelpers.addToolResult({
+					tool: toolName,
+					toolCallId,
+					output,
+					options
+				});
+			}
 		},
-		onResumeToolCall: (options) => toolInvocations.resume(options.toolCallId, options.payload),
 		onRespondToToolApproval: ({ approvalId, approved, reason }) => {
 			chatHelpers.addToolApprovalResponse({
 				id: approvalId,
@@ -178,8 +165,8 @@ const useAISDKRuntime = (chatHelpers, { adapters, toCreateMessage: customToCreat
 				options: { metadata: lastRunConfigRef.current }
 			});
 		},
+		...pickExternalStoreSharedOptions(adapter),
 		...onResume && { onResume },
-		...suggestions && { suggestions },
 		adapters: {
 			attachments: vercelAttachmentAdapter,
 			...contextAdapters,