ai-tool-set 0.1.0-alpha.2 → 0.1.0-alpha.3

package/README.md

@@ -217,6 +217,16 @@ export async function POST(req: Request) {
 }
 ```
 
+Use `.clone()` to convert between immutable and mutable, preserving all activation entries:
+
+```typescript
+// Convert an immutable toolset to mutable
+const mutableToolSet = toolSet.clone({ mutable: true });
+
+// Convert a mutable toolset back to immutable
+const immutableToolSet = mutableToolSet.clone();
+```
+
 ### Typed UI Tool Set
 
 Use `InferUIToolSet` to get fully typed UI messages from your tool set:
@@ -362,6 +372,15 @@ const { tools, activeTools } = toolSet.inferTools({ messages, context: {} });
 const result = await generateText({ model, tools, activeTools, messages });
 ```
 
+#### `.clone(options?)`
+
+Clone the toolset, preserving all activation entries. Pass `{ mutable: true }` to get a mutable clone, or omit for an immutable clone. Defaults to immutable.
+
+```ts
+const mutableClone = toolSet.clone({ mutable: true });
+const immutableClone = toolSet.clone();
+```
+
 ## Types
 
 ### `ActivationInput`
@@ -401,6 +420,38 @@ type MyUIMessage = UIMessage<unknown, any, InferUIToolSet<typeof toolSet>>;
 // message.parts[0].output // typed as search tool's return type
 ```
 
+### `ActiveTools`
+
+Extract the tool names tracked as active from an immutable `ToolSet` instance. Tracks tools from `.activate()` and `.deactivateWhen()`.
+
+> [!NOTE]
+> `ActiveTools` returns `never` for mutable toolsets, since TypeScript cannot track type changes on the same reference across method calls.
+
+```ts
+import type { ActiveTools } from 'ai-tool-set';
+
+const toolSet = createToolSet({ tools }).deactivate(['cancel_order']);
+
+type Active = ActiveTools<typeof toolSet>;
+// 'search' | 'list_orders'
+```
+
+### `InactiveTools`
+
+Extract the tool names tracked as inactive from an immutable `ToolSet` instance. Tracks tools from `.deactivate()` and `.activateWhen()`.
+
+> [!NOTE]
+> `InactiveTools` returns `never` for mutable toolsets, since TypeScript cannot track type changes on the same reference across method calls.
+
+```ts
+import type { InactiveTools } from 'ai-tool-set';
+
+const toolSet = createToolSet({ tools }).deactivate(['cancel_order']);
+
+type Inactive = InactiveTools<typeof toolSet>;
+// 'cancel_order'
+```
+
 ## License
 
 MIT

package/dist/index.d.mts

@@ -95,6 +95,13 @@ declare class ImmutableToolSet<TOOLS extends ToolRecord, MESSAGE extends Message
   deactivateWhen<NAMES extends keyof TOOLS & string>(predicates: Partial<Record<NAMES, ActivationPredicate<MESSAGE, CONTEXT>>>): ImmutableToolSet<TOOLS, MESSAGE, CONTEXT, ACTIVATED | NAMES, Exclude<DEACTIVATED, NAMES>>;
   /** Evaluate all predicates with the provided input. Returns resolved `{ tools, activeTools }`. */
   inferTools(input: ActivationInput<MESSAGE, CONTEXT>): ResolvedToolSet<TOOLS>;
+  /** Clone this toolset, optionally switching between immutable and mutable. */
+  clone(options: {
+    mutable: true;
+  }): MutableToolSet<TOOLS, MESSAGE, CONTEXT>;
+  clone(options?: {
+    mutable?: false;
+  }): ImmutableToolSet<TOOLS, MESSAGE, CONTEXT, ACTIVATED, DEACTIVATED>;
 }
 /**
  * A mutable tool set with chainable activation methods.
@@ -125,6 +132,13 @@ declare class MutableToolSet<TOOLS extends ToolRecord, MESSAGE extends MessageTy
   deactivateWhen(predicates: Partial<Record<keyof TOOLS & string, ActivationPredicate<MESSAGE, CONTEXT>>>): this;
   /** Evaluate all predicates with the provided input. Returns resolved `{ tools, activeTools }`. */
   inferTools(input: ActivationInput<MESSAGE, CONTEXT>): ResolvedToolSet<TOOLS>;
+  /** Clone this toolset, optionally switching between immutable and mutable. */
+  clone(options: {
+    mutable: true;
+  }): MutableToolSet<TOOLS, MESSAGE, CONTEXT>;
+  clone(options?: {
+    mutable?: false;
+  }): ImmutableToolSet<TOOLS, MESSAGE, CONTEXT, keyof TOOLS & string>;
 }
 type CreateToolSetOptions<TOOLS extends ToolRecord> = {
   tools: TOOLS;

package/dist/index.mjs

@@ -107,6 +107,9 @@ var ImmutableToolSet = class ImmutableToolSet {
 	inferTools(input) {
 		return this.#state.inferTools(input);
 	}
+	clone(options) {
+		return options?.mutable ? new MutableToolSet(this.#state) : new ImmutableToolSet(this.#state);
+	}
 };
 /**
 * A mutable tool set with chainable activation methods.
@@ -114,7 +117,7 @@ var ImmutableToolSet = class ImmutableToolSet {
 * Same resolution semantics as ImmutableToolSet, but methods mutate
 * in-place and return `this` instead of creating new instances.
 */
-var MutableToolSet = class {
+var MutableToolSet = class MutableToolSet {
 	#state;
 	/** All tools as a standard AI SDK tool record. */
 	tools;
@@ -151,6 +154,9 @@ var MutableToolSet = class {
 	inferTools(input) {
 		return this.#state.inferTools(input);
 	}
+	clone(options) {
+		return options?.mutable ? new MutableToolSet(this.#state) : new ImmutableToolSet(this.#state);
+	}
 };
 function createToolSet(options) {
 	const state = new ToolSetState(options.tools, []);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-tool-set",
-  "version": "0.1.0-alpha.2",
+  "version": "0.1.0-alpha.3",
   "description": "Tool set utilities for the Vercel AI SDK",
   "keywords": [],
   "license": "MIT",