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

package/dist/connectors/index.d.ts

@@ -1,14 +0,0 @@
-import { ActionDefinition } from '@/actions';
-import { Observation } from '@/memory/observation';
-import type { Action } from '@/actions/types';
-import type { OperationOptions } from '@/common/operation';
-export interface AgentConnector {
-    id: string;
-    onStart?(): Promise<void>;
-    onStop?(): Promise<void>;
-    beforeAction?(action: Action, options?: OperationOptions): Promise<void>;
-    onTaskStart?(options?: OperationOptions): void;
-    getActionSpace?(): ActionDefinition<any>[];
-    collectObservations?(options?: OperationOptions): Promise<Observation[]>;
-    getInstructions?(options?: OperationOptions): Promise<void | string>;
-}

package/dist/connectors/index.js

@@ -1,2 +0,0 @@
-export {};
-//export { BrowserConnector, BrowserConnectorOptions } from './browserConnector';

package/dist/index.js

@@ -1,28 +0,0 @@
-process.env.BAML_LOG = 'off';
-import { setLogLevel } from '@/ai/baml_client/config';
-export { Agent } from "@/agent";
-export { createAction } from '@/actions';
-export { BrowserAgent, startBrowserAgent } from '@/agent/browserAgent';
-//export { Magnus } from "@/agent/magnus";
-//export type { AgentOptions as TestCaseAgentOptions } from "@/agent";
-export * from "@/agent";
-export * from "@/memory";
-export * from "@/web/harness";
-export * from "@/actions";
-export * from "@/connectors";
-export * from "@/web/browserProvider";
-export * from "@/connectors/browserConnector";
-export * from "@/connectors/desktopConnector";
-export * from "@/agent/errors";
-export * from "@/types";
-export * from "@/ai/types";
-export * from "@/web/types";
-export { BrowserBlockedError } from '@/web/recovery';
-export * from "@/actions/types";
-export * from '@/common';
-export * from "@/telemetry";
-export { buildDefaultBrowserAgentOptions } from "@/ai/util";
-export { logger } from './logger';
-export { z } from 'zod';
-//export { ModelUsage } from '@/ai/modelHarness';
-setLogLevel('OFF');

package/dist/logger.d.ts

@@ -1,3 +0,0 @@
-import pino from 'pino';
-export declare const logger: pino.Logger<never, boolean>;
-export default logger;

package/dist/logger.js

@@ -1,15 +0,0 @@
-import pino from 'pino';
-export const logger = pino({
-    level: process.env.MAGNITUDE_LOG_LEVEL || 'warn',
-    transport: process.stdout.isTTY ? {
-        target: 'pino-pretty',
-        options: {
-            colorize: !process.env.NO_COLOR,
-            translateTime: 'SYS:HH:MM:ss.l',
-            ignore: 'pid,hostname'
-        }
-    } : undefined
-}).child({
-    name: "agent"
-});
-export default logger;

package/dist/memory/agentMemory.d.ts

@@ -1,47 +0,0 @@
-import { MultiMediaMessage } from '@/ai/baml_client';
-import { Observation, ObservationRetentionOptions, ObservationRole, ObservationSource } from './observation';
-import { MultiMediaJson } from './serde';
-import { Image as BamlImage } from '@boundaryml/baml';
-import { type NoteInput } from './notebook';
-export interface SerializedAgentMemory {
-    instructions?: string;
-    notes?: NoteInput[];
-    observations: {
-        source: ObservationSource;
-        role: ObservationRole;
-        timestamp: number;
-        data: MultiMediaJson;
-        options?: ObservationRetentionOptions;
-    }[];
-}
-export interface AgentMemoryOptions {
-    instructions?: string | null;
-    promptCaching?: boolean;
-    thoughtLimit?: number;
-}
-export interface MemoryRenderOptions {
-    /** Full audit history bypasses actor retention without changing actor visibility or cache state. */
-    history?: 'retained' | 'full';
-}
-export declare class AgentMemory {
-    private options;
-    private observations;
-    private notebook;
-    private visibleSourceIds;
-    private freezeMask?;
-    private cacheControlIndices;
-    constructor(options?: AgentMemoryOptions);
-    get instructions(): string | null;
-    render(options?: MemoryRenderOptions): Promise<MultiMediaMessage[]>;
-    simpleRender(): Promise<(BamlImage | string)[]>;
-    private observationPrefix;
-    private resolveNoteSource;
-    remember(note: NoteInput, expectedText?: string): void;
-    forget(key: string): void;
-    isEmpty(): boolean;
-    recordThought(content: string): void;
-    recordObservation(obs: Observation): void;
-    getLastThoughtMessage(): string | null;
-    toJSON(): Promise<SerializedAgentMemory>;
-    loadJSON(data: SerializedAgentMemory): Promise<void>;
-}

