@cogitator-ai/test-utils 0.1.3

package/dist/fixtures/agents.d.ts

@@ -0,0 +1,9 @@
+import type { Agent, AgentConfig } from '@cogitator-ai/types';
+export interface TestAgentConfig extends Partial<AgentConfig> {
+    name?: string;
+    model?: string;
+    instructions?: string;
+}
+export declare function createTestAgentConfig(overrides?: TestAgentConfig): AgentConfig;
+export declare function createTestAgent(overrides?: TestAgentConfig): Agent;
+//# sourceMappingURL=agents.d.ts.map

package/dist/fixtures/agents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agents.d.ts","sourceRoot":"","sources":["../../src/fixtures/agents.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAQ,MAAM,qBAAqB,CAAC;AAEpE,MAAM,WAAW,eAAgB,SAAQ,OAAO,CAAC,WAAW,CAAC;IAC3D,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,wBAAgB,qBAAqB,CAAC,SAAS,CAAC,EAAE,eAAe,GAAG,WAAW,CAY9E;AAED,wBAAgB,eAAe,CAAC,SAAS,CAAC,EAAE,eAAe,GAAG,KAAK,CAgClE"}

package/dist/fixtures/agents.js

@@ -0,0 +1,46 @@
+import { nanoid } from 'nanoid';
+export function createTestAgentConfig(overrides) {
+    return {
+        id: `agent_${nanoid(8)}`,
+        name: 'test-agent',
+        model: 'mock/test-model',
+        instructions: 'You are a helpful test assistant.',
+        temperature: 0.7,
+        maxIterations: 10,
+        timeout: 30000,
+        tools: [],
+        ...overrides,
+    };
+}
+export function createTestAgent(overrides) {
+    const config = createTestAgentConfig(overrides);
+    return {
+        id: config.id,
+        name: config.name,
+        model: config.model,
+        instructions: config.instructions,
+        tools: config.tools ?? [],
+        config,
+        clone(cloneOverrides) {
+            return createTestAgent({ ...config, ...cloneOverrides, id: undefined });
+        },
+        serialize() {
+            return {
+                version: '1.0',
+                id: config.id,
+                name: config.name,
+                config: {
+                    model: config.model,
+                    instructions: config.instructions,
+                    tools: (config.tools ?? []).map((t) => t.name),
+                    temperature: config.temperature,
+                    maxIterations: config.maxIterations,
+                    timeout: config.timeout,
+                },
+                metadata: {
+                    serializedAt: new Date().toISOString(),
+                },
+            };
+        },
+    };
+}

package/dist/fixtures/index.d.ts

@@ -0,0 +1,5 @@
+export { createTestAgent, createTestAgentConfig, type TestAgentConfig } from './agents';
+export { createUserMessage, createAssistantMessage, createSystemMessage, createToolMessage, createMultimodalMessage, createImageUrlMessage, createToolCall, createToolResult, createConversation, } from './messages';
+export { createTestTool, createCalculatorTool, createWeatherTool, createFailingTool, createSlowTool, createToolSchema, type TestToolOptions, type SimpleTool, } from './tools';
+export { createMockRunResult, createRunResultWithToolCalls, createRunResultWithMessages, type TestRunResultOptions, } from './run-results';
+//# sourceMappingURL=index.d.ts.map

package/dist/fixtures/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/fixtures/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,KAAK,eAAe,EAAE,MAAM,UAAU,CAAC;AAExF,OAAO,EACL,iBAAiB,EACjB,sBAAsB,EACtB,mBAAmB,EACnB,iBAAiB,EACjB,uBAAuB,EACvB,qBAAqB,EACrB,cAAc,EACd,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,cAAc,EACd,oBAAoB,EACpB,iBAAiB,EACjB,iBAAiB,EACjB,cAAc,EACd,gBAAgB,EAChB,KAAK,eAAe,EACpB,KAAK,UAAU,GAChB,MAAM,SAAS,CAAC;AAEjB,OAAO,EACL,mBAAmB,EACnB,4BAA4B,EAC5B,2BAA2B,EAC3B,KAAK,oBAAoB,GAC1B,MAAM,eAAe,CAAC"}

package/dist/fixtures/index.js

@@ -0,0 +1,4 @@
+export { createTestAgent, createTestAgentConfig } from './agents';
+export { createUserMessage, createAssistantMessage, createSystemMessage, createToolMessage, createMultimodalMessage, createImageUrlMessage, createToolCall, createToolResult, createConversation, } from './messages';
+export { createTestTool, createCalculatorTool, createWeatherTool, createFailingTool, createSlowTool, createToolSchema, } from './tools';
+export { createMockRunResult, createRunResultWithToolCalls, createRunResultWithMessages, } from './run-results';

package/dist/fixtures/messages.d.ts

