@ddwang/magnitude-core 0.3.1-ddwang.2 → 0.3.1-ddwang.21

package/dist/memory/rendering/renderJsonParts.js

@@ -1,115 +0,0 @@
-import { Image } from "@/memory/image";
-import { Image as BamlImage } from '@boundaryml/baml';
-async function buildJsonPartsRecursive(data, partsList, indent, currentLevel = 0, isRoot = false) {
-    if (data instanceof Image) {
-        const bamlImg = await data.toBaml();
-        if (bamlImg) {
-            partsList.push(bamlImg);
-        }
-        return;
-    }
-    if (data instanceof BamlImage) {
-        partsList.push(data);
-        return;
-    }
-    if (data === null) {
-        partsList.push('null');
-        return;
-    }
-    if (data === undefined) {
-        return; // Undefined values are omitted in JSON
-    }
-    if (typeof data === 'string') {
-        if (isRoot) {
-            partsList.push(data);
-        }
-        else {
-            partsList.push(JSON.stringify(data));
-        }
-        return;
-    }
-    if (typeof data === 'number' || typeof data === 'boolean') {
-        partsList.push(String(data));
-        return;
-    }
-    const newline = indent > 0 ? '\n' : '';
-    const spacing = indent > 0 ? ' '.repeat(currentLevel * indent) : '';
-    const nextSpacing = indent > 0 ? ' '.repeat((currentLevel + 1) * indent) : '';
-    if (Array.isArray(data)) {
-        partsList.push('[');
-        for (let index = 0; index < data.length; index++) {
-            const item = data[index];
-            if (item !== undefined) { // Skip undefined values in arrays
-                if (index > 0) {
-                    partsList.push(',');
-                }
-                if (indent > 0) {
-                    partsList.push(newline + nextSpacing);
-                }
-                else if (index > 0) {
-                    partsList.push(' ');
-                }
-                await buildJsonPartsRecursive(item, partsList, indent, currentLevel + 1, false);
-            }
-        }
-        if (data.length > 0 && indent > 0) {
-            partsList.push(newline + spacing);
-        }
-        partsList.push(']');
-        return;
-    }
-    if (typeof data === 'object' && data !== null) {
-        partsList.push('{');
-        const entries = Object.entries(data).filter(([, val]) => val !== undefined);
-        for (let index = 0; index < entries.length; index++) {
-            const [key, value] = entries[index];
-            if (index > 0) {
-                partsList.push(',');
-            }
-            if (indent > 0) {
-                partsList.push(newline + nextSpacing);
-            }
-            else if (index > 0) {
-                partsList.push(' ');
-            }
-            // Add the key
-            partsList.push(JSON.stringify(key));
-            partsList.push(': ');
-            // Add the value
-            await buildJsonPartsRecursive(value, partsList, indent, currentLevel + 1, false);
-        }
-        if (entries.length > 0 && indent > 0) {
-            partsList.push(newline + spacing);
-        }
-        partsList.push('}');
-        return;
-    }
-    throw new Error(`Object type not supported for JSON rendering: '${typeof data}'. Data: ${data}`);
-}
-export async function renderJsonParts(data, indent) {
-    const rawList = [];
-    await buildJsonPartsRecursive(data, rawList, indent, 0, true);
-    // Merge adjacent strings
-    if (rawList.length === 0) {
-        return [];
-    }
-    const mergedList = [];
-    let currentString = "";
-    for (const item of rawList) {
-        if (typeof item === 'string') {
-            currentString += item;
-        }
-        else { // It's a BamlImage
-            if (currentString.length > 0) {
-                mergedList.push(currentString);
-            }
-            currentString = ""; // Reset accumulator
-            mergedList.push(item); // Push the BamlImage
-        }
-    }
-    // Add any trailing string
-    if (currentString.length > 0) {
-        mergedList.push(currentString);
-    }
-    return mergedList;
-}

package/dist/memory/rendering/renderJsonParts.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/memory/rendering/renderJsonParts.test.js