package/dist/memory/agentMemory.js

@@ -1,167 +0,0 @@
-import { Observation } from './observation';
-import { jsonToObservableData, observableDataToJson } from './serde';
-import { applyMask, maskObservations } from './masking';
-import { TaskNotebook } from './notebook';
-// export interface FreezeState {
-//     //lastFrozenObservationIndex: number,
-//     // ^ just use length of mask
-//     visibilityMask: boolean[],
-// }
-const CACHE_CONTROL_LIMIT = 3; // Anthropic allows max of 4, we use static one on system, 3 can be cyclic
-export class AgentMemory {
-    //public readonly events: EventEmitter<AgentMemoryEvents> = new EventEmitter();
-    options;
-    // Custom instructions relating to this memory instance (e.g. agent-level and/or task-level instructions)
-    //public readonly instructions: string | null;
-    observations = [];
-    notebook = new TaskNotebook();
-    visibleSourceIds = new Set();
-    //private freezeState?: FreezeState;
-    freezeMask;
-    cacheControlIndices = [];
-    constructor(options) {
-        //this.instructions = instructions ?? null;
-        this.options = {
-            instructions: options?.instructions ?? null,
-            promptCaching: options?.promptCaching ?? false,
-            //optimizeForPromptCaching: false,
-            thoughtLimit: options?.thoughtLimit ?? 20
-        };
-    }
-    get instructions() {
-        // why is this on memory? prob should just be on agent
-        return this.options.instructions;
-    }
-    async render(options) {
-        if (options?.history === 'full') {
-            const messages = [];
-            for (const [index, observation] of this.observations.entries()) {
-                messages.push(await observation.render({ prefix: this.observationPrefix(observation, index) }));
-            }
-            const notes = this.notebook.render();
-            if (notes)
-                messages.push({ role: 'user', cacheControl: false, content: [notes] });
-            return messages;
-        }
-        if (this.options.promptCaching && this.cacheControlIndices.length >= CACHE_CONTROL_LIMIT) {
-            this.freezeMask = undefined;
-            this.cacheControlIndices = [];
-        }
-        const mask = await maskObservations(this.observations, this.freezeMask);
-        // Preserve complete note actions in the audit, not obsolete facts in actor context.
-        this.observations.forEach((observation, index) => {
-            if (observation.retention?.type === 'notebook-write')
-                mask[index] = false;
-        });
-        const visibleObservations = applyMask(this.observations, mask);
-        this.visibleSourceIds = new Set([
-            ...visibleObservations.filter(({ observation }) => observation.source.startsWith('connector:')).map(({ index }) => index),
-            ...this.notebook.sourceIds(),
-        ]);
-        const lastVisible = visibleObservations.at(-1);
-        if (lastVisible)
-            this.cacheControlIndices.push(lastVisible.index); // index WRT full observation list
-        let messages = [];
-        for (const { observation, index } of visibleObservations) {
-            const message = await observation.render({
-                prefix: this.observationPrefix(observation, index),
-                cacheControl: this.options.promptCaching && this.cacheControlIndices.includes(index)
-            });
-            messages.push(message);
-        }
-        if (this.options.promptCaching) {
-            this.freezeMask = mask;
-        }
-        const notes = this.notebook.render();
-        if (notes)
-            messages.push({ role: 'user', cacheControl: false, content: [notes] });
-        return messages;
-    }
-    async simpleRender() {
-        return (await this.render({ history: 'full' })).flatMap(message => message.content);
-    }
-    observationPrefix(observation, index) {
-        if (observation.source.startsWith('connector:'))
-            return [`[Observation ${index}] ${observation.source}\n`];
-        return observation.source.startsWith('action:taken') || observation.source === 'thought'
-            ? [`[${new Date(observation.timestamp).toTimeString().split(' ')[0]}]: `] : [];
-    }
-    resolveNoteSource(observations, id) {
-        const observation = observations[id];
-        if (!observation?.source.startsWith('connector:'))
-            throw new Error(`Observation ${id} is not a captured connector source.`);
-        const data = observation.content;
-        const url = data && typeof data === 'object' && 'url' in data && typeof data.url === 'string' ? data.url : undefined;
-        return { observation: id, capturedAt: observation.timestamp, ...(url !== undefined ? { url } : {}) };
-    }
-    remember(note, expectedText) {
-        this.notebook.put(note, id => {
-            if (!this.visibleSourceIds.has(id))
-                throw new Error(`Observation ${id} is not shown in the current context or notebook.`);
-            return this.resolveNoteSource(this.observations, id);
-        }, expectedText);
-    }
-    forget(key) {
-        this.notebook.forget(key);
-    }
-    isEmpty() {
-        return this.observations.length === 0;
-    }
-    recordThought(content) {
-        this.observations.push(Observation.fromThought(content, { type: 'thought', limit: this.options.thoughtLimit }));
-        //this.events.emit('thought', content);
-    }
-    recordObservation(obs) {
-        this.observations.push(obs);
-    }
-    getLastThoughtMessage() {
-        for (let i = this.observations.length - 1; i >= 0; i--) {
-            const obs = this.observations[i];
-            // toString() is a little funky here, or the idea that thought might not just be text
-            if (obs.source.startsWith('thought'))
-                return obs.toString();
-        }
-        return null;
-    }
-    async toJSON() {
-        const observations = [];
-        for (const observation of this.observations) {
-            observations.push({
-                source: observation.source,
-                role: observation.role,
-                timestamp: observation.timestamp,
-                data: await observableDataToJson(observation.content),
-                options: observation.retention,
-            });
-        }
-        const notes = this.notebook.toJSON();
-        return {
-            // TODO: include other options as well
-            ...(this.options.instructions ? { instructions: this.options.instructions } : {}),
-            ...(notes.length ? { notes } : {}),
-            observations: observations
-        };
-    }
-    // TODO: turn into class static method / rework cons
-    async loadJSON(data) {
-        //jsonToObservableData(data);
-        const observations = [];
-        for (const observation of data.observations) {
-            observations.push(new Observation(observation.source, observation.role, await jsonToObservableData(observation.data), observation.options, observation.timestamp));
-        }
-        // nvm
-        //this.instructions = this.instructions;
-        const notebook = new TaskNotebook();
-        for (const note of data.notes ?? [])
-            notebook.put(note, id => this.resolveNoteSource(observations, id));
-        this.observations = observations;
-        this.notebook = notebook;
-        this.visibleSourceIds.clear();
-        this.freezeMask = undefined;
-        this.cacheControlIndices = [];
-        // return {
-        //     ...(this.instructions ? { instructions: this.instructions } : {}),
-        //     observations: observations
-        // };
-    }
-}

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

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

