@jigs.design/ai-sdk 0.1.1 → 0.2.0

package/README.md

@@ -1,15 +1,15 @@
 # @jigs.design/ai-sdk
 
-Optional. Connects Pickle to the [AI SDK](https://ai-sdk.dev) in two ways:
+Optional. Connects Jigs 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`.
+- `aiSdkModel(model, settings?)` is a `model` for `createJigsServer`. 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`.
+- `jigsChat(jigs, { request, messages })` runs chat mode on a `useChat` conversation. The assistant answers in Markdown, and each fenced `jigs` block becomes a `data-jigs` part you draw with `JigsView`.
 
 ```ts
 import { aiSdkModel } from "@jigs.design/ai-sdk";
-import { createPickleServer } from "@jigs.design/server";
+import { createJigsServer } from "@jigs.design/server";
 
-export const pickle = createPickleServer({
+export const jigs = createJigsServer({
 	host,
 	context,
 	run,
@@ -21,24 +21,24 @@ Import the root entry from server code. The browser imports `@jigs.design/ai-sdk
 
 ## 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             |
+| Export                                   | What it is                                                                       |
+| ---------------------------------------- | -------------------------------------------------------------------------------- |
+| `aiSdkModel`, `ModelSettings`            | The model function and the `streamText` settings it applies to every call        |
+| `jigsChat`                               | One chat turn: the system prompt, the history converter and the stream transform |
+| `jigsDataSchemas`                        | Schemas for `validateUIMessages`. They drop each jig's `program`                 |
+| `reviveJigs`                             | Compiles a stored conversation's jigs 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 jig                 |
+| `JigsUIMessage`, `JigsBlockData`         | Types for `useChat` and for one `data-jigs` part, generic over your metadata     |
+| `StoredJigsUIMessage`, `StoredJigsBlock` | 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.
+- `src/schemas.ts`: `jigsDataSchemas`, server only.
 
 ## Docs
 

package/dist/chat.d.ts

@@ -1,11 +1,11 @@
-import { PickleBlockData, PickleUIMessage, WithPickleBlocks } from "./stored.js";
-import { ChatTurn, PickleServer } from "@jigs.design/server";
+import { JigsBlockData, JigsUIMessage, WithJigsBlocks } from "./stored.js";
+import { ChatTurn, JigsServer } from "@jigs.design/server";
 import { InferUIMessageChunk, UIMessage, UIMessageChunk } from "ai";
 //#region src/chat.d.ts
-export interface PickleChat {
+export interface JigsChat {
   /**
    * For `convertToModelMessages(messages, { convertDataPart })`: writes each
-   * pickle back as the fenced block the model wrote, so it sees its UIs.
+   * jigs 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: {
@@ -24,35 +24,35 @@ export interface PickleChat {
   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
+   * where jigs are `data-jigs` 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`.
+   * `createUIMessageStream`; its `jigs` data part must be a
+   * `JigsBlockData` or a `StoredJigsBlock`.
    */
-  toUIMessageStream: <TMessage extends UIMessage = PickleUIMessage>(stream: ReadableStream<UIMessageChunk>) => ReadableStream<InferUIMessageChunk<TMessage>>;
+  toUIMessageStream: <TMessage extends UIMessage = JigsUIMessage>(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
+ * `request` (a JigsError it throws rejects, as on a call) and reads the
+ * conversation's earlier jigs from `messages`, so edits and versions
  * continue from them.
  */
-export declare function pickleChat<TContext, TSpecName extends string>(pickle: PickleServer<TContext, TSpecName>, input: {
+export declare function jigsChat<TContext, TSpecName extends string>(jigs: JigsServer<TContext, TSpecName>, input: {
   messages: ReadonlyArray<UIMessage>;
   /** App options for the server's `options` schema, passed to repairs. */
   options?: unknown;
   request: Request;
-}): Promise<PickleChat>;
+}): Promise<JigsChat>;
 /**
- * Compiles the pickles of a stored conversation again, for showing it after
+ * Compiles the jigs 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.
+ * so a `StoredJigsUIMessage<Metadata>`, or the stored form of your own
+ * message type, comes back with `JigsBlockData` in its `data-jigs` parts.
  */
-export declare function revivePickles<TMessage extends UIMessage>(pickle: Pick<PickleServer<unknown>, "compile">, messages: ReadonlyArray<TMessage>): Promise<Array<WithPickleBlocks<TMessage, PickleBlockData>>>;
+export declare function reviveJigs<TMessage extends UIMessage>(jigs: Pick<JigsServer<unknown>, "compile">, messages: ReadonlyArray<TMessage>): Promise<Array<WithJigsBlocks<TMessage, JigsBlockData>>>;
 //#endregion

package/dist/chat.js

@@ -6,13 +6,13 @@ const blockSource = z.object({
 	id: z.string(),
 	source: z.string()
 });
-/** The conversation's blocks, oldest first, read from its `data-pickle` parts. */
+/** The conversation's blocks, oldest first, read from its `data-jigs` 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;
+			if (part.type !== "data-jigs" || !("data" in part)) continue;
 			const parsed = blockSource.safeParse(part.data);
 			if (parsed.success) blocks.push(parsed.data);
 		}
@@ -26,13 +26,13 @@ function lastPrompt(messages) {
 }
 /**
 * 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
+* `request` (a JigsError it throws rejects, as on a call) and reads the
+* conversation's earlier jigs from `messages`, so edits and versions
 * continue from them.
 */
-async function pickleChat(pickle, input) {
+async function jigsChat(jigs, input) {
 	const stop = new AbortController();
-	const turn = await pickle.chat(input.request, {
+	const turn = await jigs.chat(input.request, {
 		blocks: blocksIn(input.messages),
 		options: input.options,
 		prompt: lastPrompt(input.messages),
@@ -40,7 +40,7 @@ async function pickleChat(pickle, input) {
 	});
 	return {
 		convertDataPart: (part) => {
-			if (part.type !== "data-pickle") return;
+			if (part.type !== "data-jigs") return;
 			const parsed = blockSource.safeParse(part.data);
 			return parsed.success ? {
 				text: chatBlockText(parsed.data),
@@ -56,7 +56,7 @@ async function pickleChat(pickle, input) {
 /** 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."
+	message: "The reply stopped before this jig was finished."
 };
 function transform(turn, stream, stop) {
 	const reader = stream.getReader();
@@ -88,7 +88,7 @@ function transform(turn, stream, stop) {
 				send({
 					data: block,
 					id: block.key,
-					type: "data-pickle"
+					type: "data-jigs"
 				});
 			};
 			const repair = (block) => {
@@ -193,19 +193,19 @@ function transform(turn, stream, stop) {
 	});
 }
 /**
-* Compiles the pickles of a stored conversation again, for showing it after
+* Compiles the jigs 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.
+* so a `StoredJigsUIMessage<Metadata>`, or the stored form of your own
+* message type, comes back with `JigsBlockData` in its `data-jigs` parts.
 */
-async function revivePickles(pickle, messages) {
+async function reviveJigs(jigs, 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;
+			if (part.type !== "data-jigs" || !("data" in part)) return part;
 			const stored = storedBlock.parse(part.data);
-			const compiled = await pickle.compile(stored.source, { strict: false });
+			const compiled = await jigs.compile(stored.source, { strict: false });
 			const data = {
 				...stored,
 				diagnostics: compiled.diagnostics,
@@ -220,4 +220,4 @@ async function revivePickles(pickle, messages) {
 	})));
 }
 //#endregion
-export { pickleChat, revivePickles };
+export { jigsChat, reviveJigs };

package/dist/client.d.ts

@@ -1,2 +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 };
+import { JigsBlockData, JigsDataTypes, JigsUIMessage, StoredJigsBlock, StoredJigsUIMessage, recentMessages, withoutPrograms } from "./stored.js";
+export { type JigsBlockData, type JigsDataTypes, type JigsUIMessage, type StoredJigsBlock, type StoredJigsUIMessage, recentMessages, withoutPrograms };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { PickleBlockData, PickleDataTypes, PickleUIMessage, StoredPickleBlock, StoredPickleUIMessage, recentMessages, withoutPrograms } from "./stored.js";
-import { PickleChat, pickleChat, revivePickles } from "./chat.js";
+import { JigsBlockData, JigsDataTypes, JigsUIMessage, StoredJigsBlock, StoredJigsUIMessage, recentMessages, withoutPrograms } from "./stored.js";
+import { JigsChat, jigsChat, reviveJigs } 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 };
+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 };

package/dist/index.js

@@ -1,5 +1,5 @@
-import { pickleDataSchemas } from "./schemas.js";
-import { pickleChat, revivePickles } from "./chat.js";
+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, pickleChat, pickleDataSchemas, recentMessages, revivePickles, withoutPrograms };
+export { aiSdkModel, cachedInstructions, jigsChat, jigsDataSchemas, recentMessages, reviveJigs, withoutPrograms };

package/dist/model.d.ts

@@ -12,7 +12,7 @@ export type ModelSettings = Omit<Parameters<typeof streamText>[0], "abortSignal"
  */
 export declare function cachedInstructions(system: string, prefix: string): Instructions;
 /**
- * A `model` for `createPickleServer` from an AI SDK model: document-mode
+ * A `model` for `createJigsServer` 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`).

package/dist/model.js

@@ -19,7 +19,7 @@ function cachedInstructions(system, prefix) {
 	}];
 }
 /**
-* A `model` for `createPickleServer` from an AI SDK model: document-mode
+* A `model` for `createJigsServer` 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`).

package/dist/schemas.d.ts

@@ -1,13 +1,13 @@
 import { z } from "zod";
 //#region src/schemas.d.ts
 /**
- * Schemas for `validateUIMessages<StoredPickleUIMessage>({ messages,
+ * Schemas for `validateUIMessages<StoredJigsUIMessage>({ messages,
  * dataSchemas })`, to check a conversation the browser sent or one read
- * from storage. A pickle's program is dropped, never checked: the server
+ * from storage. A jig'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<{
+export declare const jigsDataSchemas: {
+  jigs: z.ZodObject<{
     diagnostics: z.ZodArray<z.ZodObject<{
       code: z.ZodString;
       fix: z.ZodExactOptional<z.ZodObject<{
@@ -25,7 +25,6 @@ export declare const pickleDataSchemas: {
       message: z.ZodString;
       severity: z.ZodEnum<{
         error: "error";
-        hint: "hint";
         info: "info";
         warning: "warning";
       }>;

package/dist/schemas.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { pickleErrorCodes } from "@jigs.design/runtime";
+import { jigsErrorCodes, severities } from "@jigs.design/protocol";
 //#region src/schemas.ts
 const span = z.object({
 	column: z.number().exactOptional(),
@@ -18,16 +18,11 @@ const storedBlock = z.object({
 			title: z.string()
 		}).exactOptional(),
 		message: z.string(),
-		severity: z.enum([
-			"error",
-			"hint",
-			"info",
-			"warning"
-		]),
+		severity: z.enum(severities),
 		span
 	})),
 	error: z.object({
-		code: z.enum(pickleErrorCodes),
+		code: z.enum(jigsErrorCodes),
 		message: z.string()
 	}).exactOptional(),
 	id: z.string(),
@@ -41,11 +36,11 @@ const storedBlock = z.object({
 	version: z.number()
 });
 /**
-* Schemas for `validateUIMessages<StoredPickleUIMessage>({ messages,
+* Schemas for `validateUIMessages<StoredJigsUIMessage>({ messages,
 * dataSchemas })`, to check a conversation the browser sent or one read
-* from storage. A pickle's program is dropped, never checked: the server
+* from storage. A jig's program is dropped, never checked: the server
 * reads only `id` and `source`, and a source is only ever compiled.
 */
-const pickleDataSchemas = { pickle: storedBlock };
+const jigsDataSchemas = { jigs: storedBlock };
 //#endregion
-export { pickleDataSchemas, storedBlock };
+export { jigsDataSchemas, storedBlock };

package/dist/stored.d.ts

@@ -1,55 +1,55 @@
-import { ChatBlock } from "@jigs.design/runtime";
+import { ChatBlock } from "@jigs.design/protocol";
 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 jig's `data-jigs` part: one fenced block of a reply, compiled. */
+export type JigsBlockData = 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`,
+ * A jig as the browser sends it back and as you store it: everything but
+ * the program. Only `reviveJigs` turns it back into a `JigsBlockData`,
  * by compiling `source` again.
  */
-export type StoredPickleBlock = Omit<PickleBlockData, "program">;
+export type StoredJigsBlock = Omit<JigsBlockData, "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;
+export type JigsDataTypes = {
+  jigs: JigsBlockData;
 };
-/** A `useChat` message whose replies may hold pickles. */
-export type PickleUIMessage<TMetadata = unknown> = UIMessage<TMetadata, PickleDataTypes>;
+/** A `useChat` message whose replies may hold jigs. */
+export type JigsUIMessage<TMetadata = unknown> = UIMessage<TMetadata, JigsDataTypes>;
 /**
- * A conversation as the server receives it and as you store it: its pickles
- * carry no programs. `validateUIMessages` with `pickleDataSchemas` returns
+ * A conversation as the server receives it and as you store it: its jigs
+ * carry no programs. `validateUIMessages` with `jigsDataSchemas` returns
  * this shape.
  */
-export type StoredPickleUIMessage<TMetadata = unknown> = UIMessage<TMetadata, {
-  pickle: StoredPickleBlock;
+export type StoredJigsUIMessage<TMetadata = unknown> = UIMessage<TMetadata, {
+  jigs: StoredJigsBlock;
 }>;
-/** A message part, with a `data-pickle` part's data replaced by `TBlock`. */
+/** A message part, with a `data-jigs` part's data replaced by `TBlock`. */
 type WithBlock<TPart, TBlock> = TPart extends {
-  type: "data-pickle";
+  type: "data-jigs";
 } ? Omit<TPart, "data"> & {
   data: TBlock;
 } : TPart;
 /**
- * `TMessage` with each pickle's data replaced by `TBlock`, and every other
+ * `TMessage` with each jig'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"> & {
+export type WithJigsBlocks<TMessage extends UIMessage, TBlock> = Omit<TMessage, "parts"> & {
   parts: Array<WithBlock<TMessage["parts"][number], TBlock>>;
 };
 /**
- * The messages without their pickles' programs: for the body `useChat`
+ * The messages without their jigs' 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>>;
+export declare function withoutPrograms<TMessage extends UIMessage>(messages: ReadonlyArray<TMessage>): Array<WithJigsBlocks<TMessage, StoredJigsBlock>>;
 /**
  * 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
+ * `keep` messages, from a user message on. Every earlier jig comes first,
+ * in one assistant message of their `data-jigs` 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.
  */

package/dist/stored.js

@@ -1,10 +1,10 @@
 //#region src/stored.ts
-/** Whether `part` is a pickle whose block still holds its program. */
+/** Whether `part` is a jig 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;
+	return part.type === "data-jigs" && "data" in part && typeof part.data === "object" && part.data !== null && "program" in part.data;
 }
 /**
-* The messages without their pickles' programs: for the body `useChat`
+* The messages without their jigs' 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.
@@ -26,8 +26,8 @@ function withoutPrograms(messages) {
 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
+* `keep` messages, from a user message on. Every earlier jig comes first,
+* in one assistant message of their `data-jigs` 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.
 */
@@ -37,13 +37,13 @@ function recentMessages(messages, keep = RECENT) {
 	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 jigs = earlier.flatMap((message) => message.parts.filter((part) => part.type === "data-jigs"));
 	const recent = messages.slice(start);
 	const [first] = earlier;
-	if (first === void 0 || pickles.length === 0) return recent;
+	if (first === void 0 || jigs.length === 0) return recent;
 	return [{
 		...first,
-		parts: pickles
+		parts: jigs
 	}, ...recent];
 }
 //#endregion

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@jigs.design/ai-sdk",
-  "version": "0.1.1",
-  "description": "Pickle on the AI SDK: a model function for createPickleServer, and chat mode for useChat.",
+  "version": "0.2.0",
+  "description": "Jigs on the AI SDK: a model function for createJigsServer, and chat mode for useChat.",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/yoamomonstruos/pickle.git",
+    "url": "git+https://github.com/yoamomonstruos/jigs.git",
     "directory": "packages/ai-sdk"
   },
   "type": "module",
@@ -29,8 +29,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@jigs.design/runtime": "0.1.1",
-    "@jigs.design/server": "0.1.1"
+    "@jigs.design/server": "0.2.0",
+    "@jigs.design/protocol": "0.2.0"
   },
   "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/host": "0.1.1",
-    "@jigs.design/catalog": "0.1.1"
+    "@jigs.design/catalog": "0.2.0",
+    "@jigs.design/host": "0.2.0"
   }
 }