@jigs.design/ai-sdk 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tom Bates
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,45 @@
-# Temporary Holding Version
+# @jigs.design/ai-sdk
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Optional. Connects Pickle to the [AI SDK](https://ai-sdk.dev) in two ways:
+
+- `aiSdkModel(model, settings?)` is a `model` for `createPickleServer`. It passes the host's prompt as `instructions`, streams the text through `streamText`, and reports token usage to `onTurn`. It takes a gateway id such as `"anthropic/claude-sonnet-5.5"` or any provider's `LanguageModel`.
+- `pickleChat(pickle, { request, messages })` runs chat mode on a `useChat` conversation. The assistant answers in Markdown, and each fenced `pickle` block becomes a `data-pickle` part you draw with `PickleView`.
+
+```ts
+import { aiSdkModel } from "@jigs.design/ai-sdk";
+import { createPickleServer } from "@jigs.design/server";
+
+export const pickle = createPickleServer({
+	host,
+	context,
+	run,
+	model: aiSdkModel("anthropic/claude-sonnet-5.5", { temperature: 0.2 }),
+});
+```
+
+Import the root entry from server code. The browser imports `@jigs.design/ai-sdk/client`: `withoutPrograms`, `recentMessages` and the message types, with no server code and no Zod behind them.
+
+## Exports
+
+| Export                                       | What it is                                                                       |
+| -------------------------------------------- | -------------------------------------------------------------------------------- |
+| `aiSdkModel`, `ModelSettings`                | The model function and the `streamText` settings it applies to every call        |
+| `pickleChat`                                 | One chat turn: the system prompt, the history converter and the stream transform |
+| `pickleDataSchemas`                          | Schemas for `validateUIMessages`. They drop each pickle's `program`              |
+| `revivePickles`                              | Compiles a stored conversation's pickles again, typed from the messages passed   |
+| `withoutPrograms`                            | Strips programs from messages, for the request body and for storage              |
+| `recentMessages`                             | The recent turns of a long conversation, after every earlier pickle              |
+| `PickleUIMessage`, `PickleBlockData`         | Types for `useChat` and for one `data-pickle` part, generic over your metadata   |
+| `StoredPickleUIMessage`, `StoredPickleBlock` | The same without programs: what the server receives and what you store           |
+| `@jigs.design/ai-sdk/client`                 | The browser entry: `withoutPrograms`, `recentMessages` and the types             |
+
+## Source
+
+- `src/model.ts`: `aiSdkModel`.
+- `src/chat.ts`: chat mode on `useChat`.
+- `src/stored.ts`, `src/client.ts`: the message types, `withoutPrograms`, `recentMessages`, and the browser entry. No Zod here.
+- `src/schemas.ts`: `pickleDataSchemas`, server only.
+
+## Docs
+
+[AI SDK](../../apps/docs/docs/running/ai-sdk.mdx) and [Chat](../../apps/docs/docs/running/chat.mdx). [`examples/with-ai-chat`](../../examples/with-ai-chat) runs both.

package/dist/chat.d.ts

@@ -0,0 +1,58 @@
+import { PickleBlockData, PickleUIMessage, WithPickleBlocks } from "./stored.js";
+import { ChatTurn, PickleServer } from "@jigs.design/server";
+import { InferUIMessageChunk, UIMessage, UIMessageChunk } from "ai";
+//#region src/chat.d.ts
+export interface PickleChat {
+  /**
+   * For `convertToModelMessages(messages, { convertDataPart })`: writes each
+   * pickle back as the fenced block the model wrote, so it sees its UIs.
+   * Returns `undefined` for other data parts; chain your own after it.
+   */
+  convertDataPart: (part: {
+    data: unknown;
+    type: string;
+  }) => {
+    text: string;
+    type: "text";
+  } | undefined;
+  /** The chat-mode prompt for the server's host. Add your instructions to it. */
+  system: string;
+  /**
+   * The start of `system` that is the same on every turn. Pass both to
+   * `cachedInstructions` so the provider caches it.
+   */
+  systemPrefix: string;
+  /**
+   * Turns a UI message stream, e.g. `result.toUIMessageStream()`, into one
+   * where pickles are `data-pickle` parts. Prose stays in text parts, in the
+   * reply's order; a block's part updates in place as it streams and when it
+   * is repaired, and the stream finishes after every repair. Cancelling it
+   * stops the repairs. `TMessage` is the app's message type, for
+   * `createUIMessageStream`; its `pickle` data part must be a
+   * `PickleBlockData` or a `StoredPickleBlock`.
+   */
+  toUIMessageStream: <TMessage extends UIMessage = PickleUIMessage>(stream: ReadableStream<UIMessageChunk>) => ReadableStream<InferUIMessageChunk<TMessage>>;
+  /** The chat turn under it, for anything the stream transform does not cover. */
+  turn: ChatTurn;
+}
+/**
+ * Starts one chat reply on the AI SDK. Runs the server's `context` for
+ * `request` (a PickleError it throws rejects, as on a call) and reads the
+ * conversation's earlier pickles from `messages`, so edits and versions
+ * continue from them.
+ */
+export declare function pickleChat<TContext, TSpecName extends string>(pickle: PickleServer<TContext, TSpecName>, input: {
+  messages: ReadonlyArray<UIMessage>;
+  /** App options for the server's `options` schema, passed to repairs. */
+  options?: unknown;
+  request: Request;
+}): Promise<PickleChat>;
+/**
+ * Compiles the pickles of a stored conversation again, for showing it after
+ * a reload. Programs are rebuilt from each block's `source` here, never read
+ * back from storage. Other parts and the metadata pass through as they are,
+ * so a `StoredPickleUIMessage<Metadata>`, or the stored form of your own
+ * message type, comes back with `PickleBlockData` in its `data-pickle` parts.
+ */
+export declare function revivePickles<TMessage extends UIMessage>(pickle: Pick<PickleServer<unknown>, "compile">, messages: ReadonlyArray<TMessage>): Promise<Array<WithPickleBlocks<TMessage, PickleBlockData>>>;
+//#endregion

package/dist/chat.js

@@ -0,0 +1,223 @@
+import { storedBlock } from "./schemas.js";
+import { chatBlockText } from "@jigs.design/server";
+import { z } from "zod";
+//#region src/chat.ts
+const blockSource = z.object({
+	id: z.string(),
+	source: z.string()
+});
+/** The conversation's blocks, oldest first, read from its `data-pickle` parts. */
+function blocksIn(messages) {
+	const blocks = [];
+	for (const message of messages) {
+		if (message.role !== "assistant") continue;
+		for (const part of message.parts) {
+			if (part.type !== "data-pickle" || !("data" in part)) continue;
+			const parsed = blockSource.safeParse(part.data);
+			if (parsed.success) blocks.push(parsed.data);
+		}
+	}
+	return blocks;
+}
+/** The text of the last user message: what this reply answers, for repairs. */
+function lastPrompt(messages) {
+	const text = messages.findLast((entry) => entry.role === "user")?.parts.flatMap((part) => part.type === "text" ? [part.text] : []).join("\n");
+	return text === void 0 || text === "" ? void 0 : text;
+}
+/**
+* Starts one chat reply on the AI SDK. Runs the server's `context` for
+* `request` (a PickleError it throws rejects, as on a call) and reads the
+* conversation's earlier pickles from `messages`, so edits and versions
+* continue from them.
+*/
+async function pickleChat(pickle, input) {
+	const stop = new AbortController();
+	const turn = await pickle.chat(input.request, {
+		blocks: blocksIn(input.messages),
+		options: input.options,
+		prompt: lastPrompt(input.messages),
+		signal: AbortSignal.any([input.request.signal, stop.signal])
+	});
+	return {
+		convertDataPart: (part) => {
+			if (part.type !== "data-pickle") return;
+			const parsed = blockSource.safeParse(part.data);
+			return parsed.success ? {
+				text: chatBlockText(parsed.data),
+				type: "text"
+			} : void 0;
+		},
+		system: turn.system,
+		systemPrefix: turn.systemPrefix,
+		toUIMessageStream: (stream) => transform(turn, stream, stop),
+		turn
+	};
+}
+/** What a block that was still open says when its reply stops. */
+const STOPPED = {
+	code: "INTERNAL",
+	message: "The reply stopped before this pickle was finished."
+};
+function transform(turn, stream, stop) {
+	const reader = stream.getReader();
+	let closed = false;
+	return new ReadableStream({
+		async cancel(reason) {
+			closed = true;
+			stop.abort(reason);
+			await reader.cancel(reason);
+		},
+		async start(controller) {
+			const repairs = /* @__PURE__ */ new Set();
+			let open = null;
+			let replying = null;
+			let segment = 0;
+			const send = (chunk) => {
+				if (!closed) controller.enqueue(chunk);
+			};
+			const closeText = () => {
+				if (open !== null) {
+					send({
+						id: open,
+						type: "text-end"
+					});
+					open = null;
+				}
+			};
+			const sendBlock = (block) => {
+				send({
+					data: block,
+					id: block.key,
+					type: "data-pickle"
+				});
+			};
+			const repair = (block) => {
+				const task = (async () => {
+					try {
+						for await (const fixed of turn.repair(block)) sendBlock(fixed);
+					} catch {
+						sendBlock({
+							...block,
+							error: {
+								code: "INTERNAL",
+								message: "The repair failed."
+							},
+							status: "done"
+						});
+					}
+				})();
+				repairs.add(task);
+				task.finally(() => repairs.delete(task));
+			};
+			const handle = (events, base, stopped = false) => {
+				for (const event of events) if (event.type === "text") {
+					if (event.text === "") continue;
+					if (open === null) {
+						open = `${base}-${segment}`;
+						segment++;
+						send({
+							id: open,
+							type: "text-start"
+						});
+					}
+					send({
+						delta: event.text,
+						id: open,
+						type: "text-delta"
+					});
+				} else if (stopped) {
+					closeText();
+					sendBlock({
+						...event.block,
+						error: STOPPED,
+						status: "done"
+					});
+				} else {
+					closeText();
+					sendBlock(event.block);
+					if (event.block.status === "repairing") repair(event.block);
+				}
+			};
+			const cutShort = () => {
+				if (replying !== null) {
+					handle(turn.end(), replying, true);
+					replying = null;
+				}
+				closeText();
+			};
+			try {
+				for (;;) {
+					const step = await reader.read();
+					if (step.done) break;
+					const chunk = step.value;
+					switch (chunk.type) {
+						case "text-start":
+							replying = chunk.id;
+							break;
+						case "text-delta":
+							handle(turn.push(chunk.delta), chunk.id);
+							break;
+						case "text-end":
+							replying = null;
+							handle(turn.end(), chunk.id);
+							closeText();
+							break;
+						case "abort":
+						case "error":
+							cutShort();
+							send(chunk);
+							break;
+						case "finish":
+							closeText();
+							await Promise.all(repairs);
+							send(chunk);
+							break;
+						default: send(chunk);
+					}
+				}
+				cutShort();
+				await Promise.all(repairs);
+				if (!closed) {
+					closed = true;
+					controller.close();
+				}
+			} catch (error) {
+				if (!closed) {
+					cutShort();
+					closed = true;
+					controller.error(error);
+				}
+				stop.abort(error);
+			}
+		}
+	});
+}
+/**
+* Compiles the pickles of a stored conversation again, for showing it after
+* a reload. Programs are rebuilt from each block's `source` here, never read
+* back from storage. Other parts and the metadata pass through as they are,
+* so a `StoredPickleUIMessage<Metadata>`, or the stored form of your own
+* message type, comes back with `PickleBlockData` in its `data-pickle` parts.
+*/
+async function revivePickles(pickle, messages) {
+	return await Promise.all(messages.map(async (message) => ({
+		...message,
+		parts: await Promise.all(message.parts.map(async (part) => {
+			if (part.type !== "data-pickle" || !("data" in part)) return part;
+			const stored = storedBlock.parse(part.data);
+			const compiled = await pickle.compile(stored.source, { strict: false });
+			const data = {
+				...stored,
+				diagnostics: compiled.diagnostics,
+				program: compiled.program,
+				status: "done"
+			};
+			return {
+				...part,
+				data
+			};
+		}))
+	})));
+}
+//#endregion
+export { pickleChat, revivePickles };

package/dist/client.d.ts

@@ -0,0 +1,2 @@
+import { PickleBlockData, PickleDataTypes, PickleUIMessage, StoredPickleBlock, StoredPickleUIMessage, recentMessages, withoutPrograms } from "./stored.js";
+export { type PickleBlockData, type PickleDataTypes, type PickleUIMessage, type StoredPickleBlock, type StoredPickleUIMessage, recentMessages, withoutPrograms };

package/dist/client.js

@@ -0,0 +1 @@
+export { recentMessages, withoutPrograms } from "./stored.js";

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import { PickleBlockData, PickleDataTypes, PickleUIMessage, StoredPickleBlock, StoredPickleUIMessage, recentMessages, withoutPrograms } from "./stored.js";
+import { PickleChat, pickleChat, revivePickles } from "./chat.js";
+import { ModelSettings, aiSdkModel, cachedInstructions } from "./model.js";
+import { pickleDataSchemas } from "./schemas.js";
+export { type ModelSettings, type PickleBlockData, type PickleChat, type PickleDataTypes, type PickleUIMessage, type StoredPickleBlock, type StoredPickleUIMessage, aiSdkModel, cachedInstructions, pickleChat, pickleDataSchemas, recentMessages, revivePickles, withoutPrograms };

package/dist/index.js

@@ -0,0 +1,5 @@
+import { pickleDataSchemas } from "./schemas.js";
+import { pickleChat, revivePickles } from "./chat.js";
+import { aiSdkModel, cachedInstructions } from "./model.js";
+import { recentMessages, withoutPrograms } from "./stored.js";
+export { aiSdkModel, cachedInstructions, pickleChat, pickleDataSchemas, recentMessages, revivePickles, withoutPrograms };

package/dist/model.d.ts

@@ -0,0 +1,21 @@
+import { ModelFunction } from "@jigs.design/server";
+import { Instructions, LanguageModel, streamText } from "ai";
+//#region src/model.d.ts
+/** `streamText` settings that apply to every call, such as `temperature`. */
+export type ModelSettings = Omit<Parameters<typeof streamText>[0], "abortSignal" | "instructions" | "messages" | "model" | "prompt" | "system">;
+/**
+ * `system` as instructions whose first part, `prefix`, a provider may cache:
+ * two system messages, the first marked as a cache breakpoint for providers
+ * that need one (Anthropic). Providers that cache a repeated prefix on their
+ * own (OpenAI, DeepSeek, Google) read the two as one. Without a prefix that
+ * `system` starts with, `system` alone.
+ */
+export declare function cachedInstructions(system: string, prefix: string): Instructions;
+/**
+ * A `model` for `createPickleServer` from an AI SDK model: document-mode
+ * sessions and chat repairs stream through `streamText`, and token usage
+ * reaches `onTurn`. The prompt's stable start is marked for the provider's
+ * cache (`cachedInstructions`).
+ */
+export declare function aiSdkModel(model: LanguageModel, settings?: ModelSettings): ModelFunction<unknown, unknown>;
+//#endregion

package/dist/model.js

@@ -0,0 +1,53 @@
+import { streamText } from "ai";
+//#region src/model.ts
+/**
+* `system` as instructions whose first part, `prefix`, a provider may cache:
+* two system messages, the first marked as a cache breakpoint for providers
+* that need one (Anthropic). Providers that cache a repeated prefix on their
+* own (OpenAI, DeepSeek, Google) read the two as one. Without a prefix that
+* `system` starts with, `system` alone.
+*/
+function cachedInstructions(system, prefix) {
+	if (prefix === "" || !system.startsWith(prefix)) return system;
+	return [{
+		content: prefix,
+		providerOptions: { anthropic: { cacheControl: { type: "ephemeral" } } },
+		role: "system"
+	}, {
+		content: system.slice(prefix.length),
+		role: "system"
+	}];
+}
+/**
+* A `model` for `createPickleServer` from an AI SDK model: document-mode
+* sessions and chat repairs stream through `streamText`, and token usage
+* reaches `onTurn`. The prompt's stable start is marked for the provider's
+* cache (`cachedInstructions`).
+*/
+function aiSdkModel(model, settings = {}) {
+	return async function* (request) {
+		const result = streamText({
+			...settings,
+			abortSignal: request.signal,
+			instructions: cachedInstructions(request.system, request.systemPrefix),
+			messages: request.messages.map((message) => ({
+				content: message.content,
+				role: message.role
+			})),
+			model
+		});
+		for await (const part of result.stream) if (part.type === "text-delta") yield part.text;
+		else if (part.type === "error") throw part.error;
+		const usage = await result.usage;
+		const sent = {
+			inputTokens: usage.inputTokens ?? 0,
+			outputTokens: usage.outputTokens ?? 0
+		};
+		const details = usage.inputTokenDetails;
+		if (details.cacheReadTokens !== void 0) sent.cacheReadTokens = details.cacheReadTokens;
+		if (details.cacheWriteTokens !== void 0) sent.cacheWriteTokens = details.cacheWriteTokens;
+		return { usage: sent };
+	};
+}
+//#endregion
+export { aiSdkModel, cachedInstructions };

package/dist/schemas.d.ts

@@ -0,0 +1,66 @@
+import { z } from "zod";
+//#region src/schemas.d.ts
+/**
+ * Schemas for `validateUIMessages<StoredPickleUIMessage>({ messages,
+ * dataSchemas })`, to check a conversation the browser sent or one read
+ * from storage. A pickle's program is dropped, never checked: the server
+ * reads only `id` and `source`, and a source is only ever compiled.
+ */
+export declare const pickleDataSchemas: {
+  pickle: z.ZodObject<{
+    diagnostics: z.ZodArray<z.ZodObject<{
+      code: z.ZodString;
+      fix: z.ZodExactOptional<z.ZodObject<{
+        edits: z.ZodArray<z.ZodObject<{
+          span: z.ZodObject<{
+            column: z.ZodExactOptional<z.ZodNumber>;
+            end: z.ZodExactOptional<z.ZodNumber>;
+            line: z.ZodNumber;
+            start: z.ZodExactOptional<z.ZodNumber>;
+          }, z.core.$strip>;
+          text: z.ZodString;
+        }, z.core.$strip>>;
+        title: z.ZodString;
+      }, z.core.$strip>>;
+      message: z.ZodString;
+      severity: z.ZodEnum<{
+        error: "error";
+        hint: "hint";
+        info: "info";
+        warning: "warning";
+      }>;
+      span: z.ZodObject<{
+        column: z.ZodExactOptional<z.ZodNumber>;
+        end: z.ZodExactOptional<z.ZodNumber>;
+        line: z.ZodNumber;
+        start: z.ZodExactOptional<z.ZodNumber>;
+      }, z.core.$strip>;
+    }, z.core.$strip>>;
+    error: z.ZodExactOptional<z.ZodObject<{
+      code: z.ZodEnum<{
+        BAD_INPUT: "BAD_INPUT";
+        CONFLICT: "CONFLICT";
+        DECLINED: "DECLINED";
+        FORBIDDEN: "FORBIDDEN";
+        INTERNAL: "INTERNAL";
+        NETWORK: "NETWORK";
+        NOT_FOUND: "NOT_FOUND";
+        RATE_LIMITED: "RATE_LIMITED";
+        UNAUTHORIZED: "UNAUTHORIZED";
+        UNAVAILABLE: "UNAVAILABLE";
+        UNKNOWN_PROCEDURE: "UNKNOWN_PROCEDURE";
+      }>;
+      message: z.ZodString;
+    }, z.core.$strip>>;
+    id: z.ZodString;
+    key: z.ZodString;
+    source: z.ZodString;
+    status: z.ZodEnum<{
+      done: "done";
+      repairing: "repairing";
+      streaming: "streaming";
+    }>;
+    version: z.ZodNumber;
+  }, z.core.$strip>;
+};
+//#endregion

package/dist/schemas.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import { pickleErrorCodes } from "@jigs.design/runtime";
+//#region src/schemas.ts
+const span = z.object({
+	column: z.number().exactOptional(),
+	end: z.number().exactOptional(),
+	line: z.number(),
+	start: z.number().exactOptional()
+});
+const storedBlock = z.object({
+	diagnostics: z.array(z.object({
+		code: z.string(),
+		fix: z.object({
+			edits: z.array(z.object({
+				span,
+				text: z.string()
+			})),
+			title: z.string()
+		}).exactOptional(),
+		message: z.string(),
+		severity: z.enum([
+			"error",
+			"hint",
+			"info",
+			"warning"
+		]),
+		span
+	})),
+	error: z.object({
+		code: z.enum(pickleErrorCodes),
+		message: z.string()
+	}).exactOptional(),
+	id: z.string(),
+	key: z.string(),
+	source: z.string(),
+	status: z.enum([
+		"streaming",
+		"repairing",
+		"done"
+	]),
+	version: z.number()
+});
+/**
+* Schemas for `validateUIMessages<StoredPickleUIMessage>({ messages,
+* dataSchemas })`, to check a conversation the browser sent or one read
+* from storage. A pickle's program is dropped, never checked: the server
+* reads only `id` and `source`, and a source is only ever compiled.
+*/
+const pickleDataSchemas = { pickle: storedBlock };
+//#endregion
+export { pickleDataSchemas, storedBlock };

package/dist/stored.d.ts

@@ -0,0 +1,58 @@
+import { ChatBlock } from "@jigs.design/runtime";
+import { UIMessage } from "ai";
+//#region src/stored.d.ts
+/** A pickle's `data-pickle` part: one fenced block of a reply, compiled. */
+export type PickleBlockData = ChatBlock;
+/**
+ * A pickle as the browser sends it back and as you store it: everything but
+ * the program. Only `revivePickles` turns it back into a `PickleBlockData`,
+ * by compiling `source` again.
+ */
+export type StoredPickleBlock = Omit<PickleBlockData, "program">;
+/**
+ * The data parts chat mode adds to a message. A type, not an interface: the
+ * AI SDK's data types need an implicit index signature.
+ */
+export type PickleDataTypes = {
+  pickle: PickleBlockData;
+};
+/** A `useChat` message whose replies may hold pickles. */
+export type PickleUIMessage<TMetadata = unknown> = UIMessage<TMetadata, PickleDataTypes>;
+/**
+ * A conversation as the server receives it and as you store it: its pickles
+ * carry no programs. `validateUIMessages` with `pickleDataSchemas` returns
+ * this shape.
+ */
+export type StoredPickleUIMessage<TMetadata = unknown> = UIMessage<TMetadata, {
+  pickle: StoredPickleBlock;
+}>;
+/** A message part, with a `data-pickle` part's data replaced by `TBlock`. */
+type WithBlock<TPart, TBlock> = TPart extends {
+  type: "data-pickle";
+} ? Omit<TPart, "data"> & {
+  data: TBlock;
+} : TPart;
+/**
+ * `TMessage` with each pickle's data replaced by `TBlock`, and every other
+ * part, the metadata included, as it was.
+ */
+export type WithPickleBlocks<TMessage extends UIMessage, TBlock> = Omit<TMessage, "parts"> & {
+  parts: Array<WithBlock<TMessage["parts"][number], TBlock>>;
+};
+/**
+ * The messages without their pickles' programs: for the body `useChat`
+ * posts (`prepareSendMessagesRequest`), and for storing a conversation. The
+ * server reads only each block's `id` and `source`. Every other part, and
+ * every other field of a block, is kept as it is.
+ */
+export declare function withoutPrograms<TMessage extends UIMessage>(messages: ReadonlyArray<TMessage>): Array<WithPickleBlocks<TMessage, StoredPickleBlock>>;
+/**
+ * The end of a long conversation, for the body `useChat` posts: the last
+ * `keep` messages, from a user message on. Every earlier pickle comes first,
+ * in one assistant message of their `data-pickle` parts, so the model still
+ * sees each one and edits and versions continue from them; earlier prose is
+ * left out. A conversation no longer than `keep` is returned as it is.
+ */
+export declare function recentMessages<TMessage extends UIMessage>(messages: ReadonlyArray<TMessage>, keep?: number): Array<TMessage>;
+//#endregion
+export {};

package/dist/stored.js

@@ -0,0 +1,50 @@
+//#region src/stored.ts
+/** Whether `part` is a pickle whose block still holds its program. */
+function hasProgram(part) {
+	return part.type === "data-pickle" && "data" in part && typeof part.data === "object" && part.data !== null && "program" in part.data;
+}
+/**
+* The messages without their pickles' programs: for the body `useChat`
+* posts (`prepareSendMessagesRequest`), and for storing a conversation. The
+* server reads only each block's `id` and `source`. Every other part, and
+* every other field of a block, is kept as it is.
+*/
+function withoutPrograms(messages) {
+	return messages.map((message) => ({
+		...message,
+		parts: message.parts.map((part) => {
+			if (!hasProgram(part)) return part;
+			const { program: _program, ...data } = part.data;
+			return {
+				...part,
+				data
+			};
+		})
+	}));
+}
+/** How many messages `recentMessages` keeps by default. */
+const RECENT = 20;
+/**
+* The end of a long conversation, for the body `useChat` posts: the last
+* `keep` messages, from a user message on. Every earlier pickle comes first,
+* in one assistant message of their `data-pickle` parts, so the model still
+* sees each one and edits and versions continue from them; earlier prose is
+* left out. A conversation no longer than `keep` is returned as it is.
+*/
+function recentMessages(messages, keep = RECENT) {
+	if (messages.length <= keep) return [...messages];
+	let start = messages.length - keep;
+	const nextUser = messages.findIndex((message, index) => index >= start && message.role === "user");
+	if (nextUser !== -1) start = nextUser;
+	const earlier = messages.slice(0, start).filter((message) => message.role === "assistant");
+	const pickles = earlier.flatMap((message) => message.parts.filter((part) => part.type === "data-pickle"));
+	const recent = messages.slice(start);
+	const [first] = earlier;
+	if (first === void 0 || pickles.length === 0) return recent;
+	return [{
+		...first,
+		parts: pickles
+	}, ...recent];
+}
+//#endregion
+export { recentMessages, withoutPrograms };

package/package.json

@@ -1,6 +1,46 @@
 {
   "name": "@jigs.design/ai-sdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.1",
+  "description": "Pickle on the AI SDK: a model function for createPickleServer, and chat mode for useChat.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yoamomonstruos/pickle.git",
+    "directory": "packages/ai-sdk"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "import": "./dist/client.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@jigs.design/runtime": "0.1.1",
+    "@jigs.design/server": "0.1.1"
+  },
+  "peerDependencies": {
+    "ai": "^7.0.0",
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "@ai-sdk/provider": "4.0.27",
+    "ai": "7.0.140",
+    "zod": "4.6.7",
+    "@jigs.design/host": "0.1.1",
+    "@jigs.design/catalog": "0.1.1"
+  }
 }