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

package/dist/actions/util.js

@@ -1,280 +0,0 @@
-import { zodToJsonSchema } from "zod-to-json-schema";
-import { z, ZodObject } from "zod";
-function randomName() {
-    const chars = 'abcdefghijklmnopqrstuvwxyz';
-    let result = '';
-    for (let i = 0; i < 12; i++) {
-        result += chars.charAt(Math.floor(Math.random() * chars.length));
-    }
-    return result;
-}
-class SchemaAdder {
-    tb;
-    rootSchema;
-    refCache = {};
-    constructor(tb, rootSchema) {
-        this.tb = tb;
-        this.rootSchema = rootSchema;
-    }
-    _parseObject(jsonSchema) {
-        if (jsonSchema.type !== "object") {
-            throw new Error(`_parseObject called with non-object type: ${jsonSchema.type}`);
-        }
-        let name = jsonSchema.title;
-        if (name === undefined || typeof name !== 'string') {
-            // Name doesn't actually affect much if field used as return value anyway, just needs to be unique
-            name = randomName();
-            //throw new Error("Title (string) is required in JSON schema for object type that becomes a BAML class.");
-        }
-        const newCls = this.tb.addClass(name);
-        const requiredFields = jsonSchema.required || [];
-        if (!Array.isArray(requiredFields) || !requiredFields.every(rf => typeof rf === 'string')) {
-            throw new Error(`'required' property in object '${name}' must be an array of strings.`);
-        }
-        const properties = jsonSchema.properties;
-        if (properties && typeof properties === 'object') {
-            for (const [fieldName, fieldSchemaUntyped] of Object.entries(properties)) {
-                if (typeof fieldSchemaUntyped !== 'object' || fieldSchemaUntyped === null) {
-                    console.warn(`Property schema for '${fieldName}' in class '${name}' is not a valid object/schema. Skipping.`);
-                    continue;
-                }
-                const fieldSchema = fieldSchemaUntyped;
-                const defaultValue = fieldSchema.default;
-                let fieldType;
-                if (fieldSchema.properties === undefined && fieldSchema.type === "object") {
-                    console.warn(`Field '${fieldName}' in class '${name}' uses generic dict type (object without properties) ` +
-                        `which defaults to map<string, string>. ` +
-                        "If a more specific type is needed, please provide a specific schema with properties.");
-                    fieldType = this.tb.map(this.tb.string(), this.tb.string());
-                }
-                else {
-                    fieldType = this.parse(fieldSchema);
-                }
-                if (!requiredFields.includes(fieldName)) {
-                    if (defaultValue === undefined) {
-                        fieldType = fieldType.optional();
-                    }
-                }
-                const propertyBuilder = newCls.addProperty(fieldName, fieldType);
-                let fieldDescription = fieldSchema.description;
-                if (typeof fieldDescription === 'string') {
-                    let finalDescription = fieldDescription.trim();
-                    if (defaultValue !== undefined) {
-                        finalDescription = `${finalDescription}\nDefault: ${JSON.stringify(defaultValue)}`;
-                        finalDescription = finalDescription.trim();
-                    }
-                    if (finalDescription.length > 0) {
-                        propertyBuilder.description(finalDescription);
-                    }
-                }
-                else if (defaultValue !== undefined) {
-                    const defaultDesc = `Default: ${JSON.stringify(defaultValue)}`;
-                    propertyBuilder.description(defaultDesc.trim());
-                }
-            }
-        }
-        return newCls.type();
-    }
-    _parseString(jsonSchema) {
-        if (jsonSchema.type !== "string") {
-            throw new Error(`_parseString called with non-string type: ${jsonSchema.type}`);
-        }
-        const title = jsonSchema.title;
-        const enumValues = jsonSchema.enum;
-        if (enumValues) {
-            if (!Array.isArray(enumValues)) {
-                throw new Error(`'enum' property for string type '${title || "anonymous"}' must be an array.`);
-            }
-            const stringEnumValues = [];
-            for (const val of enumValues) {
-                stringEnumValues.push(String(val));
-            }
-            if (title === undefined || typeof title !== 'string') {
-                if (stringEnumValues.length === 0) {
-                    console.warn(`Anonymous enum (string type with 'enum' but no 'title') has no values. Defaulting to plain string type.`);
-                    return this.tb.string();
-                }
-                return this.tb.union(stringEnumValues.map(value => this.tb.literalString(value)));
-            }
-            const newEnum = this.tb.addEnum(title);
-            if (stringEnumValues.length === 0) {
-                console.warn(`Enum '${title}' has no values. An empty enum was created.`);
-            }
-            for (const value of stringEnumValues) {
-                newEnum.addValue(value);
-            }
-            return newEnum.type();
-        }
-        return this.tb.string();
-    }
-    _parseArray(jsonSchema) {
-        if (jsonSchema.type !== "array") {
-            throw new Error(`_parseArray called with non-array type: ${jsonSchema.type}`);
-        }
-        const itemsSchema = jsonSchema.items;
-        if (itemsSchema === undefined) {
-            throw new Error(`Array field '${jsonSchema.title || "untitled array"}' is missing 'items' definition.`);
-        }
-        if (Array.isArray(itemsSchema) || typeof itemsSchema !== 'object' || itemsSchema === null) {
-            throw new Error(`'items' property for array '${jsonSchema.title || "untitled array"}' must be a single schema object. Tuple/array types for 'items' are not supported by this converter (matching Python script's direct parsing of items).`);
-        }
-        return this.parse(itemsSchema).list();
-    }
-    _loadRef(ref) {
-        if (!ref.startsWith("#/")) {
-            throw new Error(`Only local references are supported: ${ref}`);
-        }
-        if (this.refCache[ref]) {
-            return this.refCache[ref];
-        }
-        const pathParts = ref.substring(2).split('/');
-        if (pathParts.length !== 2 || !pathParts[0] || !pathParts[1]) {
-            throw new Error(`Unsupported $ref format: '${ref}'. Expected format like '#/collectionKey/definitionKey' matching Python logic.`);
-        }
-        const collectionKey = pathParts[0];
-        const definitionKey = pathParts[1];
-        const collection = this.rootSchema[collectionKey];
-        if (typeof collection !== 'object' || collection === null) {
-            throw new Error(`Reference collection '${collectionKey}' for $ref '${ref}' not found or not an object in the root schema.`);
-        }
-        if (!collection.hasOwnProperty(definitionKey)) {
-            throw new Error(`Reference item '${definitionKey}' for $ref '${ref}' not found in collection '${collectionKey}'.`);
-        }
-        const targetSchema = collection[definitionKey];
-        if (typeof targetSchema !== 'object' || targetSchema === null) {
-            throw new Error(`Resolved $ref '${ref}' points to a non-object schema.`);
-        }
-        const fieldType = this.parse(targetSchema);
-        this.refCache[ref] = fieldType;
-        return fieldType;
-    }
-    parse(jsonSchema) {
-        if (jsonSchema.$ref) {
-            if (typeof jsonSchema.$ref !== 'string') {
-                throw new Error("'$ref' property must be a string.");
-            }
-            return this._loadRef(jsonSchema.$ref);
-        }
-        // Handle 'const' next, as it's a very specific assertion
-        if (jsonSchema.const !== undefined) {
-            const constValue = jsonSchema.const;
-            if (typeof constValue === 'string') {
-                return this.tb.literalString(constValue);
-            }
-            else if (typeof constValue === 'number') {
-                if (Number.isInteger(constValue)) {
-                    return this.tb.literalInt(constValue);
-                }
-                else {
-                    // BAML does not appear to have a literalFloat, based on available information.
-                    // The 'const' value itself isn't captured as a literal in the BAML type for floats.
-                    console.warn(`JSON Schema 'const' with float value '${constValue}' encountered. ` +
-                        `BAML will use base type (float) as literalFloat is not available. Title: '${jsonSchema.title || "anonymous"}'`);
-                    return this.tb.float();
-                }
-            }
-            else if (typeof constValue === 'boolean') {
-                return this.tb.literalBool(constValue);
-            }
-            else if (constValue === null) {
-                return this.tb.null();
-            }
-            if (typeof constValue === 'object' && (jsonSchema.type !== 'object' && jsonSchema.type !== 'array')) {
-                console.warn(`JSON Schema 'const' with complex value '${JSON.stringify(constValue)}' ` +
-                    `encountered. Title: '${jsonSchema.title || "anonymous"}'. ` +
-                    `Expected 'type: "object"' or 'type: "array"' if this const is to be further processed as such. ` +
-                    `Falling back to standard type parsing based on 'jsonSchema.type' (if present).`);
-            }
-        }
-        if (jsonSchema.anyOf) {
-            if (!Array.isArray(jsonSchema.anyOf)) {
-                throw new Error("'anyOf' property must be an array of schema objects.");
-            }
-            if (!jsonSchema.anyOf.every(s => typeof s === 'object' && s !== null)) {
-                throw new Error("'anyOf' array must contain valid schema objects.");
-            }
-            if (jsonSchema.anyOf.length === 0) {
-                console.warn("'anyOf' is an empty array. Defaulting to string (Python script has no specific handling).");
-                return this.tb.string();
-            }
-            return this.tb.union(jsonSchema.anyOf.map(subSchema => this.parse(subSchema)));
-        }
-        const additionalProperties = jsonSchema.additionalProperties;
-        if (additionalProperties && typeof additionalProperties === 'object' && additionalProperties.anyOf) {
-            const apSchema = additionalProperties;
-            const anyOfInAp = apSchema.anyOf;
-            if (!Array.isArray(anyOfInAp)) {
-                throw new Error("'anyOf' in 'additionalProperties' must be an array of schema objects.");
-            }
-            if (!anyOfInAp.every(s => typeof s === 'object' && s !== null)) {
-                throw new Error("'anyOf' in 'additionalProperties' must contain valid schema objects.");
-            }
-            if (anyOfInAp.length === 0) {
-                console.warn("'anyOf' in 'additionalProperties' is empty. Defaulting map value to string.");
-                return this.tb.map(this.tb.string(), this.tb.string());
-            }
-            const valueType = this.tb.union(anyOfInAp.map(subSchema => this.parse(subSchema)));
-            return this.tb.map(this.tb.string(), valueType);
-        }
-        const type = jsonSchema.type;
-        if (type === undefined) {
-            console.warn("Type field is missing in JSON schema, defaulting to string (Python script behavior).");
-            return this.tb.string();
-        }
-        if (typeof type !== 'string') {
-            throw new Error(`Unsupported 'type' format: Expected a string, got ${typeof type} (${JSON.stringify(type)}). Python script would raise ValueError.`);
-        }
-        let fieldType;
-        switch (type) {
-            case "string":
-                fieldType = this._parseString(jsonSchema);
-                break;
-            case "number":
-                fieldType = this.tb.float();
-                break;
-            case "integer":
-                fieldType = this.tb.int();
-                break;
-            case "object":
-                fieldType = this._parseObject(jsonSchema);
-                break;
-            case "array":
-                fieldType = this._parseArray(jsonSchema);
-                break;
-            case "boolean":
-                fieldType = this.tb.bool();
-                break;
-            case "null":
-                fieldType = this.tb.null();
-                break;
-            default:
-                throw new Error(`Unsupported JSON Schema type: '${type}'`);
-        }
-        return fieldType;
-    }
-}
-function convertJsonSchemaToBaml(tb, jsonSchema) {
-    if (typeof jsonSchema !== 'object' || jsonSchema === null) {
-        throw new Error("Invalid JSON schema provided. Must be an object.");
-    }
-    const parser = new SchemaAdder(tb, jsonSchema);
-    return parser.parse(jsonSchema);
-}
-export function convertZodToBaml(tb, schema) {
-    const jsonSchema = zodToJsonSchema(schema);
-    return convertJsonSchemaToBaml(tb, jsonSchema);
-}
-export function convertActionDefinitionsToBaml(tb, actionVocabulary) {
-    /**
-     * Convert action definitions to BAML TypeBuilder union representing any one of the actions
-     */
-    return tb.union(actionVocabulary.map(action => convertZodToBaml(tb, actionInputSchema(action))));
-}
-// One wire schema for BAML's prompt and provider-enforced structured output.
-export function actionInputSchema({ name, description, schema }) {
-    const wrapper = z.object({ variant: description ? z.literal(name).describe(description) : z.literal(name) });
-    return schema instanceof ZodObject ? wrapper.merge(schema) : wrapper.extend({ input: schema });
-}
-//const tb = new TypeBuilder();
-//console.log(convertZodToBaml(tb, z.string()))
-//console.log(zodToJsonSchema(z.string()))