package/dist/memory/agentMemory.test.js

@@ -1,150 +0,0 @@
-import { expect, test } from 'bun:test';
-import sharp from 'sharp';
-import { AgentMemory } from './agentMemory';
-import { Observation } from './observation';
-import { Image } from './image';
-const screen = (n) => Observation.fromConnector('fixture', {
-    url: `https://fixture.invalid/record/${n}?filter=active`,
-    screenshot: new Image(sharp({ create: { width: 2, height: 2, channels: 3, background: { r: n * 13, g: 80, b: 120 } } }).png()),
-}, { type: 'screenshot', limit: 2, dedupe: true });
-const text = async (memory) => (await memory.render()).flatMap(message => message.content)
-    .filter(part => typeof part === 'string').join('');
-for (const promptCaching of [false, true])
-    test(`full audit bypasses all actor filters without changing actor state, caching ${promptCaching}`, async () => {
-        const memory = new AgentMemory({ promptCaching, thoughtLimit: 1 });
-        memory.recordObservation(screen(0));
-        memory.recordObservation(screen(0)); // Identical screenshots remain separate audit events.
-        memory.recordObservation(Observation.fromActionTaken('memory:note', 'Obsolete fact', { type: 'notebook-write' }));
-        memory.recordObservation(Observation.fromActionResult('memory:note', 'Old result', { type: 'notebook-result', limit: 1 }));
-        memory.recordThought('Old thought');
-        memory.recordObservation(screen(1));
-        memory.recordObservation(screen(2));
-        memory.recordObservation(Observation.fromActionTaken('memory:forget', 'Forget obsolete fact', { type: 'notebook-write' }));
-        memory.recordObservation(Observation.fromActionResult('memory:forget', 'New result', { type: 'notebook-result', limit: 1 }));
-        memory.recordThought('Latest thought');
-        const saved = await memory.toJSON();
-        const control = new AgentMemory({ promptCaching, thoughtLimit: 1 });
-        await control.loadJSON(saved);
-        await memory.render();
-        await control.render();
-        const audit = await memory.render({ history: 'full' });
-        const auditText = audit.flatMap(message => message.content).filter(part => typeof part === 'string').join('');
-        expect(audit).toHaveLength(saved.observations.length);
-        expect(audit.every(message => !message.cacheControl)).toBe(true);
-        for (const expected of ['[Observation 0]', '[Observation 1]', 'Obsolete fact', 'Old result', 'Old thought', 'Forget obsolete fact']) {
-            expect(auditText).toContain(expected);
-        }
-        expect(() => memory.remember({ key: 'hidden', text: 'Audit is not actor visibility', sources: [0] })).toThrow('not shown');
-        expect(await memory.toJSON()).toEqual(saved);
-        expect(await memory.render()).toEqual(await control.render());
-        expect(await text(memory)).not.toContain('Obsolete fact');
-    });
-for (const promptCaching of [false, true])
-    test(`notes survive screenshot and thought eviction with prompt caching ${promptCaching}`, async () => {
-        const memory = new AgentMemory({ promptCaching, thoughtLimit: 1 });
-        memory.recordObservation(screen(0));
-        expect(await text(memory)).toContain('[Observation 0]');
-        memory.remember({ key: 'record', text: 'Exact value: 791; status uncertain.', sources: [0] });
-        for (let i = 1; i < 15; i++) {
-            memory.recordThought(i === 1 ? 'Discard-this-old-thought' : `Intermediate check ${i}`);
-            memory.recordObservation(screen(i));
-            await memory.render();
-        }
-        const rendered = await text(memory);
-        expect(rendered).not.toContain('[Observation 0]');
-        expect(rendered).not.toContain('Discard-this-old-thought');
-        expect(rendered).toContain('Exact value: 791; status uncertain.');
-        expect(rendered).toContain('https://fixture.invalid/record/0?filter=active');
-        expect((await memory.render()).at(-1)?.cacheControl).toBe(false);
-        const saved = JSON.parse(JSON.stringify(await memory.toJSON()));
-        const restored = new AgentMemory({ promptCaching });
-        await restored.loadJSON(saved);
-        expect(await restored.toJSON()).toEqual(saved);
-        expect(await text(restored)).toContain('Exact value: 791; status uncertain.');
-        expect((await restored.simpleRender()).join('')).toContain('not independent evidence');
-        // Consolidation can reference provenance still shown in the notebook.
-        restored.remember({ key: 'consolidated', text: 'Prior observed value: 791.', sources: [0] });
-        restored.forget('record');
-        expect(await text(restored)).not.toContain('status uncertain');
-    });
-test('only visible connector observations or retained note sources can be cited', async () => {
-    const memory = new AgentMemory();
-    memory.recordObservation(screen(0));
-    memory.recordObservation(Observation.fromThought('A model claim is not a source.'));
-    memory.recordObservation(Observation.fromActionTaken('answer', 'A model answer is not a source.'));
-    for (let i = 1; i < 4; i++)
-        memory.recordObservation(screen(i));
-    await memory.render();
-    for (const id of [0, 1, 2, 999, -1, 0.5]) {
-        expect(() => memory.remember({ key: 'invalid', text: 'claim', sources: [id] })).toThrow();
-    }
-    memory.remember({ key: 'observed', text: 'visible fact', sources: [5] });
-    memory.recordObservation(screen(4));
-    // Merely recording an observation does not make it model-visible.
-    expect(() => memory.remember({ key: 'not-seen', text: 'claim', sources: [6] })).toThrow();
-    expect((await memory.toJSON()).notes).toHaveLength(1);
-});
-test('loading legacy memory clears notes and visibility/cache state', async () => {
-    const memory = new AgentMemory({ promptCaching: true });
-    memory.recordObservation(screen(0));
-    await memory.render();
-    memory.remember({ key: 'old-task', text: 'old task fact', sources: [0] });
-    const legacy = new AgentMemory();
-    legacy.recordObservation(Observation.fromConnector('fixture', 'New task observation'));
-    await memory.loadJSON(await legacy.toJSON());
-    expect((await memory.toJSON()).notes).toBeUndefined();
-    expect(() => memory.remember({ key: 'premature', text: 'claim', sources: [0] })).toThrow();
-    expect(await text(memory)).not.toContain('old task fact');
-    expect(await text(memory)).toContain('New task observation');
-});
-test('malformed checkpoint provenance does not replace current memory', async () => {
-    const memory = new AgentMemory();
-    memory.recordObservation(screen(0));
-    const saved = await memory.toJSON();
-    await expect(memory.loadJSON({ ...saved, notes: [{ key: 'bad', text: 'claim', sources: [50] }] })).rejects.toThrow();
-    expect(await memory.toJSON()).toEqual(saved);
-});
-for (const promptCaching of [false, true])
-    test(`completed checks outlive the default thought window and can be corrected, caching ${promptCaching}`, async () => {
-        const memory = new AgentMemory({ promptCaching });
-        const url = `https://fixture.invalid/${crypto.randomUUID()}`;
-        memory.recordObservation(Observation.fromConnector('fixture', { url, value: 'pending' }, { type: 'state', limit: 1 }));
-        memory.recordThought('Original inspection finished.');
-        await memory.render();
-        memory.remember({ key: 'inspection', text: 'Checked record; observed status pending. Follow-up unresolved.', sources: [0] });
-        for (let i = 0; i < 35; i++) {
-            memory.recordObservation(Observation.fromConnector('fixture', `Other record ${i}`, { type: 'state', limit: 1 }));
-            memory.recordThought(`Unrelated check ${i}`);
-            await memory.render();
-        }
-        const rendered = await text(memory);
-        expect(rendered).not.toContain('Original inspection finished.');
-        expect(rendered).not.toContain('[Observation 0]');
-        expect(rendered).toContain('Checked record; observed status pending. Follow-up unresolved.');
-        // A legitimate later revisit can change the fact: no automatic "already seen" skip.
-        memory.recordObservation(Observation.fromConnector('fixture', { url, value: 'complete' }, { type: 'state', limit: 1 }));
-        const latestId = (await memory.toJSON()).observations.length - 1;
-        await memory.render();
-        memory.remember({ key: 'inspection', text: 'Rechecked record; now complete. No follow-up remains.', sources: [latestId] }, 'Checked record; observed status pending. Follow-up unresolved.');
-        const corrected = await text(memory);
-        expect(corrected).toContain('now complete');
-        expect(corrected).not.toContain('status pending');
-        expect((await memory.toJSON()).notes?.[0].sources).toEqual([latestId]);
-        expect((await memory.toJSON()).observations[0].data).toHaveProperty('value');
-        const saved = await memory.toJSON();
-        const restored = new AgentMemory({ promptCaching });
-        await restored.loadJSON(saved);
-        await restored.render();
-        expect(() => restored.remember({ key: 'inspection', text: 'A different record', sources: [latestId] })).toThrow('already exists');
-        expect(() => restored.remember({ key: 'inspection', text: 'Stale correction', sources: [latestId] }, 'Checked record; observed status pending. Follow-up unresolved.')).toThrow('exactly match');
-        expect(await restored.toJSON()).toEqual(saved);
-    });
-test('duplicate keys in a checkpoint fail without replacing existing memory', async () => {
-    const memory = new AgentMemory();
-    memory.recordObservation(screen(0));
-    await memory.render();
-    memory.remember({ key: 'unique', text: 'Keep this fact', sources: [0] });
-    const saved = await memory.toJSON();
-    await expect(memory.loadJSON({ ...saved, notes: [...saved.notes, { ...saved.notes[0], text: 'Discarded duplicate' }] })).rejects.toThrow('already exists');
-    expect(await memory.toJSON()).toEqual(saved);
-});