@@ -0,0 +1,14 @@
+import type { Message, ToolCall, ToolResult, ContentPart } from '@cogitator-ai/types';
+export declare function createUserMessage(content: string): Message;
+export declare function createAssistantMessage(content: string): Message;
+export declare function createSystemMessage(content: string): Message;
+export declare function createToolMessage(toolCallId: string, content: string, name?: string): Message;
+export declare function createMultimodalMessage(parts: ContentPart[]): Message;
+export declare function createImageUrlMessage(text: string, imageUrl: string): Message;
+export declare function createToolCall(name: string, args?: Record<string, unknown>): ToolCall;
+export declare function createToolResult(toolCall: ToolCall, result: unknown, error?: string): ToolResult;
+export declare function createConversation(...messages: Array<{
+    role: 'user' | 'assistant';
+    content: string;
+}>): Message[];
+//# sourceMappingURL=messages.d.ts.map

package/dist/fixtures/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../src/fixtures/messages.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAGtF,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAE1D;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAE/D;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAE5D;AAED,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAO7F;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,OAAO,CAErE;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAK7E;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAAG,QAAQ,CAMzF;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,UAAU,CAOhG;AAED,wBAAgB,kBAAkB,CAChC,GAAG,QAAQ,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,GAClE,OAAO,EAAE,CAIX"}

package/dist/fixtures/messages.js

@@ -0,0 +1,45 @@
+import { nanoid } from 'nanoid';
+export function createUserMessage(content) {
+    return { role: 'user', content };
+}
+export function createAssistantMessage(content) {
+    return { role: 'assistant', content };
+}
+export function createSystemMessage(content) {
+    return { role: 'system', content };
+}
+export function createToolMessage(toolCallId, content, name) {
+    return {
+        role: 'tool',
+        content,
+        toolCallId,
+        name,
+    };
+}
+export function createMultimodalMessage(parts) {
+    return { role: 'user', content: parts };
+}
+export function createImageUrlMessage(text, imageUrl) {
+    return createMultimodalMessage([
+        { type: 'text', text },
+        { type: 'image_url', image_url: { url: imageUrl } },
+    ]);
+}
+export function createToolCall(name, args = {}) {
+    return {
+        id: `call_${nanoid(8)}`,
+        name,
+        arguments: args,
+    };
+}
+export function createToolResult(toolCall, result, error) {
+    return {
+        callId: toolCall.id,
+        name: toolCall.name,
+        result,
+        error,
+    };
+}
+export function createConversation(...messages) {
+    return messages.map((m) => m.role === 'user' ? createUserMessage(m.content) : createAssistantMessage(m.content));
+}

package/dist/fixtures/run-results.d.ts

@@ -0,0 +1,8 @@
+import type { RunResult, ToolCall, Message } from '@cogitator-ai/types';
+export interface TestRunResultOptions extends Partial<Omit<RunResult, 'output'>> {
+    output?: string;
+}
+export declare function createMockRunResult(output: string, options?: TestRunResultOptions): RunResult;
+export declare function createRunResultWithToolCalls(output: string, toolCalls: readonly ToolCall[], options?: Partial<RunResult>): RunResult;
+export declare function createRunResultWithMessages(output: string, messages: readonly Message[], options?: Partial<RunResult>): RunResult;
+//# sourceMappingURL=run-results.d.ts.map

package/dist/fixtures/run-results.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-results.d.ts","sourceRoot":"","sources":["../../src/fixtures/run-results.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAExE,MAAM,WAAW,oBAAqB,SAAQ,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;IAC9E,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,oBAAoB,GAAG,SAAS,CAqB7F;AAED,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,SAAS,QAAQ,EAAE,EAC9B,OAAO,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC,GAC3B,SAAS,CAKX;AAED,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,SAAS,OAAO,EAAE,EAC5B,OAAO,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC,GAC3B,SAAS,CAKX"}

package/dist/fixtures/run-results.js

@@ -0,0 +1,35 @@
+import { nanoid } from 'nanoid';
+export function createMockRunResult(output, options) {
+    return {
+        output,
+        runId: options?.runId ?? `run_${nanoid(8)}`,
+        agentId: options?.agentId ?? `agent_${nanoid(8)}`,
+        threadId: options?.threadId ?? `thread_${nanoid(8)}`,
+        usage: options?.usage ?? {
+            inputTokens: 100,
+            outputTokens: 50,
+            totalTokens: 150,
+            cost: 0.001,
+            duration: 100,
+        },
+        toolCalls: options?.toolCalls ?? [],
+        messages: options?.messages ?? [],
+        trace: options?.trace ?? {
+            traceId: `trace_${nanoid(12)}`,
+            spans: [],
+        },
+        ...options,
+    };
+}
+export function createRunResultWithToolCalls(output, toolCalls, options) {
+    return createMockRunResult(output, {
+        ...options,
+        toolCalls,
+    });
+}
+export function createRunResultWithMessages(output, messages, options) {
+    return createMockRunResult(output, {
+        ...options,
+        messages,
+    });
+}