package/dist/actions/webActions.d.ts

@@ -1,87 +0,0 @@
-import { ActionDefinition } from ".";
-export declare const clickCoordAction: ActionDefinition<{
-    x: number;
-    y: number;
-}>;
-export declare const mouseDoubleClickAction: ActionDefinition<{
-    x: number;
-    y: number;
-}>;
-export declare const mouseHoverAction: ActionDefinition<{
-    x: number;
-    y: number;
-}>;
-export declare const mouseRightClickAction: ActionDefinition<{
-    x: number;
-    y: number;
-}>;
-export declare const mouseDragAction: ActionDefinition<{
-    from: {
-        x: number;
-        y: number;
-    };
-    to: {
-        x: number;
-        y: number;
-    };
-}>;
-export declare const typeAction: ActionDefinition<{
-    content: string;
-}>;
-export declare const keyboardEnterAction: ActionDefinition<any>;
-export declare const keyboardTabAction: ActionDefinition<any>;
-export declare const keyboardBackspaceAction: ActionDefinition<any>;
-export declare const keyboardSelectAllAction: ActionDefinition<any>;
-export declare const keyboardEscapeAction: ActionDefinition<{}>;
-export declare const scrollCoordAction: ActionDefinition<{
-    x: number;
-    y: number;
-    deltaX: number;
-    deltaY: number;
-}>;
-export declare const switchTabAction: ActionDefinition<{
-    index: number;
-}>;
-export declare const newTabAction: ActionDefinition<{}>;
-export declare const navigateAction: ActionDefinition<{
-    url: string;
-}>;
-export declare const goBackAction: ActionDefinition<{}>;
-export declare const waitAction: ActionDefinition<{
-    seconds: number;
-}>;
-export declare const webActions: readonly [ActionDefinition<{
-    x: number;
-    y: number;
-}>, ActionDefinition<{
-    x: number;
-    y: number;
-}>, ActionDefinition<{
-    x: number;
-    y: number;
-}>, ActionDefinition<{
-    x: number;
-    y: number;
-}>, ActionDefinition<{
-    x: number;
-    y: number;
-    deltaX: number;
-    deltaY: number;
-}>, ActionDefinition<{
-    from: {
-        x: number;
-        y: number;
-    };
-    to: {
-        x: number;
-        y: number;
-    };
-}>, ActionDefinition<{}>, ActionDefinition<{
-    index: number;
-}>, ActionDefinition<{
-    url: string;
-}>, ActionDefinition<{
-    content: string;
-}>, ActionDefinition<any>, ActionDefinition<any>, ActionDefinition<any>, ActionDefinition<{}>, ActionDefinition<any>, ActionDefinition<{
-    seconds: number;
-}>];