@@ -1,217 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { renderJsonParts } from './renderJsonParts';
-import { Image } from '@/memory/image';
-import sharp from 'sharp';
-// Create a mock Image that will convert to BamlImage
-class MockImage extends Image {
-    id;
-    constructor(id) {
-        super(sharp());
-        this.id = id;
-    }
-    async toBaml() {
-        // Return a mock BamlImage
-        return {
-            __mockBamlImage: true,
-            id: this.id
-        };
-    }
-}
-describe('renderJsonParts', () => {
-    test('renders primitive types correctly', async () => {
-        expect(await renderJsonParts('hello', 0)).toEqual(['hello']);
-        expect(await renderJsonParts(42, 0)).toEqual(['42']);
-        expect(await renderJsonParts(true, 0)).toEqual(['true']);
-        expect(await renderJsonParts(false, 0)).toEqual(['false']);
-        expect(await renderJsonParts(null, 0)).toEqual(['null']);
-    });
-    test('renders root-level strings without quotes', async () => {
-        expect(await renderJsonParts('CLICK THE UNICORN', 0)).toEqual(['CLICK THE UNICORN']);
-        expect(await renderJsonParts('Hello World', 0)).toEqual(['Hello World']);
-        expect(await renderJsonParts('{"already":"json"}', 0)).toEqual(['{"already":"json"}']);
-    });
-    test('properly quotes strings inside objects and arrays', async () => {
-        // Strings in objects should be quoted
-        expect(await renderJsonParts({ message: 'hello' }, 0)).toEqual(['{"message": "hello"}']);
-        expect(await renderJsonParts({ name: 'John', city: 'NYC' }, 0)).toEqual(['{"name": "John", "city": "NYC"}']);
-        // Strings in arrays should be quoted
-        expect(await renderJsonParts(['apple', 'banana'], 0)).toEqual(['["apple", "banana"]']);
-        expect(await renderJsonParts(['hello', 123, 'world'], 0)).toEqual(['["hello", 123, "world"]']);
-        // Nested structures
-        expect(await renderJsonParts({ items: ['a', 'b'], text: 'test' }, 0)).toEqual(['{"items": ["a", "b"], "text": "test"}']);
-    });
-    test('renders empty structures', async () => {
-        expect(await renderJsonParts([], 0)).toEqual(['[]']);
-        expect(await renderJsonParts({}, 0)).toEqual(['{}']);
-    });
-    test('renders simple arrays', async () => {
-        expect(await renderJsonParts([1, 2, 3], 0)).toEqual(['[1, 2, 3]']);
-        expect(await renderJsonParts(['a', 'b', 'c'], 0)).toEqual(['["a", "b", "c"]']);
-        expect(await renderJsonParts([true, false, null], 0)).toEqual(['[true, false, null]']);
-    });
-    test('renders simple objects', async () => {
-        expect(await renderJsonParts({ name: 'John', age: 30 }, 0)).toEqual(['{"name": "John", "age": 30}']);
-        expect(await renderJsonParts({ a: 1, b: true, c: null }, 0)).toEqual(['{"a": 1, "b": true, "c": null}']);
-    });
-    test('handles undefined values correctly', async () => {
-        // Undefined at root level returns empty array
-        expect(await renderJsonParts(undefined, 0)).toEqual([]);
-        // Undefined in arrays is skipped
-        expect(await renderJsonParts([1, undefined, 3], 0)).toEqual(['[1, 3]']);
-        // Undefined in objects is omitted
-        expect(await renderJsonParts({ a: 1, b: undefined, c: 3 }, 0)).toEqual(['{"a": 1, "c": 3}']);
-    });
-    test('renders nested structures', async () => {
-        const nested = {
-            user: {
-                name: 'Alice',
-                scores: [95, 87, 92],
-                active: true
-            },
-            metadata: {
-                created: '2024-01-01',
-                tags: ['important', 'verified']
-            }
-        };
-        const result = await renderJsonParts(nested, 0);
-        expect(result).toEqual(['{"user": {"name": "Alice", "scores": [95, 87, 92], "active": true}, "metadata": {"created": "2024-01-01", "tags": ["important", "verified"]}}']);
-    });
-    test('splits JSON around BamlImage in object', async () => {
-        const mockImage = new MockImage('img1');
-        const data = {
-            title: 'Product',
-            image: mockImage,
-            price: 29.99
-        };
-        const result = await renderJsonParts(data, 0);
-        expect(result.length).toBe(3);
-        expect(result[0]).toBe('{"title": "Product", "image": ');
-        expect(result[1]).toHaveProperty('__mockBamlImage', true);
-        expect(result[2]).toBe(', "price": 29.99}');
-    });
-    test('splits JSON around multiple BamlImages in object', async () => {
-        const mockImage1 = new MockImage('img1');
-        const mockImage2 = new MockImage('img2');
-        const data = {
-            before: 'text',
-            image1: mockImage1,
-            middle: 'more text',
-            image2: mockImage2,
-            after: 'final'
-        };
-        const result = await renderJsonParts(data, 0);
-        expect(result.length).toBe(5);
-        expect(result[0]).toBe('{"before": "text", "image1": ');
-        expect(result[1]).toHaveProperty('__mockBamlImage', true);
-        expect(result[2]).toBe(', "middle": "more text", "image2": ');
-        expect(result[3]).toHaveProperty('__mockBamlImage', true);
-        expect(result[4]).toBe(', "after": "final"}');
-    });
-    test('splits JSON around BamlImage in array', async () => {
-        const mockImage = new MockImage('img1');
-        const data = ['start', mockImage, 'end'];
-        const result = await renderJsonParts(data, 0);
-        expect(result.length).toBe(3);
-        expect(result[0]).toBe('["start", ');
-        expect(result[1]).toHaveProperty('__mockBamlImage', true);
-        expect(result[2]).toBe(', "end"]');
-    });
-    test('handles array with only BamlImages', async () => {
-        const mockImage1 = new MockImage('img1');
-        const mockImage2 = new MockImage('img2');
-        const data = [mockImage1, mockImage2];
-        const result = await renderJsonParts(data, 0);
-        expect(result.length).toBe(5);
-        expect(result[0]).toBe('[');
-        expect(result[1]).toHaveProperty('__mockBamlImage', true);
-        expect(result[2]).toBe(', ');
-        expect(result[3]).toHaveProperty('__mockBamlImage', true);
-        expect(result[4]).toBe(']');
-    });
-    test('handles nested structures with images', async () => {
-        const mockImage = new MockImage('img1');
-        const data = {
-            user: {
-                name: 'Bob',
-                avatar: mockImage,
-                settings: {
-                    theme: 'dark'
-                }
-            },
-            posts: [
-                { id: 1, image: mockImage, text: 'Hello' }
-            ]
-        };
-        const result = await renderJsonParts(data, 0);
-        // Should have multiple parts due to images
-        expect(result.length).toBeGreaterThan(1);
-        // First part should start with JSON
-        expect(result[0]).toMatch(/^{"user": /);
-        // Should contain the mock images
-        const imageParts = result.filter(part => part && typeof part === 'object' && '__mockBamlImage' in part);
-        expect(imageParts.length).toBe(2);
-    });
-    test('handles edge case with image as first array element', async () => {
-        const mockImage = new MockImage('img1');
-        const data = [mockImage, 'text'];
-        const result = await renderJsonParts(data, 0);
-        expect(result.length).toBe(3);
-        expect(result[0]).toBe('[');
-        expect(result[1]).toHaveProperty('__mockBamlImage', true);
-        expect(result[2]).toBe(', "text"]');
-    });
-    test('handles edge case with image as last array element', async () => {
-        const mockImage = new MockImage('img1');
-        const data = ['text', mockImage];
-        const result = await renderJsonParts(data, 0);
-        expect(result.length).toBe(3);
-        expect(result[0]).toBe('["text", ');
-        expect(result[1]).toHaveProperty('__mockBamlImage', true);
-        expect(result[2]).toBe(']');
-    });
-    test('properly escapes special characters in strings', async () => {
-        const data = {
-            quote: 'He said "Hello"',
-            newline: 'Line 1\nLine 2',
-            tab: 'Col1\tCol2',
-            backslash: 'C:\\Users\\Path'
-        };
-        const result = await renderJsonParts(data, 0);
-        expect(result[0]).toContain('\\"Hello\\"');
-        expect(result[0]).toContain('\\n');
-        expect(result[0]).toContain('\\t');
-        expect(result[0]).toContain('\\\\');
-    });
-    test('renders with proper indentation when indent is 2', async () => {
-        const data = {
-            name: 'John',
-            age: 30,
-            hobbies: ['reading', 'coding']
-        };
-        const result = await renderJsonParts(data, 2);
-        expect(result).toEqual(['{\n  "name": "John",\n  "age": 30,\n  "hobbies": [\n    "reading",\n    "coding"\n  ]\n}']);
-    });
-    test('renders with proper indentation when indent is 4', async () => {
-        const data = {
-            user: {
-                name: 'Alice',
-                active: true
-            }
-        };
-        const result = await renderJsonParts(data, 4);
-        expect(result).toEqual(['{\n    "user": {\n        "name": "Alice",\n        "active": true\n    }\n}']);
-    });
-    test('handles indentation with images', async () => {
-        const mockImage = new MockImage('img1');
-        const data = {
-            title: 'Product',
-            image: mockImage,
-            price: 29.99
-        };
-        const result = await renderJsonParts(data, 2);
-        expect(result.length).toBe(3);
-        expect(result[0]).toBe('{\n  "title": "Product",\n  "image": ');
-        expect(result[1]).toHaveProperty('__mockBamlImage', true);
-        expect(result[2]).toBe(',\n  "price": 29.99\n}');
-    });
-});

package/dist/memory/rendering/renderXmlParts.d.ts

@@ -1,7 +0,0 @@
-/**
- * Convert observations to form that can be passed as BAML context, rendered as a custom XML-like structure.
- */
-import { Image as BamlImage } from '@boundaryml/baml';
-import { RenderableContent } from '@/memory/observation';
-export type MultiMediaContentPart = BamlImage | string;
-export declare function renderXmlParts(data: RenderableContent): Promise<MultiMediaContentPart[]>;

package/dist/memory/rendering/renderXmlParts.js

@@ -1,127 +0,0 @@
-/**
- * Convert observations to form that can be passed as BAML context, rendered as a custom XML-like structure.
- */
-import { Image as BamlImage } from '@boundaryml/baml';
-import { Image } from '@/memory/image';
-//export type BamlRenderable = BamlImage | string;
-// export type BamlRenderable = {
-//     role: ''
-//     content: (BamlImage | string)[]
-// }
-async function buildXmlPartsRecursive(data, indentLevel, partsList, isInsideList = false) {
-    const indent = '  '.repeat(indentLevel);
-    if (data instanceof Image) {
-        const bamlImg = await data.toBaml();
-        if (bamlImg) {
-            partsList.push(bamlImg);
-        }
-        return;
-    }
-    if (data instanceof BamlImage) {
-        partsList.push(data);
-        return;
-    }
-    if (typeof data === 'string' || typeof data === 'number' || typeof data === 'boolean' || data === null) {
-        partsList.push(String(data)); // No XML escaping, direct string conversion
-        return;
-    }
-    if (data === undefined) {
-        return; // Undefined values are omitted
-    }
-    if (Array.isArray(data)) {
-        // data.forEach(async (item, index) => {
-        //     await buildXmlPartsRecursive(item, indentLevel, partsList, true);
-        //     if (index < data.length - 1) {
-        //         partsList.push("\n");
-        //     }
-        // });
-        for (let index = 0; index < data.length; index++) {
-            await buildXmlPartsRecursive(data[index], indentLevel, partsList, true);
-            if (index < data.length - 1) {
-                partsList.push("\n");
-            }
-        }
-        return;
-    }
-    if (typeof data === 'object' && data !== null) {
-        const objectEntries = Object.entries(data).filter(([, val]) => val !== undefined);
-        objectEntries.forEach(async ([key, value], entryIndex) => {
-            const tagName = key; // Use key directly as tag name
-            const currentValueParts = [];
-            await buildXmlPartsRecursive(value, indentLevel + 1, currentValueParts, false);
-            // Merge adjacent strings in currentValueParts for easier analysis
-            const mergedValueParts = [];
-            let currentStr = "";
-            for (const part of currentValueParts) {
-                if (typeof part === 'string') {
-                    currentStr += part;
-                }
-                else {
-                    if (currentStr)
-                        mergedValueParts.push(currentStr);
-                    currentStr = "";
-                    mergedValueParts.push(part);
-                }
-            }
-            if (currentStr)
-                mergedValueParts.push(currentStr);
-            // Apply styling rules
-            if (mergedValueParts.length === 1 && mergedValueParts[0] instanceof BamlImage) {
-                partsList.push(`${indent}<${tagName}>`);
-                partsList.push(mergedValueParts[0]); // The BamlImage
-                partsList.push(`</${tagName}>`);
-            }
-            else if (mergedValueParts.length === 1 && typeof mergedValueParts[0] === 'string') {
-                const contentStr = mergedValueParts[0];
-                if (contentStr.includes('\n')) {
-                    partsList.push(`${indent}<${tagName}>\n${contentStr}\n${indent}</${tagName}>`);
-                }
-                else {
-                    partsList.push(`${indent}<${tagName}>${contentStr}</${tagName}>`);
-                }
-            }
-            else { // Empty content or multiple parts (complex/nested)
-                partsList.push(`${indent}<${tagName}>\n`);
-                mergedValueParts.forEach((part, partIdx) => {
-                    partsList.push(part);
-                    if (partIdx < mergedValueParts.length - 1) {
-                        partsList.push("\n");
-                    }
-                });
-                partsList.push(`\n${indent}</${tagName}>`);
-            }
-            if (entryIndex < objectEntries.length - 1) {
-                partsList.push("\n"); // Newline between sibling XML elements
-            }
-        });
-        return;
-    }
-    throw new Error(`Object type not supported for LLM context: ${typeof data}`);
-}
-export async function renderXmlParts(data) {
-    const rawList = [];
-    await buildXmlPartsRecursive(data, 0, rawList);
-    // Merge adjacent strings
-    if (rawList.length === 0) {
-        return [];
-    }
-    const mergedList = [];
-    let currentString = "";
-    for (const item of rawList) {
-        if (typeof item === 'string') {
-            currentString += item;
-        }
-        else { // It's a BamlImage
-            if (currentString.length > 0) {
-                mergedList.push(currentString);
-            }
-            currentString = ""; // Reset accumulator
-            mergedList.push(item); // Push the BamlImage
-        }
-    }
-    // Add any trailing string
-    if (currentString.length > 0) {
-        mergedList.push(currentString);
-    }
-    return mergedList;
-}

package/dist/memory/serde.d.ts

@@ -1,20 +0,0 @@
-import { RenderableContent } from "./observation";
-export type StoredMedia = {
-    type: 'media';
-    format: string;
-    storage: 'base64';
-    base64: string;
-};
-export interface StoredPrimitive {
-    type: 'primitive';
-    content: string | boolean | number;
-}
-type MultiMediaPrimitive = StoredMedia | StoredPrimitive | undefined | null;
-type MultiMediaArray = Array<MultiMediaJson>;
-export type MultiMediaObject = {
-    [key: string]: MultiMediaJson;
-};
-export type MultiMediaJson = MultiMediaPrimitive | MultiMediaArray | MultiMediaObject;
-export declare function observableDataToJson(data: RenderableContent): Promise<MultiMediaJson>;
-export declare function jsonToObservableData(data: MultiMediaJson): Promise<RenderableContent>;
-export {};

package/dist/memory/serde.js

@@ -1,67 +0,0 @@
-import { Image } from './image';
-export async function observableDataToJson(data) {
-    if (data instanceof Image) {
-        return await data.toJson(); //return imageToJson(data);
-    }
-    if (typeof data === 'string' || typeof data === 'number' || typeof data === 'boolean') {
-        return { type: "primitive", content: data };
-    }
-    if (data === undefined) {
-        return undefined; // JSON.stringify will omit keys with this value or handle standalone undefined
-    }
-    if (data === null) {
-        return null;
-    }
-    if (Array.isArray(data)) {
-        // Filter out undefined items first, then map and process the rest.
-        return Promise.all(data
-            .filter(item => item !== undefined)
-            .map(item => observableDataToJson(item)));
-    }
-    if (typeof data === 'object') { // Known not to be null or array here
-        const entries = await Promise.all(Object.entries(data).map(async ([key, value]) => [key, await observableDataToJson(value)]));
-        // fromEntries preserves own keys such as __proto__ as data properties.
-        return Object.fromEntries(entries.filter(([, value]) => value !== undefined));
-    }
-    // Fallback for any unexpected data types not covered by ObservableData.
-    // Returning undefined is consistent with how unrepresentable values are handled.
-    return undefined;
-}
-// TODO: Implement deserialization, and actually leverage serde for logging stuff
-export async function jsonToObservableData(data) {
-    // Handle null and undefined primitives
-    if (data === null || data === undefined) {
-        return data;
-    }
-    // Handle arrays by recursively converting each item
-    if (Array.isArray(data)) {
-        return Promise.all(data.map(item => jsonToObservableData(item)));
-    }
-    // Handle objects, which can be StoredMedia, StoredPrimitive, or a generic object
-    if (typeof data === 'object') {
-        // Check for our special typed objects
-        if ('type' in data && typeof data.type === 'string') {
-            switch (data.type) {
-                case 'media':
-                    // Cast the object to StoredMedia and use the static `fromBase64` method.
-                    const media = data;
-                    if (media.storage === 'base64') {
-                        return Image.fromBase64(media.base64);
-                    }
-                    throw new Error(`Unsupported media storage type: ${media.storage}`);
-                case 'primitive':
-                    // Unwrap the primitive value from its container object.
-                    return data.content;
-            }
-        }
-        // Handle generic observable data object by recursively converting each property's value
-        const keys = Object.keys(data);
-        // Process all values concurrently for better performance
-        const values = await Promise.all(keys.map(key => jsonToObservableData(data[key])));
-        return Object.fromEntries(keys.map((key, index) => [key, values[index]]));
-    }
-    // According to the MultiMediaJson type definition, raw primitives (string, number, boolean)
-    // are not valid at the top level and should be wrapped in a StoredPrimitive object.
-    // Throw an error if we encounter them, as the input is malformed.
-    throw new Error(`Invalid MultiMediaJson format: Unexpected primitive value '${data}'.`);
-}

package/dist/memory/serde.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/memory/serde.test.js

@@ -1,64 +0,0 @@
-import { expect, test } from 'bun:test';
-import sharp from 'sharp';
-import { AgentMemory } from './agentMemory';
-import { Image } from './image';
-import { maskObservations } from './masking';
-import { Observation } from './observation';
-import { jsonToObservableData, observableDataToJson } from './serde';
-const roundTrip = async (value) => jsonToObservableData(JSON.parse(JSON.stringify(await observableDataToJson(value))));
-test('nested objects, arrays, and falsy values survive an actual JSON round trip', async () => {
-    const value = { count: 17, empty: '', nested: { label: 'fixture', values: [true, false, 0, null, { n: -2 }] } };
-    expect(await roundTrip(value)).toEqual(value);
-    expect(await roundTrip([value, 'text', 0, false, null])).toEqual([value, 'text', 0, false, null]);
-});
-test('undefined entries are omitted without losing null or empty values', async () => {
-    expect(await roundTrip({ missing: undefined, empty: {}, nested: { absent: undefined, present: null }, values: [undefined, '', null] }))
-        .toEqual({ empty: {}, nested: { present: null }, values: ['', null] });
-    expect(await observableDataToJson(undefined)).toBeUndefined();
-    expect(await jsonToObservableData(undefined)).toBeUndefined();
-});
-test('arbitrary own property names survive without changing object prototypes', async () => {
-    const value = JSON.parse('{"__proto__":{"fixture":true},"constructor":{"prototype":{"n":2}},"a/b~c":false}');
-    const saved = await observableDataToJson(value);
-    const loaded = await roundTrip(value);
-    for (const object of [saved, loaded]) {
-        if (!object || typeof object !== 'object')
-            throw new Error('Expected a saved/restored object');
-        expect(Object.hasOwn(object, '__proto__')).toBe(true);
-        expect(Object.getPrototypeOf(object)).toBe(Object.prototype);
-    }
-    expect(loaded).toEqual(value);
-    expect(Object.hasOwn(Object.prototype, 'fixture')).toBe(false);
-});
-test('nested media is serialized before JSON encoding and restored as an Image', async () => {
-    const screenshot = new Image(sharp({ create: { width: 2, height: 3, channels: 3, background: '#123456' } }).png());
-    const value = { nested: { screenshot }, rows: [screenshot, { label: 'image fixture' }] };
-    const saved = (await observableDataToJson(value));
-    const loaded = await roundTrip(value);
-    expect(loaded.nested.screenshot).toBeInstanceOf(Image);
-    expect(await loaded.nested.screenshot.getDimensions()).toEqual({ width: 2, height: 3 });
-    expect(await observableDataToJson(loaded)).toEqual(saved);
-});
-test('memory checkpoints retain structured observations and their metadata', async () => {
-    const memory = new AgentMemory();
-    memory.recordObservation(new Observation('connector:fixture', 'user', { a: [{ b: 4 }] }, { type: 'state', dedupe: true }, 123));
-    const saved = JSON.parse(JSON.stringify(await memory.toJSON()));
-    const restored = new AgentMemory();
-    await restored.loadJSON(saved);
-    expect(await restored.toJSON()).toEqual(saved);
-    expect((await restored.toJSON()).observations[0].data).toEqual({ a: [{ b: { type: 'primitive', content: 4 } }] });
-});
-test('deduplication distinguishes different structured observation values', async () => {
-    const observations = [1, 1, 2].map(value => Observation.fromConnector('fixture', { nested: { value } }, { type: 'state', dedupe: true }));
-    expect(await observations[0].equals(observations[1])).toBe(true);
-    expect(await observations[1].equals(observations[2])).toBe(false);
-    expect(await maskObservations(observations)).toEqual([false, true, true]);
-});
-test('varied synthetic object keys and nested values round-trip independently of task content', async () => {
-    let seed = 0xa173;
-    for (let i = 0; i < 64; i++) {
-        seed = (Math.imul(seed, 1664525) + 1013904223) >>> 0;
-        const value = { [`field_${seed.toString(36)}_é`]: [{ count: seed, enabled: !!(seed % 2), nested: { value: `value-${i}` } }] };
-        expect(await roundTrip(value)).toEqual(value);
-    }
-});

package/dist/memory/util.d.ts

@@ -1,2 +0,0 @@
-import { MultiMediaMessage } from '@/ai/baml_client';
-export declare function mergeMessages(messages: MultiMediaMessage[]): MultiMediaMessage[];

package/dist/memory/util.js

@@ -1,17 +0,0 @@
-export function mergeMessages(messages) {
-    if (messages.length === 0)
-        return [];
-    const merged = [];
-    let current = messages[0];
-    for (let i = 1; i < messages.length; i++) {
-        if (messages[i].role === current.role) {
-            current.content.push(...messages[i].content);
-        }
-        else {
-            merged.push(current);
-            current = messages[i];
-        }
-    }
-    merged.push(current);
-    return merged;
-}

package/dist/telemetry/events.d.ts

@@ -1,9 +0,0 @@
-import type { Agent } from "@/agent";
-import { LLMClientIdentifier } from "@/ai/types";
-export type UsageReport = {
-    llm: LLMClientIdentifier;
-    inputTokens: number;
-    outputTokens: number;
-    numCalls: number;
-}[];
-export declare function telemetrifyAgent(agent: Agent): void;