@maxanstey-meridian/tandem 0.1.3 → 0.1.5

package/README.md

@@ -62,6 +62,11 @@ capabilities, interactions, persistence, and complete examples.
 
 Licensed under the [MIT License](./LICENSE).
 
+For a specialised model that requires a plain user message, a raw-output agent
+can set both `instructions` and `output.instructions` to `""`. Tandem then sends
+the authored message without system instructions or a response-format constraint.
+Other agent/output modes still require nonblank instructions.
+
 ## Development and publishing
 
 ```sh
@@ -74,3 +79,38 @@ npm pack
 `npm pack` and `npm publish` build fresh output before packaging. The npm package contains
 `dist`, including one copy of the vendored bridge in `dist/runtime`. Update `runtime` from
 a tested Tandem bridge build before releasing runtime changes.
+
+## Runtime-sized collections
+
+Use `collection` for a list whose size is known at execution time. Declare its
+item/result schemas and agents, select items from state, and apply the ordered
+results. Native Tandem owns scheduling through `max`; zero and one item need no
+special graph.
+
+`taskAgent<Input, Output>` defines a model participant with validated input and
+output. Inside a collection, `context.run(agent, input)` invokes only agents
+declared on that collection. Await each call before the next. Scope use after
+completion and sibling parallel agent calls are rejected. Operational failure
+fails the collection, drains active work, and skips application of results.
+
+```ts
+const canonicalise = collection({
+  id: "canonicalise",
+  item: Proposition,
+  result: Claim,
+  agents: [canonicaliser],
+  max: 6,
+  items: (state: SourceState) => state.propositions,
+  execute: (proposition, context) => context.run(canonicaliser, proposition),
+  apply: (state, claims) => ({ ...state, claims }),
+});
+```
+
+The executable [collection example](tests/collection-child.ts) includes
+conditional recovery, persistence, cancellation and concurrent source runs.
+Agent visits remain in the source run's native observations and ledger.
+
+Agent definitions may be reused across collections. Native Tandem binds each under
+its collection name. Scoped observations and accepted ledger values carry a
+`visitId` so concurrent calls can be correlated without changing their semantic
+`stepId`.

package/dist/index.d.ts

@@ -55,7 +55,7 @@ export interface Parallel<TState> extends Participant<TState> {
 export interface Terminal<TState> extends Participant<TState> {
     readonly kind: "terminal";
 }
-type Node<TState> = Stage<TState> | Interaction<TState, unknown, unknown> | Agent<TState> | Parallel<TState> | Terminal<TState>;
+type Node<TState> = Collection<TState> | Stage<TState> | Interaction<TState, unknown, unknown> | Agent<TState> | Parallel<TState> | Terminal<TState>;
 export declare function stage<TState>(definition: {
     id: string;
     execute: (state: TState, context: {
@@ -63,6 +63,44 @@ export declare function stage<TState>(definition: {
     }) => TState | Promise<TState>;
     persist?: boolean;
 }): Stage<TState>;
+declare const taskAgentBrand: unique symbol;
+export interface TaskAgentReference {
+    readonly id: string;
+    readonly [taskAgentBrand]: true;
+}
+export interface TaskAgent<TInput, TOutput> extends TaskAgentReference {
+    readonly input: z.ZodType<TInput>;
+    readonly result: z.ZodType<TOutput>;
+}
+export interface CollectionContext {
+    readonly signal: AbortSignal;
+    run<TInput, TOutput>(agent: TaskAgent<TInput, TOutput>, input: NoInfer<TInput>): Promise<TOutput>;
+}
+export interface Collection<TState> extends Participant<TState> {
+    readonly kind: "collection";
+}
+export interface TaskAgentDefinition<TInput, TOutput> extends Omit<AgentDefinition<TInput, TOutput>, "output" | "capabilities" | "workspace" | "checkpoint"> {
+    input: z.ZodType<TInput>;
+    result: z.ZodType<TOutput>;
+    output: Omit<Extract<NonNullable<AgentDefinition<TInput, TOutput>["output"]>, {
+        schema: unknown;
+    }>, "apply"> | Omit<Extract<NonNullable<AgentDefinition<TInput, TOutput>["output"]>, {
+        raw: true;
+    }>, "apply">;
+}
+export declare function taskAgent<TInput, TOutput>(definition: TaskAgentDefinition<TInput, TOutput>): TaskAgent<TInput, TOutput>;
+interface CollectionDefinition<TState, TItem, TResult> {
+    id: string;
+    item: z.ZodType<TItem>;
+    result: z.ZodType<TResult>;
+    items: (state: TState) => readonly TItem[];
+    agents: readonly TaskAgentReference[];
+    execute: (item: TItem, context: CollectionContext) => Promise<TResult> | TResult;
+    apply: (state: TState, results: readonly TResult[]) => TState;
+    max: number;
+    persist?: boolean;
+}
+export declare function collection<TState, TItem, TResult>(definition: CollectionDefinition<TState, TItem, TResult>): Collection<TState>;
 export declare function interaction<TState, TRequest, TResponse>(definition: {
     id: string;
     requestSchema: z.ZodType<TRequest>;
@@ -221,7 +259,7 @@ export declare function output<TState>(definition: {
     persist?: boolean;
 }): Terminal<TState>;
 export interface OrdinaryRoute<TState> {
-    readonly from: Stage<TState> | Interaction<TState, unknown, unknown>;
+    readonly from: Stage<TState> | Collection<TState> | Interaction<TState, unknown, unknown>;
     readonly to: Node<TState>;
     readonly label: string;
     readonly outcome?: never;
@@ -275,7 +313,8 @@ export interface InspectedRoute {
 }
 export interface InspectedNode {
     readonly id: string;
-    readonly kind: "stage" | "interaction" | "agent" | "parallel" | "completion" | "failure";
+    readonly kind: "stage" | "interaction" | "agent" | "parallel" | "collection" | "completion" | "failure";
+    readonly agents?: readonly string[];
     readonly persist?: boolean;
     readonly interaction?: {
         readonly requestSchema: unknown;
@@ -304,6 +343,8 @@ export interface RunResult<TState> {
     readonly summary: string | null;
 }
 export type RunObservation = {
+    readonly visitId?: string | null;
+} & ({
     readonly version: 1;
     readonly kind: "stepStarted";
     readonly stepId: string;
@@ -354,7 +395,7 @@ export type RunObservation = {
         readonly message: string;
     }[];
     readonly rawResponse: string;
-};
+});
 export interface TerminalPresentationOptions {
     readonly truncatedToolNames?: readonly string[];
 }
@@ -377,6 +418,7 @@ export type AcceptedValue = {
         readonly version: 1;
         readonly kind: K;
         readonly stepId: string;
+        readonly visitId?: string | null;
         readonly valueType: string | null;
         readonly payload: unknown | null;
     };

package/dist/index.js

@@ -332,6 +332,55 @@ class StageImplementation extends NodeImplementation {
 export function stage(definition) {
     return new StageImplementation(definition.id, definition.persist, definition.execute);
 }
+const taskAgentBrand = Symbol("taskAgent");
+class TaskAgentImplementation {
+    id;
+    input;
+    result;
+    [taskAgentBrand] = true;
+    state;
+    participant;
+    constructor(id, input, result, definition) {
+        this.id = id;
+        this.input = input;
+        this.result = result;
+        this.state = z.object({ input, output: z.object({ value: result }).nullable() });
+        this.participant = agent({
+            ...definition,
+            message: (state) => definition.message(state.input),
+            output: {
+                ...definition.output,
+                validateFor: definition.output.validateFor
+                    ? (state, value) => definition.output.validateFor(state.input, value)
+                    : undefined,
+                apply: (state, value) => ({
+                    ...state,
+                    output: { value },
+                }),
+            },
+        });
+    }
+}
+export function taskAgent(definition) {
+    return new TaskAgentImplementation(definition.id, definition.input, definition.result, definition);
+}
+class CollectionImplementation extends NodeImplementation {
+    definition;
+    kind = "collection";
+    constructor(definition) {
+        super(definition.id, definition.persist);
+        this.definition = definition;
+    }
+}
+export function collection(definition) {
+    if (!Number.isInteger(definition.max) || definition.max < 1 || definition.max > 2147483647) {
+        throw new TandemError("Collection max must be a positive 32-bit integer.");
+    }
+    if (new Set(definition.agents.map((agent) => agent.id)).size !== definition.agents.length) {
+        throw new TandemError("Collection agent IDs must be unique.");
+    }
+    return new CollectionImplementation(definition);
+}
 class InteractionImplementation extends NodeImplementation {
     requestSchema;
     responseSchema;
@@ -576,7 +625,10 @@ class AgentImplementation extends NodeImplementation {
     }
 }
 export function agent(definition) {
-    requireInstructions(definition.instructions, `Agent '${definition.id}' instructions`);
+    const rawOutput = definition.output && "raw" in definition.output && definition.output.raw === true;
+    if (!rawOutput || typeof definition.instructions !== "string") {
+        requireInstructions(definition.instructions, `Agent '${definition.id}' instructions`);
+    }
     const reasoningEffort = definition.reasoning?.effort;
     const reasoningMaxTokens = definition.reasoning?.maxTokens;
     if (definition.reasoning &&
@@ -595,7 +647,9 @@ export function agent(definition) {
         }
     }
     if (definition.output) {
-        requireInstructions(definition.output.instructions, `Agent '${definition.id}' output instructions`);
+        if (!rawOutput || typeof definition.output.instructions !== "string") {
+            requireInstructions(definition.output.instructions, `Agent '${definition.id}' output instructions`);
+        }
         if ("raw" in definition.output) {
             if (definition.output.raw !== true) {
                 throw new TandemError(`Agent '${definition.id}' output raw must be true.`);
@@ -818,6 +872,15 @@ export function inspectPipeline(graph) {
     const inspectNode = (node) => {
         const implementation = node;
         const persist = implementation.persist;
+        if (implementation instanceof CollectionImplementation) {
+            return {
+                id: node.id,
+                kind: "collection",
+                persist,
+                max: implementation.definition.max,
+                agents: implementation.definition.agents.map((agent) => node.id + "/" + agent.id),
+            };
+        }
         if (node.kind === "interaction") {
             const interaction = implementation;
             return {
@@ -887,19 +950,35 @@ export function inspectPipeline(graph) {
 }
 const runObservationSchema = z.discriminatedUnion("kind", [
     z
-        .object({ version: z.literal(1), kind: z.literal("stepStarted"), stepId: z.string().min(1) })
+        .object({
+        version: z.literal(1),
+        kind: z.literal("stepStarted"),
+        stepId: z.string().min(1),
+        visitId: z.string().nullable().optional(),
+    })
         .strict(),
     z
-        .object({ version: z.literal(1), kind: z.literal("stepCompleted"), stepId: z.string().min(1) })
+        .object({
+        version: z.literal(1),
+        kind: z.literal("stepCompleted"),
+        stepId: z.string().min(1),
+        visitId: z.string().nullable().optional(),
+    })
         .strict(),
     z
-        .object({ version: z.literal(1), kind: z.literal("stepCancelled"), stepId: z.string().min(1) })
+        .object({
+        version: z.literal(1),
+        kind: z.literal("stepCancelled"),
+        stepId: z.string().min(1),
+        visitId: z.string().nullable().optional(),
+    })
         .strict(),
     z
         .object({
         version: z.literal(1),
         kind: z.literal("stepFaulted"),
         stepId: z.string().min(1),
+        visitId: z.string().nullable().optional(),
         error: z.string(),
     })
         .strict(),
@@ -908,6 +987,7 @@ const runObservationSchema = z.discriminatedUnion("kind", [
         version: z.literal(1),
         kind: z.literal("agentText"),
         stepId: z.string().min(1),
+        visitId: z.string().nullable().optional(),
         text: z.string(),
     })
         .strict(),
@@ -916,6 +996,7 @@ const runObservationSchema = z.discriminatedUnion("kind", [
         version: z.literal(1),
         kind: z.literal("agentModelSelected"),
         stepId: z.string().min(1),
+        visitId: z.string().nullable().optional(),
         modelId: z.string().min(1),
     })
         .strict(),
@@ -924,6 +1005,7 @@ const runObservationSchema = z.discriminatedUnion("kind", [
         version: z.literal(1),
         kind: z.literal("agentReasoning"),
         stepId: z.string().min(1),
+        visitId: z.string().nullable().optional(),
         text: z.string(),
     })
         .strict(),
@@ -932,6 +1014,7 @@ const runObservationSchema = z.discriminatedUnion("kind", [
         version: z.literal(1),
         kind: z.literal("agentUsage"),
         stepId: z.string().min(1),
+        visitId: z.string().nullable().optional(),
         inputTokens: z.number().int().nonnegative(),
         outputTokens: z.number().int().nonnegative(),
         reasoningTokens: z.number().int().nonnegative(),
@@ -944,6 +1027,7 @@ const runObservationSchema = z.discriminatedUnion("kind", [
         version: z.literal(1),
         kind: z.literal("structuredOutputRejected"),
         stepId: z.string().min(1),
+        visitId: z.string().nullable().optional(),
         attempt: z.number().int().positive(),
         problems: z.array(z.object({ field: z.string(), message: z.string().min(1) }).strict()),
         rawResponse: z.string(),
@@ -960,6 +1044,7 @@ const acceptedKinds = [
 const acceptedValueSchema = z
     .object({
     kind: z.enum(acceptedKinds),
+    visitId: z.string().nullable().optional(),
     stepId: z.string().min(1),
     valueType: z.string().min(1).nullable(),
     payload: z.unknown().nullable(),
@@ -984,6 +1069,7 @@ export async function inspectAccepted(options) {
             version: 1,
             kind: value.kind,
             stepId: value.stepId,
+            ...(value.visitId == null ? {} : { visitId: value.visitId }),
             valueType: value.valueType,
             payload: value.payload,
         }));
@@ -1132,6 +1218,64 @@ function interactionHandlerEntries(handlers) {
 function compileNode(node, stateSchema, callbacks) {
     const implementation = node;
     const base = { id: node.id, persist: implementation.persist };
+    if (implementation instanceof CollectionImplementation) {
+        const definition = implementation.definition;
+        const agents = definition.agents.map((value) => {
+            if (!(value instanceof TaskAgentImplementation))
+                throw new TandemError("Use taskAgent to declare collection agents.");
+            return compileNode(value.participant, value.state, callbacks);
+        });
+        const itemsCallback = callbacks.registerSync((state) => serializeBoundary(z.array(definition.item), definition.items(parseJson(stateSchema, state, node.id + " state")), node.id + " items"));
+        const runCallback = callbacks.registerAsync(async (item, scopeId, signal) => {
+            let active = false;
+            let closed = false;
+            const context = {
+                signal,
+                async run(value, input) {
+                    if (closed)
+                        throw new TandemError("Collection scope has ended.");
+                    if (active)
+                        throw new TandemError("Collection item agents must be awaited serially.");
+                    if (!definition.agents.includes(value) || !(value instanceof TaskAgentImplementation)) {
+                        throw new TandemError("Agent is not declared in this collection.");
+                    }
+                    signal.throwIfAborted();
+                    active = true;
+                    try {
+                        const { runCollectionAgentAsync } = await import("./runtime/loader.mjs");
+                        const response = await runCollectionAgentAsync(scopeId, value.id, serializeBoundary(value.state, { input, output: null }, value.id + " input"));
+                        const state = parseJson(value.state, response, value.id + " output");
+                        if (state.output === null)
+                            throw new TandemError("Agent returned no output.");
+                        return parse(value.result, state.output.value, value.id + " result");
+                    }
+                    finally {
+                        active = false;
+                    }
+                },
+            };
+            try {
+                const result = await definition.execute(parseJson(definition.item, item, node.id + " item"), context);
+                if (active)
+                    throw new TandemError("Collection item returned before its agent completed.");
+                signal.throwIfAborted();
+                return serializeBoundary(definition.result, result, node.id + " result");
+            }
+            finally {
+                closed = true;
+            }
+        });
+        const applyCallback = callbacks.registerSync((state, results) => serializeBoundary(stateSchema, definition.apply(parseJson(stateSchema, state, node.id + " state"), parseJson(z.array(definition.result), results, node.id + " results")), node.id + " output"));
+        return {
+            ...base,
+            kind: "collection",
+            agents,
+            max: definition.max,
+            itemsCallback,
+            runCallback,
+            applyCallback,
+        };
+    }
     if (implementation instanceof StageImplementation) {
         const run = callbacks.registerAsync(async (state, _, signal) => serializeBoundary(stateSchema, await implementation.execute(parseJson(stateSchema, state, `${node.id} input`), {
             signal,
@@ -1321,13 +1465,9 @@ function compileAgentOutput(id, output, stateSchema, callbacks) {
         ? callbacks.registerSync((_, input) => issuesParsed(z.unknown(), output.parse(JSON.parse(input))))
         : callbacks.registerSync((_, input) => issues(output.schema, input));
     const validateFor = output.validateFor
-        ? callbacks.registerSync((state, input) => validationProblems(output.validateFor(parseJson(stateSchema, state, `${id} state`), raw
-            ? JSON.parse(input)
-            : parseJson(output.schema, input, `${id} output`)), `${id} output contextual validation`))
+        ? callbacks.registerSync((state, input) => validationProblems(output.validateFor(parseJson(stateSchema, state, `${id} state`), raw ? JSON.parse(input) : parseJson(output.schema, input, `${id} output`)), `${id} output contextual validation`))
         : undefined;
-    const apply = callbacks.registerSync((state, input) => serializeBoundary(stateSchema, output.apply(parseJson(stateSchema, state, `${id} state`), raw
-        ? JSON.parse(input)
-        : parseJson(output.schema, input, `${id} output`)), `${id} applied state`));
+    const apply = callbacks.registerSync((state, input) => serializeBoundary(stateSchema, output.apply(parseJson(stateSchema, state, `${id} state`), raw ? JSON.parse(input) : parseJson(output.schema, input, `${id} output`)), `${id} applied state`));
     return {
         instructions: output.instructions,
         ...(raw

package/dist/runtime/Tandem.NodeApiSpike.Bridge.cjs

@@ -1,4 +1,4 @@
-// Generated for: Tandem.NodeApiSpike.Bridge 0.1.0.0
+// Generated for: Tandem.NodeApiSpike.Bridge 0.2.1.0
 // Generated by: Microsoft.JavaScript.NodeApi.Generator 0.9.0.0
 /* eslint-disable */
 

package/dist/runtime/Tandem.NodeApiSpike.Bridge.d.ts

@@ -1,4 +1,4 @@
-// Generated for: Tandem.NodeApiSpike.Bridge 0.1.0.0
+// Generated for: Tandem.NodeApiSpike.Bridge 0.2.1.0
 // Generated by: Microsoft.JavaScript.NodeApi.Generator 0.9.0.0
 /* eslint-disable */
 
@@ -7,6 +7,13 @@ import './System.Runtime';
 
 /** Adapts JavaScript-authored participants to the Tandem runtime. */
 export namespace NodePipelineBridge {
+	/** Executes a declared agent within an active collection item. */
+	export function runCollectionAgentAsync(
+		scopeId: string,
+		agentId: string,
+		state: string,
+	): Promise<string>;
+
 	/** Reads accepted semantic journal values from a packaged SQLite ledger. */
 	export function inspectAcceptedAsync(
 		ledgerPath: string,

package/dist/runtime/Tandem.NodeApiSpike.Bridge.deps.json

@@ -7,23 +7,23 @@
   "targets": {
     ".NETCoreApp,Version=v10.0": {},
     ".NETCoreApp,Version=v10.0/osx-arm64": {
-      "Tandem.NodeApiSpike.Bridge/0.1.0": {
+      "Tandem.NodeApiSpike.Bridge/0.2.1": {
         "dependencies": {
-          "Meridian.Tandem": "0.1.0",
-          "Meridian.Tandem.Advanced": "0.1.0",
-          "Meridian.Tandem.Ledger": "0.1.0",
-          "Meridian.Tandem.OpenAICompatible": "0.1.0",
-          "Meridian.Tandem.Terminal": "0.1.0",
+          "Meridian.Tandem": "0.2.1",
+          "Meridian.Tandem.Advanced": "0.2.1",
+          "Meridian.Tandem.Ledger": "0.2.1",
+          "Meridian.Tandem.OpenAICompatible": "0.2.1",
+          "Meridian.Tandem.Terminal": "0.2.1",
           "Microsoft.Extensions.AI.OpenAI": "10.8.3",
           "Microsoft.JavaScript.NodeApi": "0.9.26",
           "Microsoft.JavaScript.NodeApi.Generator": "0.9.26",
           "OpenAI": "2.12.0",
           "System.ClientModel": "1.14.0",
-          "Tandem.Advanced": "0.1.0.0",
-          "Tandem": "0.1.0.0",
-          "Tandem.Ledger": "0.1.0.0",
-          "Tandem.OpenAICompatible": "0.1.0.0",
-          "Tandem.Terminal": "0.1.0.0"
+          "Tandem.Advanced": "0.2.1.0",
+          "Tandem": "0.2.1.0",
+          "Tandem.Ledger": "0.2.1.0",
+          "Tandem.OpenAICompatible": "0.2.1.0",
+          "Tandem.Terminal": "0.2.1.0"
         },
         "runtime": {
           "Tandem.NodeApiSpike.Bridge.dll": {}
@@ -643,7 +643,7 @@
           }
         }
       },
-      "Meridian.Tandem/0.1.0": {
+      "Meridian.Tandem/0.2.1": {
         "dependencies": {
           "FluentValidation": "12.1.1",
           "JsonSchema.Net.Generation": "7.3.11",
@@ -653,15 +653,15 @@
         },
         "runtime": {
           "Tandem.dll": {
-            "assemblyVersion": "0.1.0.0",
-            "fileVersion": "0.1.0.0"
+            "assemblyVersion": "0.2.1.0",
+            "fileVersion": "0.2.1.0"
           }
         }
       },
-      "Meridian.Tandem.Advanced/0.1.0": {
+      "Meridian.Tandem.Advanced/0.2.1": {
         "dependencies": {
           "FluentValidation": "12.1.1",
-          "Meridian.Tandem": "0.1.0",
+          "Meridian.Tandem": "0.2.1",
           "Microsoft.Agents.AI.Harness": "1.16.0",
           "Microsoft.Agents.AI.Tools.Shell": "1.16.0-preview.260730.1",
           "Microsoft.Extensions.AI": "10.8.3",
@@ -669,25 +669,25 @@
         },
         "runtime": {
           "Tandem.Advanced.dll": {
-            "assemblyVersion": "0.1.0.0",
-            "fileVersion": "0.1.0.0"
+            "assemblyVersion": "0.2.1.0",
+            "fileVersion": "0.2.1.0"
           }
         }
       },
-      "Meridian.Tandem.Ledger/0.1.0": {
+      "Meridian.Tandem.Ledger/0.2.1": {
         "dependencies": {
-          "Meridian.Tandem": "0.1.0",
+          "Meridian.Tandem": "0.2.1",
           "Microsoft.Data.Sqlite": "10.0.10",
           "SQLitePCLRaw.bundle_e_sqlite3": "2.1.12"
         },
         "runtime": {
           "Tandem.Ledger.dll": {
-            "assemblyVersion": "0.1.0.0",
-            "fileVersion": "0.1.0.0"
+            "assemblyVersion": "0.2.1.0",
+            "fileVersion": "0.2.1.0"
           }
         }
       },
-      "Meridian.Tandem.OpenAICompatible/0.1.0": {
+      "Meridian.Tandem.OpenAICompatible/0.2.1": {
         "dependencies": {
           "Microsoft.Extensions.AI": "10.8.3",
           "OpenAI": "2.12.0",
@@ -695,67 +695,67 @@
         },
         "runtime": {
           "Tandem.OpenAICompatible.dll": {
-            "assemblyVersion": "0.1.0.0",
-            "fileVersion": "0.1.0.0"
+            "assemblyVersion": "0.2.1.0",
+            "fileVersion": "0.2.1.0"
           }
         }
       },
-      "Meridian.Tandem.Terminal/0.1.0": {
+      "Meridian.Tandem.Terminal/0.2.1": {
         "dependencies": {
-          "Meridian.Tandem": "0.1.0",
+          "Meridian.Tandem": "0.2.1",
           "Spectre.Console": "0.57.2"
         },
         "runtime": {
           "Tandem.Terminal.dll": {
-            "assemblyVersion": "0.1.0.0",
-            "fileVersion": "0.1.0.0"
+            "assemblyVersion": "0.2.1.0",
+            "fileVersion": "0.2.1.0"
           }
         }
       },
-      "Tandem.Advanced/0.1.0.0": {
+      "Tandem.Advanced/0.2.1.0": {
         "runtime": {
           "Tandem.Advanced.dll": {
-            "assemblyVersion": "0.1.0.0",
-            "fileVersion": "0.1.0.0"
+            "assemblyVersion": "0.2.1.0",
+            "fileVersion": "0.2.1.0"
           }
         }
       },
-      "Tandem/0.1.0.0": {
+      "Tandem/0.2.1.0": {
         "runtime": {
           "Tandem.dll": {
-            "assemblyVersion": "0.1.0.0",
-            "fileVersion": "0.1.0.0"
+            "assemblyVersion": "0.2.1.0",
+            "fileVersion": "0.2.1.0"
           }
         }
       },
-      "Tandem.Ledger/0.1.0.0": {
+      "Tandem.Ledger/0.2.1.0": {
         "runtime": {
           "Tandem.Ledger.dll": {
-            "assemblyVersion": "0.1.0.0",
-            "fileVersion": "0.1.0.0"
+            "assemblyVersion": "0.2.1.0",
+            "fileVersion": "0.2.1.0"
           }
         }
       },
-      "Tandem.OpenAICompatible/0.1.0.0": {
+      "Tandem.OpenAICompatible/0.2.1.0": {
         "runtime": {
           "Tandem.OpenAICompatible.dll": {
-            "assemblyVersion": "0.1.0.0",
-            "fileVersion": "0.1.0.0"
+            "assemblyVersion": "0.2.1.0",
+            "fileVersion": "0.2.1.0"
           }
         }
       },
-      "Tandem.Terminal/0.1.0.0": {
+      "Tandem.Terminal/0.2.1.0": {
         "runtime": {
           "Tandem.Terminal.dll": {
-            "assemblyVersion": "0.1.0.0",
-            "fileVersion": "0.1.0.0"
+            "assemblyVersion": "0.2.1.0",
+            "fileVersion": "0.2.1.0"
           }
         }
       }
     }
   },
   "libraries": {
-    "Tandem.NodeApiSpike.Bridge/0.1.0": {
+    "Tandem.NodeApiSpike.Bridge/0.2.1": {
       "type": "project",
       "serviceable": false,
       "sha512": ""
@@ -1103,52 +1103,52 @@
       "path": "tavily/1.0.1",
       "hashPath": "tavily.1.0.1.nupkg.sha512"
     },
-    "Meridian.Tandem/0.1.0": {
+    "Meridian.Tandem/0.2.1": {
       "type": "project",
       "serviceable": false,
       "sha512": ""
     },
-    "Meridian.Tandem.Advanced/0.1.0": {
+    "Meridian.Tandem.Advanced/0.2.1": {
       "type": "project",
       "serviceable": false,
       "sha512": ""
     },
-    "Meridian.Tandem.Ledger/0.1.0": {
+    "Meridian.Tandem.Ledger/0.2.1": {
       "type": "project",
       "serviceable": false,
       "sha512": ""
     },
-    "Meridian.Tandem.OpenAICompatible/0.1.0": {
+    "Meridian.Tandem.OpenAICompatible/0.2.1": {
       "type": "project",
       "serviceable": false,
       "sha512": ""
     },
-    "Meridian.Tandem.Terminal/0.1.0": {
+    "Meridian.Tandem.Terminal/0.2.1": {
       "type": "project",
       "serviceable": false,
       "sha512": ""
     },
-    "Tandem.Advanced/0.1.0.0": {
+    "Tandem.Advanced/0.2.1.0": {
       "type": "reference",
       "serviceable": false,
       "sha512": ""
     },
-    "Tandem/0.1.0.0": {
+    "Tandem/0.2.1.0": {
       "type": "reference",
       "serviceable": false,
       "sha512": ""
     },
-    "Tandem.Ledger/0.1.0.0": {
+    "Tandem.Ledger/0.2.1.0": {
       "type": "reference",
       "serviceable": false,
       "sha512": ""
     },
-    "Tandem.OpenAICompatible/0.1.0.0": {
+    "Tandem.OpenAICompatible/0.2.1.0": {
       "type": "reference",
       "serviceable": false,
       "sha512": ""
     },
-    "Tandem.Terminal/0.1.0.0": {
+    "Tandem.Terminal/0.2.1.0": {
       "type": "reference",
       "serviceable": false,
       "sha512": ""

package/dist/runtime/Tandem.NodeApiSpike.Bridge.mjs

@@ -1,4 +1,4 @@
-// Generated for: Tandem.NodeApiSpike.Bridge 0.1.0.0
+// Generated for: Tandem.NodeApiSpike.Bridge 0.2.1.0
 // Generated by: Microsoft.JavaScript.NodeApi.Generator 0.9.0.0
 /* eslint-disable */
 

package/dist/runtime/loader.mjs

@@ -25,11 +25,11 @@ let runtime;
 try {
   runtime = await import(bridgeUrl.href);
 } catch (error) {
-  throw new Error(
-    `Tandem could not load the ${platform} bridge from ${bridgeUrl.pathname}.`,
-    { cause: error },
-  );
+  throw new Error(`Tandem could not load the ${platform} bridge from ${bridgeUrl.pathname}.`, {
+    cause: error,
+  });
 }
 
 export const runRegisteredGraphAsync = runtime.NodePipelineBridge.runRegisteredGraphAsync;
-export const inspectAcceptedAsync = runtime.NodePipelineBridge.inspectAcceptedAsync;
+export const inspectAcceptedAsync = runtime.NodePipelineBridge.inspectAcceptedAsync;
+export const runCollectionAgentAsync = runtime.NodePipelineBridge.runCollectionAgentAsync;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maxanstey-meridian/tandem",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "TypeScript authoring API for Tandem agentic pipelines",
   "homepage": "https://github.com/maxanstey-meridian/tandem-ts#readme",
   "license": "MIT",