package/dist/actions/webActions.js

@@ -1,214 +0,0 @@
-import { createAction } from ".";
-import { z } from "zod";
-import { BrowserConnector } from "@/connectors/browserConnector"; // Changed from WebInteractionFacet
-export const clickCoordAction = createAction({
-    name: 'mouse:click',
-    description: "Click something",
-    schema: z.object({
-        x: z.number().int(),
-        y: z.number().int(),
-    }),
-    resolver: async ({ input: { x, y }, agent }) => {
-        const web = agent.require(BrowserConnector);
-        const harness = web.getHarness();
-        await harness.click({ x, y });
-    },
-    render: ({ x, y }) => `⊙ click (${x}, ${y})`
-});
-export const mouseDoubleClickAction = createAction({
-    name: 'mouse:double_click',
-    schema: z.object({
-        x: z.number().int(),
-        y: z.number().int(),
-    }),
-    resolver: async ({ input: { x, y }, agent }) => {
-        const web = agent.require(BrowserConnector);
-        const harness = web.getHarness();
-        await harness.doubleClick({ x, y });
-    },
-    render: ({ x, y }) => `⊙ double click (${x}, ${y})`
-});
-export const mouseHoverAction = createAction({
-    name: 'mouse:hover',
-    description: "Hover over an element to reveal tooltips, dropdown menus, or hidden content",
-    schema: z.object({
-        x: z.number().int(),
-        y: z.number().int(),
-    }),
-    resolver: async ({ input: { x, y }, agent }) => {
-        const web = agent.require(BrowserConnector);
-        await web.getHarness().hover({ x, y });
-    },
-    render: ({ x, y }) => `◎ hover (${x}, ${y})`
-});
-export const mouseRightClickAction = createAction({
-    name: 'mouse:right_click',
-    schema: z.object({
-        x: z.number().int(),
-        y: z.number().int(),
-    }),
-    resolver: async ({ input: { x, y }, agent }) => {
-        await agent.require(BrowserConnector).getHarness().rightClick({ x, y });
-    },
-    render: ({ x, y }) => `⊙ right click (${x}, ${y})`
-});
-export const mouseDragAction = createAction({
-    name: 'mouse:drag',
-    description: "Click and hold mouse in one location and release in another",
-    schema: z.object({
-        from: z.object({ x: z.number().int(), y: z.number().int() }),
-        to: z.object({ x: z.number().int(), y: z.number().int() })
-    }),
-    resolver: async ({ input: { from, to }, agent }) => {
-        const web = agent.require(BrowserConnector);
-        const harness = web.getHarness();
-        await harness.drag({ x1: from.x, y1: from.y, x2: to.x, y2: to.y });
-    },
-    render: ({ from, to }) => `⤡ drag (${from.x}, ${from.y}) -> (${to.x}, ${to.y})`
-});
-export const typeAction = createAction({
-    name: 'keyboard:type',
-    description: "Make sure to click where you need to type first", // make sure you click into it first
-    schema: z.object({
-        content: z.string().describe("Content to type"),
-    }),
-    resolver: async ({ input: { content }, agent }) => {
-        const webConnector = agent.require(BrowserConnector);
-        const harness = webConnector.getHarness();
-        await harness.type({ content });
-    },
-    render: ({ content }) => `⌨︎ type "${content}"`
-});
-export const keyboardEnterAction = createAction({
-    name: 'keyboard:enter',
-    resolver: async ({ agent }) => {
-        await agent.require(BrowserConnector).getHarness().enter();
-    },
-    render: () => `⏎ press enter`
-});
-export const keyboardTabAction = createAction({
-    name: 'keyboard:tab',
-    resolver: async ({ agent }) => {
-        await agent.require(BrowserConnector).getHarness().tab();
-    },
-    render: () => `⇥ press tab`
-});
-export const keyboardBackspaceAction = createAction({
-    name: 'keyboard:backspace',
-    resolver: async ({ agent }) => {
-        await agent.require(BrowserConnector).getHarness().backspace();
-    },
-    render: () => `⌫ press backspace`
-});
-export const keyboardSelectAllAction = createAction({
-    name: 'keyboard:select_all',
-    description: "Select all content in the active text area (CTRL+A)",
-    resolver: async ({ input: { content }, agent }) => {
-        await agent.require(BrowserConnector).getHarness().selectAll();
-    },
-    render: () => `⬚ select all`
-});
-export const keyboardEscapeAction = createAction({
-    name: 'keyboard:escape',
-    description: 'Press Escape to dismiss a dismissible dialog, menu, or focused interaction. This does not bypass a subscription or sign-in requirement.',
-    schema: z.object({}),
-    resolver: async ({ agent }) => {
-        await agent.require(BrowserConnector).getHarness().escape();
-    },
-    render: () => '⎋ press Escape'
-});
-export const scrollCoordAction = createAction({
-    name: 'mouse:scroll',
-    description: "Hover over the area to scroll. Distances are in pixels, not wheel ticks. To browse a full page, use about 500-600 pixels per scroll. Reserve small distances for fine adjustments or small scrollable areas.",
-    schema: z.object({
-        x: z.number().int(),
-        y: z.number().int(),
-        deltaX: z.number().int().describe("Horizontal distance in pixels: positive scrolls right, negative scrolls left. Use 0 for vertical-only scrolling."),
-        deltaY: z.number().int().describe("Vertical distance in pixels: 600 scrolls down, -600 scrolls up. Use about 500-600 to browse a full page; 5 moves only 5 pixels. Use smaller distances for fine adjustments and 0 for horizontal-only scrolling."),
-    }),
-    resolver: async ({ input: { x, y, deltaX, deltaY }, agent }) => {
-        const webConnector = agent.require(BrowserConnector);
-        const harness = webConnector.getHarness();
-        await harness.scroll({ x, y, deltaX, deltaY });
-    },
-    render: ({ x, y, deltaX, deltaY }) => `↕ scroll (${deltaX}px, ${deltaY}px)`
-});
-// Grounding agnostic
-export const switchTabAction = createAction({
-    name: 'browser:tab:switch',
-    description: "Switch to a tab that is already open",
-    schema: z.object({
-        index: z.number().int().describe("Index of tab to switch to"),
-    }),
-    resolver: async ({ input: { index }, agent }) => {
-        const webConnector = agent.require(BrowserConnector);
-        const harness = webConnector.getHarness();
-        await harness.switchTab({ index });
-    },
-    render: ({ index }) => `⧉ switch to tab ${index}`
-});
-export const newTabAction = createAction({
-    name: 'browser:tab:new',
-    description: "Open and switch to a new tab",
-    schema: z.object({}),
-    resolver: async ({ agent }) => {
-        const webConnector = agent.require(BrowserConnector);
-        const harness = webConnector.getHarness();
-        await harness.newTab();
-    },
-    render: () => `⊞ open new tab`
-});
-export const navigateAction = createAction({
-    name: 'browser:nav',
-    description: "Navigate to a URL directly",
-    schema: z.object({
-        url: z.string().describe('URL to navigate to'),
-    }),
-    resolver: async ({ input: { url }, agent }) => {
-        const webConnector = agent.require(BrowserConnector);
-        const harness = webConnector.getHarness();
-        await harness.navigate(url);
-    },
-    render: ({ url }) => `⛓︎ navigate to ${url}`
-});
-export const goBackAction = createAction({
-    name: 'browser:nav:back',
-    description: "Go back",
-    schema: z.object({}),
-    resolver: async ({ agent }) => {
-        const webConnector = agent.require(BrowserConnector);
-        const harness = webConnector.getHarness();
-        await harness.goBack();
-    },
-    render: () => `← navigate back`
-});
-// gets overused currently if we include this
-export const waitAction = createAction({
-    name: 'wait',
-    description: "Actions include smart waiting automatically - so only use this when a significant additional wait is clearly required.",
-    schema: z.object({
-        seconds: z.number().finite().nonnegative()
-    }),
-    resolver: async ({ input: { seconds }, agent }) => {
-        await agent.require(BrowserConnector).wait(seconds * 1000);
-    },
-    render: ({ seconds }) => `◴ wait for ${seconds}s`
-});
-export const webActions = [
-    clickCoordAction,
-    mouseDoubleClickAction,
-    mouseRightClickAction,
-    mouseHoverAction,
-    scrollCoordAction,
-    mouseDragAction,
-    newTabAction,
-    switchTabAction,
-    navigateAction,
-    typeAction,
-    keyboardEnterAction,
-    keyboardTabAction,
-    keyboardBackspaceAction,
-    keyboardEscapeAction,
-    keyboardSelectAllAction,
-    waitAction,
-];