package/dist/fixtures/tools.d.ts

@@ -0,0 +1,20 @@
+import type { ToolSchema, ToolContext } from '@cogitator-ai/types';
+export interface TestToolOptions {
+    name?: string;
+    description?: string;
+    parameters?: ToolSchema['parameters'];
+    execute?: (args: Record<string, unknown>, context: ToolContext) => Promise<unknown>;
+}
+export interface SimpleTool {
+    name: string;
+    description: string;
+    parameters: ToolSchema['parameters'];
+    execute: (args: Record<string, unknown>, context: ToolContext) => Promise<unknown>;
+}
+export declare function createTestTool(options?: TestToolOptions): SimpleTool;
+export declare function createCalculatorTool(): SimpleTool;
+export declare function createWeatherTool(): SimpleTool;
+export declare function createFailingTool(errorMessage?: string): SimpleTool;
+export declare function createSlowTool(delayMs?: number): SimpleTool;
+export declare function createToolSchema(name: string, description?: string): ToolSchema;
+//# sourceMappingURL=tools.d.ts.map

package/dist/fixtures/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../src/fixtures/tools.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEnE,MAAM,WAAW,eAAe;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,UAAU,CAAC,YAAY,CAAC,CAAC;IACtC,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,EAAE,WAAW,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CACrF;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,UAAU,CAAC,YAAY,CAAC,CAAC;IACrC,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,EAAE,WAAW,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CACpF;AAED,wBAAgB,cAAc,CAAC,OAAO,CAAC,EAAE,eAAe,GAAG,UAAU,CAiBpE;AAED,wBAAgB,oBAAoB,IAAI,UAAU,CA8BjD;AAED,wBAAgB,iBAAiB,IAAI,UAAU,CAuB9C;AAED,wBAAgB,iBAAiB,CAAC,YAAY,SAA0B,GAAG,UAAU,CAQpF;AAED,wBAAgB,cAAc,CAAC,OAAO,SAAO,GAAG,UAAU,CASzD;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,UAAU,CAY/E"}

package/dist/fixtures/tools.js

@@ -0,0 +1,106 @@
+import { nanoid } from 'nanoid';
+export function createTestTool(options) {
+    const name = options?.name ?? `test_tool_${nanoid(4)}`;
+    return {
+        name,
+        description: options?.description ?? `A test tool called ${name}`,
+        parameters: options?.parameters ?? {
+            type: 'object',
+            properties: {
+                input: { type: 'string', description: 'Test input' },
+            },
+            required: ['input'],
+        },
+        execute: options?.execute ??
+            (async (args) => ({ result: `Executed ${name} with ${JSON.stringify(args)}` })),
+    };
+}
+export function createCalculatorTool() {
+    return createTestTool({
+        name: 'calculator',
+        description: 'Perform mathematical calculations',
+        parameters: {
+            type: 'object',
+            properties: {
+                expression: { type: 'string', description: 'Mathematical expression to evaluate' },
+            },
+            required: ['expression'],
+        },
+        execute: async (args) => {
+            try {
+                const expression = args.expression;
+                const ops = {
+                    '+': (a, b) => a + b,
+                    '-': (a, b) => a - b,
+                    '*': (a, b) => a * b,
+                    '/': (a, b) => a / b,
+                };
+                const match = /^(\d+)\s*([+\-*/])\s*(\d+)$/.exec(expression);
+                if (!match)
+                    return { error: 'Invalid expression' };
+                const [, a, op, b] = match;
+                const result = ops[op](Number(a), Number(b));
+                return { result };
+            }
+            catch {
+                return { error: 'Invalid expression' };
+            }
+        },
+    });
+}
+export function createWeatherTool() {
+    return createTestTool({
+        name: 'get_weather',
+        description: 'Get the current weather for a location',
+        parameters: {
+            type: 'object',
+            properties: {
+                city: { type: 'string', description: 'City name' },
+                units: {
+                    type: 'string',
+                    enum: ['celsius', 'fahrenheit'],
+                    description: 'Temperature units',
+                },
+            },
+            required: ['city'],
+        },
+        execute: async ({ city, units = 'celsius' }) => ({
+            city,
+            temperature: units === 'celsius' ? 22 : 72,
+            condition: 'sunny',
+            units,
+        }),
+    });
+}
+export function createFailingTool(errorMessage = 'Tool execution failed') {
+    return createTestTool({
+        name: 'failing_tool',
+        description: 'A tool that always fails',
+        execute: async () => {
+            throw new Error(errorMessage);
+        },
+    });
+}
+export function createSlowTool(delayMs = 1000) {
+    return createTestTool({
+        name: 'slow_tool',
+        description: 'A tool that takes time to execute',
+        execute: async (args) => {
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+            return { result: 'completed', delay: delayMs, args };
+        },
+    });
+}
+export function createToolSchema(name, description) {
+    return {
+        name,
+        description: description ?? `Schema for ${name}`,
+        parameters: {
+            type: 'object',
+            properties: {
+                input: { type: 'string' },
+            },
+            required: ['input'],
+        },
+    };
+}