package/dist/memory/image.d.ts

@@ -1,28 +0,0 @@
-import { Image as BamlImage } from '@boundaryml/baml';
-import { StoredMedia } from './serde';
-import { Sharp } from 'sharp';
-import sharp from 'sharp';
-export type ImageMediaType = `image/${string}`;
-export declare class Image {
-    /**
-     * Wrapper for a Sharp image with conveniences to go to/from base64, convert to BAML, or serialize as JSON
-     */
-    private img;
-    private encoded?;
-    constructor(img: Sharp);
-    static fromBase64(base64: string): Image;
-    getFormat(): Promise<keyof sharp.FormatEnum>;
-    private encode;
-    /**
-     * Convert the image to a JSON representation
-     */
-    toJson(): Promise<StoredMedia>;
-    toBase64(): Promise<string>;
-    toBaml(): Promise<BamlImage>;
-    saveToFile(filepath: string): Promise<void>;
-    getDimensions(): Promise<{
-        width: number;
-        height: number;
-    }>;
-    resize(width: number, height: number): Promise<Image>;
-}

package/dist/memory/image.js

@@ -1,95 +0,0 @@
-import { Image as BamlImage } from '@boundaryml/baml';
-import sharp from 'sharp';
-export class Image {
-    /**
-     * Wrapper for a Sharp image with conveniences to go to/from base64, convert to BAML, or serialize as JSON
-     */
-    // represents the start of a pipeline
-    img;
-    encoded;
-    // Cached metadata property for sync access + required width/height properties
-    //private metadata: Sharp['metadata'] & { width: number, height: number };
-    //private content: string;
-    //private mediaType: ImageMediaType;
-    //constructor(type: 'url' | 'base64', content: string, mediaType: ImageMediaType) {
-    constructor(img) {
-        // Own the pipeline configuration; later caller edits cannot change it.
-        this.img = img.clone();
-    }
-    static fromBase64(base64) {
-        // if (!mediaType) {
-        //     const match = base64.match(/^data:(.*?);base64,/);
-        //     mediaType = match ? `image/${match[1]}` : undefined;
-        // }
-        // if (!mediaType) {
-        //     throw new Error("Image media type must be specified either in base64 encoded string or in mediaType parameter");
-        // }
-        const base64Data = base64.replace(/^data:.*?;base64,/, '');
-        //return new Image('base64', base64Data, mediaType);
-        return new Image(sharp(Buffer.from(base64Data, 'base64')));
-    }
-    async getFormat() {
-        return (await this.encode()).format;
-    }
-    encode() {
-        // Share in-flight work across rendering, deduplication and checkpoints.
-        // Retain encoded strings, not both a Buffer and its base64 copy.
-        return this.encoded ??= this.img.clone().toBuffer({ resolveWithObject: true }).then(({ data, info }) => ({
-            base64: data.toString('base64'), format: info.format, width: info.width, height: info.height,
-        })).catch(error => {
-            this.encoded = undefined;
-            throw error;
-        });
-    }
-    /**
-     * Convert the image to a JSON representation
-     */
-    async toJson() {
-        // Source metadata can describe raw input or a pre-conversion format.
-        // Use the format of the bytes emitted by the Sharp pipeline.
-        const { base64, format } = await this.encode();
-        return {
-            type: 'media',
-            format,
-            storage: 'base64',
-            base64,
-        };
-    }
-    async toBase64() {
-        return (await this.encode()).base64;
-    }
-    async toBaml() {
-        const { format, base64 } = await this.toJson();
-        return BamlImage.fromBase64(`image/${format}`, base64);
-    }
-    async saveToFile(filepath) {
-        await this.img.clone().toFile(filepath);
-        //console.log(`Image saved to ${filepath}`);
-    }
-    async getDimensions() {
-        //const { width, height } = await this.img.clone().metadata();
-        // Need to convert to buffer in order for metadata to be updated - otherwise it returns metadata of the original image
-        const { width, height } = await this.encode();
-        if (!width || !height)
-            throw new Error("Unable to get dimensions from image");
-        return { width, height };
-    }
-    async resize(width, height) {
-        // if (this.type != 'base64') throw new Error("Only base64 images can be resized");
-        // const img = sharp(Buffer.from(this.content));
-        // const metadata = await img.metadata();
-        //console.log(`resizing to: ${width}, ${height}`);
-        //console.log("Before resizing:", await this.getDimensions());
-        // if (!metadata.width || !metadata.height)
-        const resizedImage = new Image(this.img.clone().resize({
-            // Round width/height since sometimes they are floats due to rounding errors - sharp will throw if not integers
-            width: Math.round(width),
-            height: Math.round(height),
-            fit: 'fill', // exact size, no cropping
-            kernel: sharp.kernel.lanczos3
-        }));
-        //resizedImage.saveToFile('foo.png');
-        //console.log("After resizing:", await resizedImage.getDimensions());
-        return resizedImage;
-    }
-}

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

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