package/dist/actions/webActions.test.d.ts

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

package/dist/actions/webActions.test.js

@@ -1,43 +0,0 @@
-import { expect, mock, test } from 'bun:test';
-import { zodToJsonSchema } from 'zod-to-json-schema';
-import { keyboardEscapeAction, scrollCoordAction, waitAction, webActions } from './webActions';
-test('Escape is exposed and forwards the Escape command', async () => {
-    const escape = mock(async () => { });
-    const agent = { require: () => ({ getHarness: () => ({ escape }) }) };
-    expect(webActions).toContain(keyboardEscapeAction);
-    await keyboardEscapeAction.resolver({ agent, input: {} });
-    expect(escape).toHaveBeenCalledTimes(1);
-});
-test('wait validates its duration and uses browser cooldown handling', async () => {
-    const wait = mock(async () => { });
-    const agent = { require: () => ({ wait }) };
-    await waitAction.resolver({ agent, input: { seconds: 2 } });
-    expect(wait).toHaveBeenCalledWith(2000);
-    expect(waitAction.schema.safeParse({ seconds: -1 }).success).toBe(false);
-    expect(waitAction.schema.safeParse({ seconds: Infinity }).success).toBe(false);
-});
-test('scroll scale and precision guidance are included in the action schema', () => {
-    const prompt = `${scrollCoordAction.description} ${JSON.stringify(zodToJsonSchema(scrollCoordAction.schema))}`;
-    expect(prompt).toContain('not wheel ticks');
-    expect(prompt).toContain('500-600');
-    expect(prompt).toContain('600 scrolls down, -600 scrolls up');
-    expect(prompt).toContain('positive scrolls right, negative scrolls left');
-    expect(prompt).toContain('fine adjustments');
-});
-for (const deltas of [
-    { deltaX: 0, deltaY: 5 },
-    { deltaX: 0, deltaY: -5 },
-    { deltaX: 0, deltaY: 600 },
-    { deltaX: 0, deltaY: -600 },
-    { deltaX: 600, deltaY: 0 },
-    { deltaX: -5, deltaY: 0 },
-]) {
-    test(`scroll forwards pixel distances unchanged: ${deltas.deltaX}, ${deltas.deltaY}`, async () => {
-        const scroll = mock(async () => { });
-        const agent = { require: () => ({ getHarness: () => ({ scroll }) }) };
-        const input = scrollCoordAction.schema.parse({ x: 120, y: 250, ...deltas });
-        await scrollCoordAction.resolver({ agent, input });
-        expect(scroll).toHaveBeenCalledTimes(1);
-        expect(scroll).toHaveBeenCalledWith({ x: 120, y: 250, ...deltas });
-    });
-}