package/dist/helpers/async.d.ts

@@ -0,0 +1,11 @@
+export declare function waitFor<T>(condition: () => T | Promise<T>, options?: {
+    timeout?: number;
+    interval?: number;
+}): Promise<T>;
+export declare function eventually(assertion: () => void | Promise<void>, options?: {
+    timeout?: number;
+    interval?: number;
+}): Promise<void>;
+export declare function delay(ms: number): Promise<void>;
+export declare function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T>;
+//# sourceMappingURL=async.d.ts.map

package/dist/helpers/async.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async.d.ts","sourceRoot":"","sources":["../../src/helpers/async.ts"],"names":[],"mappings":"AAAA,wBAAsB,OAAO,CAAC,CAAC,EAC7B,SAAS,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EAC/B,OAAO,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,GAChD,OAAO,CAAC,CAAC,CAAC,CAcZ;AAED,wBAAsB,UAAU,CAC9B,SAAS,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,EACrC,OAAO,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,GAChD,OAAO,CAAC,IAAI,CAAC,CAiBf;AAED,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/C;AAED,wBAAsB,WAAW,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAKhF"}

package/dist/helpers/async.js

@@ -0,0 +1,37 @@
+export async function waitFor(condition, options) {
+    const timeout = options?.timeout ?? 5000;
+    const interval = options?.interval ?? 50;
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+        const result = await condition();
+        if (result) {
+            return result;
+        }
+        await new Promise((resolve) => setTimeout(resolve, interval));
+    }
+    throw new Error(`waitFor timed out after ${timeout}ms`);
+}
+export async function eventually(assertion, options) {
+    const timeout = options?.timeout ?? 5000;
+    const interval = options?.interval ?? 50;
+    const startTime = Date.now();
+    let lastError;
+    while (Date.now() - startTime < timeout) {
+        try {
+            await assertion();
+            return;
+        }
+        catch (error) {
+            lastError = error;
+            await new Promise((resolve) => setTimeout(resolve, interval));
+        }
+    }
+    throw lastError ?? new Error(`eventually timed out after ${timeout}ms`);
+}
+export function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export async function withTimeout(promise, ms) {
+    const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error(`Operation timed out after ${ms}ms`)), ms));
+    return Promise.race([promise, timeoutPromise]);
+}

package/dist/helpers/index.d.ts

@@ -0,0 +1,3 @@
+export { collectStreamContent, collectStreamChunks, collectStreamToolCalls, createMockReadableStream, } from './streams';
+export { waitFor, eventually, delay, withTimeout } from './async';
+//# sourceMappingURL=index.d.ts.map

package/dist/helpers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/helpers/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,mBAAmB,EACnB,sBAAsB,EACtB,wBAAwB,GACzB,MAAM,WAAW,CAAC;AAEnB,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC"}

package/dist/helpers/index.js

@@ -0,0 +1,2 @@
+export { collectStreamContent, collectStreamChunks, collectStreamToolCalls, createMockReadableStream, } from './streams';
+export { waitFor, eventually, delay, withTimeout } from './async';

package/dist/helpers/streams.d.ts

@@ -0,0 +1,9 @@
+import type { ChatStreamChunk } from '@cogitator-ai/types';
+export declare function collectStreamContent(stream: AsyncGenerator<ChatStreamChunk>): Promise<string>;
+export declare function collectStreamChunks(stream: AsyncGenerator<ChatStreamChunk>): Promise<ChatStreamChunk[]>;
+export declare function collectStreamToolCalls(stream: AsyncGenerator<ChatStreamChunk>): Promise<Array<{
+    name: string;
+    arguments: Record<string, unknown>;
+}>>;
+export declare function createMockReadableStream(chunks: string[]): ReadableStream<Uint8Array>;
+//# sourceMappingURL=streams.d.ts.map

package/dist/helpers/streams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streams.d.ts","sourceRoot":"","sources":["../../src/helpers/streams.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE3D,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,cAAc,CAAC,eAAe,CAAC,GACtC,OAAO,CAAC,MAAM,CAAC,CAQjB;AAED,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,cAAc,CAAC,eAAe,CAAC,GACtC,OAAO,CAAC,eAAe,EAAE,CAAC,CAM5B;AAED,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,cAAc,CAAC,eAAe,CAAC,GACtC,OAAO,CAAC,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CAAC,CAAC,CAiBtE;AAED,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,cAAc,CAAC,UAAU,CAAC,CAarF"}

package/dist/helpers/streams.js

