@jigs.design/ai-sdk 0.3.0 → 0.3.2

package/dist/chat.js

@@ -204,7 +204,7 @@ async function reviveJigs(jigs, messages) {
 		...message,
 		parts: await Promise.all(message.parts.map(async (part) => {
 			if (part.type !== "data-jigs" || !("data" in part)) return part;
-			const stored = storedBlock.parse(part.data);
+			const { toolKeys: _stored, ...stored } = storedBlock.parse(part.data);
 			const compiled = await jigs.compile(stored.source, { strict: false });
 			const data = {
 				...stored,
@@ -212,6 +212,7 @@ async function reviveJigs(jigs, messages) {
 				program: compiled.program,
 				status: "done"
 			};
+			if (compiled.toolKeys !== void 0) data.toolKeys = compiled.toolKeys;
 			return {
 				...part,
 				data

package/dist/client.d.ts

@@ -1,2 +1,3 @@
 import { JigsBlockData, JigsDataTypes, JigsUIMessage, StoredJigsBlock, StoredJigsUIMessage, recentMessages, withoutPrograms } from "./stored.js";
-export { type JigsBlockData, type JigsDataTypes, type JigsUIMessage, type StoredJigsBlock, type StoredJigsUIMessage, recentMessages, withoutPrograms };
+import { ToolDataOptions, ToolPart, toolData, toolValue } from "./tool-data.js";
+export { type JigsBlockData, type JigsDataTypes, type JigsUIMessage, type StoredJigsBlock, type StoredJigsUIMessage, type ToolDataOptions, type ToolPart, recentMessages, toolData, toolValue, withoutPrograms };

package/dist/client.js

@@ -1 +1,3 @@
-export { recentMessages, withoutPrograms } from "./stored.js";
+import { recentMessages, withoutPrograms } from "./stored.js";
+import { toolData, toolValue } from "./tool-data.js";
+export { recentMessages, toolData, toolValue, withoutPrograms };

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import { JigsBlockData, JigsDataTypes, JigsUIMessage, StoredJigsBlock, StoredJigsUIMessage, recentMessages, withoutPrograms } from "./stored.js";
+import { ToolDataOptions, ToolPart, toolData, toolValue } from "./tool-data.js";
 import { JigsChat, jigsChat, reviveJigs } from "./chat.js";
 import { ModelSettings, aiSdkModel, cachedInstructions } from "./model.js";
 import { jigsDataSchemas } from "./schemas.js";
-export { type JigsBlockData, type JigsChat, type JigsDataTypes, type JigsUIMessage, type ModelSettings, type StoredJigsBlock, type StoredJigsUIMessage, aiSdkModel, cachedInstructions, jigsChat, jigsDataSchemas, recentMessages, reviveJigs, withoutPrograms };
+export { type JigsBlockData, type JigsChat, type JigsDataTypes, type JigsUIMessage, type ModelSettings, type StoredJigsBlock, type StoredJigsUIMessage, type ToolDataOptions, type ToolPart, aiSdkModel, cachedInstructions, jigsChat, jigsDataSchemas, recentMessages, reviveJigs, toolData, toolValue, withoutPrograms };

package/dist/index.js

@@ -2,4 +2,5 @@ import { jigsDataSchemas } from "./schemas.js";
 import { jigsChat, reviveJigs } from "./chat.js";
 import { aiSdkModel, cachedInstructions } from "./model.js";
 import { recentMessages, withoutPrograms } from "./stored.js";
-export { aiSdkModel, cachedInstructions, jigsChat, jigsDataSchemas, recentMessages, reviveJigs, withoutPrograms };
+import { toolData, toolValue } from "./tool-data.js";
+export { aiSdkModel, cachedInstructions, jigsChat, jigsDataSchemas, recentMessages, reviveJigs, toolData, toolValue, withoutPrograms };

package/dist/schemas.d.ts

@@ -63,6 +63,7 @@ export declare const jigsDataSchemas: {
       repairing: "repairing";
       streaming: "streaming";
     }>;
+    toolKeys: z.ZodExactOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodLiteral<"all">]>>;
     version: z.ZodNumber;
   }, z.core.$strip>;
 };

package/dist/schemas.js

@@ -41,6 +41,7 @@ const storedBlock = z.object({
 		"repairing",
 		"done"
 	]),
+	toolKeys: z.union([z.array(z.string()), z.literal("all")]).exactOptional(),
 	version: z.number()
 });
 /**

package/dist/tool-data.d.ts

@@ -0,0 +1,48 @@
+import { JsonValue } from "@jigs.design/protocol";
+import { DynamicToolUIPart, ToolUIPart, UIMessage } from "ai";
+//#region src/tool-data.d.ts
+/** A tool call in a message: a `tool-<name>` part, or a `dynamic-tool` one. */
+export type ToolPart = DynamicToolUIPart | ToolUIPart;
+type JsonObject = {
+  readonly [key: string]: JsonValue;
+};
+/**
+ * A tool part's output as a block reads it: what the model was shown, as
+ * JSON. Undefined for no value: a call not finished (a preliminary output
+ * too, which the model never sees), one that failed or was refused, an MCP
+ * result with `isError`, or an output over 32 KB of JSON. An output is read
+ * as JSON, as it crossed the wire. A tool from an MCP client
+ * (`toolMetadata.clientName`, which `@ai-sdk/mcp` sets) is read as
+ * `mcpToModelOutput` shows it: its structured content, else its text parts,
+ * parsed when there is one and it is JSON.
+ */
+export declare function toolValue(part: ToolPart): JsonValue | undefined;
+export interface ToolDataOptions {
+  /**
+   * A tool's value for a block instead of `toolValue`'s, for an app tool
+   * whose `toModelOutput` shows the model a different shape from its
+   * output; undefined for no value. Keep the same function for a page:
+   * results are reused by it.
+   */
+  value?: (toolName: string, part: ToolPart) => JsonValue | undefined;
+}
+/**
+ * Each jig's provided data from the tool calls of the conversation, by
+ * block key, for `JigsView`'s `data` on a server with `toolResults: true`:
+ * `<JigsView data={{ ...hostData, ...tools.get(block.key) }} … />`. Only a
+ * block that reads the slot (`ChatBlock.toolKeys`) has an entry, cut to the
+ * tools it reads.
+ *
+ * A block version reads, for each tool: the latest value before it in the
+ * reply that wrote it; else its previous version's value; else the latest
+ * value earlier in the conversation. A failed or refused call in that reply
+ * removes the tool's entry, so the block shows its empty state rather than
+ * an older result. A tool called twice in one step leaves the last result.
+ * While a block's results are the same, it gets the same object, so the view
+ * does not compare them again.
+ */
+export declare function toolData<TMessage extends UIMessage>(messages: ReadonlyArray<TMessage>, options?: ToolDataOptions): ReadonlyMap<string, {
+  toolResults: JsonObject;
+}>;
+//#endregion
+export {};

package/dist/tool-data.js

@@ -0,0 +1,172 @@
+//#region src/tool-data.ts
+/** The most JSON one tool's value may take before a block gets none of it. */
+const MAX_VALUE_CHARS = 32768;
+function isList(value) {
+	return Array.isArray(value);
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null && !isList(value);
+}
+function isText(value) {
+	return typeof value === "string";
+}
+/** JSON text read back; the caller made it, so it is JSON. */
+function parsed(text) {
+	return JSON.parse(text);
+}
+/** The tool a part called, or null for a part that is not a tool call. */
+function toolNameOf(part) {
+	if (part.type === "dynamic-tool") return part.toolName;
+	return part.type.startsWith("tool-") ? part.type.slice(5) : null;
+}
+function isToolPart(part) {
+	return toolNameOf(part) !== null && "state" in part;
+}
+/** A block's `data-jigs` part, with its data as `jigsChat` sent it. */
+function isBlockPart(part) {
+	return part.type === "data-jigs" && "data" in part && typeof part.data === "object" && part.data !== null && "key" in part.data && "name" in part.data;
+}
+/** What `mcpToModelOutput` (`@ai-sdk/mcp`) shows the model of one content part. */
+function contentText(part) {
+	if (!isObject(part)) return null;
+	if (part.type === "text" && isText(part.text)) return part.text;
+	return part.type === "image" ? null : JSON.stringify(part);
+}
+/** An MCP tool's `CallToolResult` as the model was shown it. */
+function mcpValue(output) {
+	if (!isObject(output) || output.isError === true) return;
+	const structured = output.structuredContent;
+	if (structured !== void 0) return structured;
+	const content = output.content;
+	if (content === void 0 || !isList(content)) return output;
+	const texts = content.flatMap((part) => {
+		const text = contentText(part);
+		return text === null ? [] : [text];
+	});
+	const [only] = texts;
+	if (texts.length === 1 && only !== void 0) try {
+		return parsed(only);
+	} catch {
+		return only;
+	}
+	return texts.length === 0 ? void 0 : texts.join("\n");
+}
+/** Values already worked out, by part; null for none. */
+const values = /* @__PURE__ */ new WeakMap();
+/**
+* A tool part's output as a block reads it: what the model was shown, as
+* JSON. Undefined for no value: a call not finished (a preliminary output
+* too, which the model never sees), one that failed or was refused, an MCP
+* result with `isError`, or an output over 32 KB of JSON. An output is read
+* as JSON, as it crossed the wire. A tool from an MCP client
+* (`toolMetadata.clientName`, which `@ai-sdk/mcp` sets) is read as
+* `mcpToModelOutput` shows it: its structured content, else its text parts,
+* parsed when there is one and it is JSON.
+*/
+function toolValue(part) {
+	if (part.state !== "output-available" || part.preliminary === true) return;
+	const known = values.get(part);
+	if (known !== void 0) return known ?? void 0;
+	const text = JSON.stringify(part.output);
+	let value;
+	if (text !== void 0 && text.length <= MAX_VALUE_CHARS) {
+		const output = parsed(text);
+		value = part.toolMetadata?.clientName === void 0 ? output : mcpValue(output);
+	}
+	values.set(part, value ?? null);
+	return value;
+}
+/** What a finished tool part does to a snapshot: sets its tool's value, or removes it. */
+function apply(snapshot, part, value) {
+	const name = toolNameOf(part) ?? "";
+	if (value === void 0) snapshot.delete(name);
+	else snapshot.set(name, {
+		id: `${part.toolCallId}:${part.state}`,
+		value
+	});
+}
+/** Whether a part settles its tool's value: a final output, an error or a refusal. */
+const settles = (part) => part.state === "output-available" && part.preliminary !== true || part.state === "output-error" || part.state === "output-denied";
+/** `snapshot` cut to `keys`, as the record a block reads. */
+function project(snapshot, keys) {
+	const names = (keys === "all" ? [...snapshot.keys()] : keys).toSorted();
+	const record = {};
+	const ids = [];
+	for (const name of names) {
+		const entry = snapshot.get(name);
+		if (entry !== void 0) {
+			record[name] = entry.value;
+			ids.push(`${name}=${entry.id}`);
+		}
+	}
+	return {
+		fingerprint: ids.join("\n"),
+		record
+	};
+}
+/** A block's results as last passed, by its block data, for each `value` function. */
+const remembered = /* @__PURE__ */ new WeakMap();
+const DEFAULT_VALUE = {};
+/**
+* Each jig's provided data from the tool calls of the conversation, by
+* block key, for `JigsView`'s `data` on a server with `toolResults: true`:
+* `<JigsView data={{ ...hostData, ...tools.get(block.key) }} … />`. Only a
+* block that reads the slot (`ChatBlock.toolKeys`) has an entry, cut to the
+* tools it reads.
+*
+* A block version reads, for each tool: the latest value before it in the
+* reply that wrote it; else its previous version's value; else the latest
+* value earlier in the conversation. A failed or refused call in that reply
+* removes the tool's entry, so the block shows its empty state rather than
+* an older result. A tool called twice in one step leaves the last result.
+* While a block's results are the same, it gets the same object, so the view
+* does not compare them again.
+*/
+function toolData(messages, options = {}) {
+	const valueOf = options.value;
+	const bucket = valueOf ?? DEFAULT_VALUE;
+	const cache = remembered.get(bucket) ?? /* @__PURE__ */ new WeakMap();
+	remembered.set(bucket, cache);
+	const result = /* @__PURE__ */ new Map();
+	const conversation = /* @__PURE__ */ new Map();
+	const versions = /* @__PURE__ */ new Map();
+	for (const message of messages) {
+		const before = new Map(conversation);
+		/** The settled tool calls of this message so far, in order. */
+		const settled = [];
+		for (const part of message.parts) {
+			if (isToolPart(part)) {
+				if (settles(part)) {
+					const value = valueOf === void 0 ? toolValue(part) : valueOf(toolNameOf(part) ?? "", part);
+					settled.push({
+						part,
+						value
+					});
+				}
+				continue;
+			}
+			if (!isBlockPart(part)) continue;
+			const block = part.data;
+			const snapshot = new Map(versions.get(block.name) ?? before);
+			for (const entry of settled) apply(snapshot, entry.part, entry.value);
+			versions.set(block.name, snapshot);
+			if (block.toolKeys === void 0) continue;
+			const projected = project(snapshot, block.toolKeys);
+			const known = cache.get(block);
+			if (known !== void 0 && known.fingerprint === projected.fingerprint) {
+				result.set(block.key, known.data);
+				continue;
+			}
+			const data = { toolResults: projected.record };
+			cache.set(block, {
+				...projected,
+				data
+			});
+			result.set(block.key, data);
+		}
+		for (const entry of settled) apply(conversation, entry.part, entry.value);
+	}
+	return result;
+}
+//#endregion
+export { toolData, toolValue };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jigs.design/ai-sdk",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Jigs on the AI SDK: a model function for createJigsServer, and chat mode for useChat.",
   "license": "MIT",
   "repository": {
@@ -29,8 +29,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@jigs.design/protocol": "0.3.0",
-    "@jigs.design/server": "0.3.0"
+    "@jigs.design/protocol": "0.3.2",
+    "@jigs.design/server": "0.3.2"
   },
   "peerDependencies": {
     "ai": "^7.0.0",
@@ -40,7 +40,7 @@
     "@ai-sdk/provider": "4.0.27",
     "ai": "7.0.140",
     "zod": "4.6.7",
-    "@jigs.design/catalog": "0.3.0",
-    "@jigs.design/host": "0.3.0"
+    "@jigs.design/catalog": "0.3.2",
+    "@jigs.design/host": "0.3.2"
   }
 }