package/dist/agent/browserAgent.d.ts

@@ -1,31 +0,0 @@
-import { BrowserContext, Page } from "playwright";
-import { Agent, AgentOptions } from ".";
-import { BrowserConnectorOptions } from "@/connectors/browserConnector";
-import { Schema, ZodSchema } from "zod";
-import z from "zod";
-import EventEmitter from "eventemitter3";
-import { type OperationOptions } from '@/common/operation';
-export declare function startBrowserAgent(options?: AgentOptions & BrowserConnectorOptions & {
-    narrate?: boolean;
-}): Promise<BrowserAgent>;
-type ExtractedOutput = string | number | boolean | bigint | Date | null | undefined | {
-    [key: string]: ExtractedOutput;
-} | ExtractedOutput[];
-export interface BrowserAgentEvents {
-    'nav': (url: string) => void;
-    'extractStarted': (instructions: string, schema: ZodSchema) => void;
-    'extractDone': (instructions: string, data: ExtractedOutput) => void;
-}
-export declare class BrowserAgent extends Agent {
-    readonly browserAgentEvents: EventEmitter<BrowserAgentEvents>;
-    constructor({ agentOptions, browserOptions }: {
-        agentOptions?: Partial<AgentOptions>;
-        browserOptions?: BrowserConnectorOptions;
-    });
-    get page(): Page;
-    get context(): BrowserContext;
-    nav(url: string, options?: OperationOptions): Promise<void>;
-    extract<T extends Schema>(instructions: string, schema: T, options?: OperationOptions): Promise<z.infer<T>>;
-    private _extract;
-}
-export {};