@@ -0,0 +1,46 @@
+export async function collectStreamContent(stream) {
+    let content = '';
+    for await (const chunk of stream) {
+        if (chunk.delta.content) {
+            content += chunk.delta.content;
+        }
+    }
+    return content;
+}
+export async function collectStreamChunks(stream) {
+    const chunks = [];
+    for await (const chunk of stream) {
+        chunks.push(chunk);
+    }
+    return chunks;
+}
+export async function collectStreamToolCalls(stream) {
+    const toolCalls = [];
+    for await (const chunk of stream) {
+        if (chunk.delta.toolCalls) {
+            for (const tc of chunk.delta.toolCalls) {
+                if (tc.name && tc.arguments) {
+                    toolCalls.push({
+                        name: tc.name,
+                        arguments: tc.arguments,
+                    });
+                }
+            }
+        }
+    }
+    return toolCalls;
+}
+export function createMockReadableStream(chunks) {
+    const encoder = new TextEncoder();
+    let index = 0;
+    return new ReadableStream({
+        pull(controller) {
+            if (index < chunks.length) {
+                controller.enqueue(encoder.encode(chunks[index++]));
+            }
+            else {
+                controller.close();
+            }
+        },
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './mocks';
+export * from './fixtures';
+export * from './helpers';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from './mocks';
+export * from './fixtures';
+export * from './helpers';

package/dist/mocks/index.d.ts

@@ -0,0 +1,4 @@
+export { MockLLMBackend, createMockLLMBackend } from './mock-llm-backend';
+export type { MockChatResponse, MockStreamChunk } from './mock-llm-backend';
+export { MockMemoryAdapter, createMockMemoryAdapter } from './mock-memory-adapter';
+//# sourceMappingURL=index.d.ts.map

package/dist/mocks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mocks/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAC1E,YAAY,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAE5E,OAAO,EAAE,iBAAiB,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/mocks/index.js

@@ -0,0 +1,2 @@
+export { MockLLMBackend, createMockLLMBackend } from './mock-llm-backend';
+export { MockMemoryAdapter, createMockMemoryAdapter } from './mock-memory-adapter';

package/dist/mocks/mock-llm-backend.d.ts

@@ -0,0 +1,39 @@
+import type { LLMBackend, LLMProvider, ChatRequest, ChatResponse, ChatStreamChunk, ToolCall } from '@cogitator-ai/types';
+export interface MockChatResponse extends Partial<ChatResponse> {
+    content?: string;
+    toolCalls?: ToolCall[];
+    finishReason?: ChatResponse['finishReason'];
+    error?: Error;
+    delay?: number;
+}
+export interface MockStreamChunk {
+    content?: string;
+    toolCalls?: Partial<ToolCall>[];
+    finishReason?: ChatStreamChunk['finishReason'];
+    delay?: number;
+}
+export declare class MockLLMBackend implements LLMBackend {
+    readonly provider: LLMProvider;
+    private responses;
+    private streamChunks;
+    private _calls;
+    private responseIndex;
+    private streamIndex;
+    private defaultDelay;
+    setResponse(response: MockChatResponse): this;
+    setResponses(responses: MockChatResponse[]): this;
+    setToolCallResponse(toolCalls: ToolCall[], content?: string): this;
+    setStreamChunks(chunks: MockStreamChunk[]): this;
+    setMultipleStreamChunks(chunksArray: MockStreamChunk[][]): this;
+    setDefaultDelay(ms: number): this;
+    getCalls(): ChatRequest[];
+    getLastCall(): ChatRequest | undefined;
+    getCallCount(): number;
+    wasCalledWith(predicate: (req: ChatRequest) => boolean): boolean;
+    reset(): void;
+    chat(request: ChatRequest): Promise<ChatResponse>;
+    chatStream(request: ChatRequest): AsyncGenerator<ChatStreamChunk>;
+    private estimateTokens;
+}
+export declare function createMockLLMBackend(): MockLLMBackend;
+//# sourceMappingURL=mock-llm-backend.d.ts.map

package/dist/mocks/mock-llm-backend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-llm-backend.d.ts","sourceRoot":"","sources":["../../src/mocks/mock-llm-backend.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,UAAU,EACV,WAAW,EACX,WAAW,EACX,YAAY,EACZ,eAAe,EACf,QAAQ,EACT,MAAM,qBAAqB,CAAC;AAE7B,MAAM,WAAW,gBAAiB,SAAQ,OAAO,CAAC,YAAY,CAAC;IAC7D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,QAAQ,EAAE,CAAC;IACvB,YAAY,CAAC,EAAE,YAAY,CAAC,cAAc,CAAC,CAAC;IAC5C,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;IAChC,YAAY,CAAC,EAAE,eAAe,CAAC,cAAc,CAAC,CAAC;IAC/C,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,cAAe,YAAW,UAAU;IAC/C,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAY;IAE1C,OAAO,CAAC,SAAS,CAA0B;IAC3C,OAAO,CAAC,YAAY,CAA2B;IAC/C,OAAO,CAAC,MAAM,CAAqB;IACnC,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,YAAY,CAAK;IAEzB,WAAW,CAAC,QAAQ,EAAE,gBAAgB,GAAG,IAAI;IAM7C,YAAY,CAAC,SAAS,EAAE,gBAAgB,EAAE,GAAG,IAAI;IAMjD,mBAAmB,CAAC,SAAS,EAAE,QAAQ,EAAE,EAAE,OAAO,SAAK,GAAG,IAAI;IAQ9D,eAAe,CAAC,MAAM,EAAE,eAAe,EAAE,GAAG,IAAI;IAMhD,uBAAuB,CAAC,WAAW,EAAE,eAAe,EAAE,EAAE,GAAG,IAAI;IAM/D,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAKjC,QAAQ,IAAI,WAAW,EAAE;IAIzB,WAAW,IAAI,WAAW,GAAG,SAAS;IAItC,YAAY,IAAI,MAAM;IAItB,aAAa,CAAC,SAAS,EAAE,CAAC,GAAG,EAAE,WAAW,KAAK,OAAO,GAAG,OAAO;IAIhE,KAAK,IAAI,IAAI;IAQP,IAAI,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IAuChD,UAAU,CAAC,OAAO,EAAE,WAAW,GAAG,cAAc,CAAC,eAAe,CAAC;IAsDxE,OAAO,CAAC,cAAc;CASvB;AAED,wBAAgB,oBAAoB,IAAI,cAAc,CAErD"}

package/dist/mocks/mock-llm-backend.js

@@ -0,0 +1,149 @@
+import { nanoid } from 'nanoid';
+export class MockLLMBackend {
+    provider = 'openai';
+    responses = [];
+    streamChunks = [];
+    _calls = [];
+    responseIndex = 0;
+    streamIndex = 0;
+    defaultDelay = 0;
+    setResponse(response) {
+        this.responses = [response];
+        this.responseIndex = 0;
+        return this;
+    }
+    setResponses(responses) {
+        this.responses = responses;
+        this.responseIndex = 0;
+        return this;
+    }
+    setToolCallResponse(toolCalls, content = '') {
+        return this.setResponse({
+            content,
+            toolCalls,
+            finishReason: 'tool_calls',
+        });
+    }
+    setStreamChunks(chunks) {
+        this.streamChunks = [chunks];
+        this.streamIndex = 0;
+        return this;
+    }
+    setMultipleStreamChunks(chunksArray) {
+        this.streamChunks = chunksArray;
+        this.streamIndex = 0;
+        return this;
+    }
+    setDefaultDelay(ms) {
+        this.defaultDelay = ms;
+        return this;
+    }
+    getCalls() {
+        return [...this._calls];
+    }
+    getLastCall() {
+        return this._calls[this._calls.length - 1];
+    }
+    getCallCount() {
+        return this._calls.length;
+    }
+    wasCalledWith(predicate) {
+        return this._calls.some(predicate);
+    }
+    reset() {
+        this._calls = [];
+        this.responses = [];
+        this.streamChunks = [];
+        this.responseIndex = 0;
+        this.streamIndex = 0;
+    }
+    async chat(request) {
+        this._calls.push(request);
+        const mockResponse = this.responses[this.responseIndex] ?? this.responses[0];
+        if (this.responseIndex < this.responses.length - 1) {
+            this.responseIndex++;
+        }
+        if (mockResponse?.error) {
+            throw mockResponse.error;
+        }
+        const delay = mockResponse?.delay ?? this.defaultDelay;
+        if (delay > 0) {
+            await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+        const id = `mock_${nanoid(8)}`;
+        const content = mockResponse?.content ?? '';
+        const toolCalls = mockResponse?.toolCalls;
+        const finishReason = mockResponse?.finishReason ?? (toolCalls ? 'tool_calls' : 'stop');
+        const inputTokens = mockResponse?.usage?.inputTokens ?? this.estimateTokens(request.messages);
+        const outputTokens = mockResponse?.usage?.outputTokens ?? Math.ceil(content.length / 4);
+        return {
+            id,
+            content,
+            toolCalls,
+            finishReason,
+            usage: {
+                inputTokens,
+                outputTokens,
+                totalTokens: inputTokens + outputTokens,
+                ...mockResponse?.usage,
+            },
+        };
+    }
+    async *chatStream(request) {
+        this._calls.push(request);
+        const chunks = this.streamChunks[this.streamIndex] ?? this.streamChunks[0] ?? [];
+        if (this.streamIndex < this.streamChunks.length - 1) {
+            this.streamIndex++;
+        }
+        const id = `mock_stream_${nanoid(8)}`;
+        let totalContent = '';
+        for (let i = 0; i < chunks.length; i++) {
+            const chunk = chunks[i];
+            const delay = chunk.delay ?? this.defaultDelay;
+            if (delay > 0) {
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+            if (chunk.content) {
+                totalContent += chunk.content;
+            }
+            const isLast = i === chunks.length - 1;
+            const inputTokens = this.estimateTokens(request.messages);
+            const outputTokens = Math.ceil(totalContent.length / 4);
+            yield {
+                id,
+                delta: {
+                    content: chunk.content,
+                    toolCalls: chunk.toolCalls,
+                },
+                finishReason: isLast ? (chunk.finishReason ?? 'stop') : undefined,
+                usage: isLast
+                    ? {
+                        inputTokens,
+                        outputTokens,
+                        totalTokens: inputTokens + outputTokens,
+                    }
+                    : undefined,
+            };
+        }
+        if (chunks.length === 0) {
+            yield {
+                id,
+                delta: { content: '' },
+                finishReason: 'stop',
+                usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+            };
+        }
+    }
+    estimateTokens(messages) {
+        let total = 0;
+        for (const msg of messages) {
+            if (typeof msg.content === 'string') {
+                total += Math.ceil(msg.content.length / 4);
+            }
+        }
+        return Math.max(total, 1);
+    }
+}
+export function createMockLLMBackend() {
+    return new MockLLMBackend();
+}

package/dist/mocks/mock-memory-adapter.d.ts

@@ -0,0 +1,31 @@
+import type { MemoryAdapter, MemoryEntry, Thread, MemoryResult, MemoryProvider, MemoryQueryOptions } from '@cogitator-ai/types';
+export declare class MockMemoryAdapter implements MemoryAdapter {
+    readonly provider: MemoryProvider;
+    private threads;
+    private entries;
+    private _connected;
+    private _calls;
+    connect(): Promise<MemoryResult<void>>;
+    disconnect(): Promise<MemoryResult<void>>;
+    isConnected(): boolean;
+    createThread(agentId: string, metadata?: Record<string, unknown>, threadId?: string): Promise<MemoryResult<Thread>>;
+    getThread(threadId: string): Promise<MemoryResult<Thread | null>>;
+    updateThread(threadId: string, metadata: Record<string, unknown>): Promise<MemoryResult<Thread>>;
+    deleteThread(threadId: string): Promise<MemoryResult<void>>;
+    addEntry(entry: Omit<MemoryEntry, 'id' | 'createdAt'>): Promise<MemoryResult<MemoryEntry>>;
+    getEntries(options: MemoryQueryOptions): Promise<MemoryResult<MemoryEntry[]>>;
+    getEntry(entryId: string): Promise<MemoryResult<MemoryEntry | null>>;
+    deleteEntry(entryId: string): Promise<MemoryResult<void>>;
+    clearThread(threadId: string): Promise<MemoryResult<void>>;
+    getCalls(): Array<{
+        method: string;
+        args: unknown[];
+    }>;
+    getCallsFor(method: string): Array<{
+        method: string;
+        args: unknown[];
+    }>;
+    reset(): void;
+}
+export declare function createMockMemoryAdapter(): MockMemoryAdapter;
+//# sourceMappingURL=mock-memory-adapter.d.ts.map

package/dist/mocks/mock-memory-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-memory-adapter.d.ts","sourceRoot":"","sources":["../../src/mocks/mock-memory-adapter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,aAAa,EACb,WAAW,EACX,MAAM,EACN,YAAY,EACZ,cAAc,EACd,kBAAkB,EACnB,MAAM,qBAAqB,CAAC;AAE7B,qBAAa,iBAAkB,YAAW,aAAa;IACrD,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAY;IAE7C,OAAO,CAAC,OAAO,CAA6B;IAC5C,OAAO,CAAC,OAAO,CAAoC;IACnD,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,MAAM,CAAkD;IAE1D,OAAO,IAAI,OAAO,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAMtC,UAAU,IAAI,OAAO,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAM/C,WAAW,IAAI,OAAO;IAIhB,YAAY,CAChB,OAAO,EAAE,MAAM,EACf,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClC,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;IAiB1B,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAMjE,YAAY,CAChB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,OAAO,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;IAc1B,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAO3D,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,GAAG,WAAW,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,WAAW,CAAC,CAAC;IAqB1F,UAAU,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,YAAY,CAAC,WAAW,EAAE,CAAC,CAAC;IAoB7E,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;IAapE,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAezD,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAMhE,QAAQ,IAAI,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,EAAE,CAAA;KAAE,CAAC;IAItD,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,EAAE,CAAA;KAAE,CAAC;IAIvE,KAAK,IAAI,IAAI;CAMd;AAED,wBAAgB,uBAAuB,IAAI,iBAAiB,CAE3D"}

package/dist/mocks/mock-memory-adapter.js

@@ -0,0 +1,128 @@
+import { nanoid } from 'nanoid';
+export class MockMemoryAdapter {
+    provider = 'memory';
+    threads = new Map();
+    entries = new Map();
+    _connected = false;
+    _calls = [];
+    async connect() {
+        this._calls.push({ method: 'connect', args: [] });
+        this._connected = true;
+        return { success: true, data: undefined };
+    }
+    async disconnect() {
+        this._calls.push({ method: 'disconnect', args: [] });
+        this._connected = false;
+        return { success: true, data: undefined };
+    }
+    isConnected() {
+        return this._connected;
+    }
+    async createThread(agentId, metadata, threadId) {
+        this._calls.push({ method: 'createThread', args: [agentId, metadata, threadId] });
+        const thread = {
+            id: threadId ?? `thread_${nanoid(8)}`,
+            agentId,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+            metadata: metadata ?? {},
+        };
+        this.threads.set(thread.id, thread);
+        this.entries.set(thread.id, []);
+        return { success: true, data: thread };
+    }
+    async getThread(threadId) {
+        this._calls.push({ method: 'getThread', args: [threadId] });
+        const thread = this.threads.get(threadId) ?? null;
+        return { success: true, data: thread };
+    }
+    async updateThread(threadId, metadata) {
+        this._calls.push({ method: 'updateThread', args: [threadId, metadata] });
+        const thread = this.threads.get(threadId);
+        if (!thread) {
+            return { success: false, error: `Thread ${threadId} not found` };
+        }
+        thread.metadata = { ...thread.metadata, ...metadata };
+        thread.updatedAt = new Date();
+        return { success: true, data: thread };
+    }
+    async deleteThread(threadId) {
+        this._calls.push({ method: 'deleteThread', args: [threadId] });
+        this.threads.delete(threadId);
+        this.entries.delete(threadId);
+        return { success: true, data: undefined };
+    }
+    async addEntry(entry) {
+        this._calls.push({ method: 'addEntry', args: [entry] });
+        const memoryEntry = {
+            id: `entry_${nanoid(8)}`,
+            threadId: entry.threadId,
+            message: entry.message,
+            tokenCount: entry.tokenCount ?? 0,
+            createdAt: new Date(),
+            toolCalls: entry.toolCalls,
+            toolResults: entry.toolResults,
+            metadata: entry.metadata,
+        };
+        const threadEntries = this.entries.get(entry.threadId) ?? [];
+        threadEntries.push(memoryEntry);
+        this.entries.set(entry.threadId, threadEntries);
+        return { success: true, data: memoryEntry };
+    }
+    async getEntries(options) {
+        this._calls.push({ method: 'getEntries', args: [options] });
+        let entries = this.entries.get(options.threadId) ?? [];
+        if (options.before) {
+            entries = entries.filter((e) => e.createdAt < options.before);
+        }
+        if (options.after) {
+            entries = entries.filter((e) => e.createdAt > options.after);
+        }
+        if (options.limit) {
+            entries = entries.slice(-options.limit);
+        }
+        return { success: true, data: entries };
+    }
+    async getEntry(entryId) {
+        this._calls.push({ method: 'getEntry', args: [entryId] });
+        for (const threadEntries of this.entries.values()) {
+            const entry = threadEntries.find((e) => e.id === entryId);
+            if (entry) {
+                return { success: true, data: entry };
+            }
+        }
+        return { success: true, data: null };
+    }
+    async deleteEntry(entryId) {
+        this._calls.push({ method: 'deleteEntry', args: [entryId] });
+        for (const [threadId, threadEntries] of this.entries.entries()) {
+            const index = threadEntries.findIndex((e) => e.id === entryId);
+            if (index !== -1) {
+                threadEntries.splice(index, 1);
+                this.entries.set(threadId, threadEntries);
+                break;
+            }
+        }
+        return { success: true, data: undefined };
+    }
+    async clearThread(threadId) {
+        this._calls.push({ method: 'clearThread', args: [threadId] });
+        this.entries.set(threadId, []);
+        return { success: true, data: undefined };
+    }
+    getCalls() {
+        return [...this._calls];
+    }
+    getCallsFor(method) {
+        return this._calls.filter((c) => c.method === method);
+    }
+    reset() {
+        this.threads.clear();
+        this.entries.clear();
+        this._calls = [];
+        this._connected = false;
+    }
+}
+export function createMockMemoryAdapter() {
+    return new MockMemoryAdapter();
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@cogitator-ai/test-utils",
+  "version": "0.1.3",
+  "description": "Shared testing utilities for Cogitator packages",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@cogitator-ai/types": "workspace:*",
+    "nanoid": "^5.0.4"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0",
+    "vitest": "^4.0.18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cogitator-ai/Cogitator-AI.git",
+    "directory": "packages/test-utils"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://npm.pkg.github.com"
+  },
+  "license": "MIT"
+}