package/dist/memory/image.test.js

@@ -1,46 +0,0 @@
-import { expect, spyOn, test } from 'bun:test';
-import sharp from 'sharp';
-import { Image } from './image';
-import { Observation } from './observation';
-import { AgentMemory } from './agentMemory';
-test('rendering, hashes and checkpoints share one in-flight encoding per image', async () => {
-    const image = new Image(sharp({ create: { width: 3, height: 4, channels: 3, background: '#123456' } }).png());
-    const observation = Observation.fromConnector('fixture', { screenshot: image });
-    const memory = new AgentMemory();
-    memory.recordObservation(observation);
-    const encode = spyOn(sharp.prototype, 'toBuffer');
-    try {
-        const [json] = await Promise.all([image.toJson(), memory.render(), observation.hash(), memory.toJSON(), image.getDimensions(), image.toBase64()]);
-        await Promise.all([memory.render(), observation.hash(), memory.toJSON(), image.toBaml()]);
-        expect(encode).toHaveBeenCalledTimes(1);
-        expect(await image.getDimensions()).toEqual({ width: 3, height: 4 });
-        json.base64 = 'Caller mutation';
-        expect((await image.toJson()).base64).not.toBe('Caller mutation');
-    }
-    finally {
-        encode.mockRestore();
-    }
-});
-test('an Image owns its pipeline configuration and resizing returns an independent image', async () => {
-    const pipeline = sharp({ create: { width: 3, height: 4, channels: 3, background: '#123456' } }).png();
-    const image = new Image(pipeline);
-    pipeline.resize(10, 20).jpeg();
-    expect(await image.getDimensions()).toEqual({ width: 3, height: 4 });
-    expect(await image.getFormat()).toBe('png');
-    const saved = await image.toJson();
-    const resized = await image.resize(8, 9);
-    expect(await resized.getDimensions()).toEqual({ width: 8, height: 9 });
-    expect(await image.toJson()).toEqual(saved);
-});
-test('failed image encodings are retryable rather than cached rejections', async () => {
-    const image = new Image(sharp({ create: { width: 2, height: 2, channels: 3, background: '#123456' } }).png());
-    const encode = spyOn(sharp.prototype, 'toBuffer').mockRejectedValueOnce(new Error('Transient encoding failure'));
-    try {
-        await expect(image.toJson()).rejects.toThrow('Transient encoding failure');
-        expect((await image.toJson()).format).toBe('png');
-        expect(encode).toHaveBeenCalledTimes(2);
-    }
-    finally {
-        encode.mockRestore();
-    }
-});

package/dist/memory/index.d.ts

@@ -1,3 +0,0 @@
-export * from './agentMemory';
-export * from './observation';
-export * from './util';

package/dist/memory/index.js

@@ -1,3 +0,0 @@
-export * from './agentMemory';
-export * from './observation';
-export * from './util';

package/dist/memory/masking.d.ts

@@ -1,7 +0,0 @@
-import { Observation } from './observation';
-export declare function maskObservations(observations: Observation[], freezeMask?: boolean[]): Promise<boolean[]>;
-export interface MaskedObservation {
-    observation: Observation;
-    index: number;
-}
-export declare function applyMask(observations: Observation[], mask: boolean[]): MaskedObservation[];