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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ddwang/magnitude-core",
-  "version": "0.3.1-ddwang.2",
+  "version": "0.3.1-ddwang.21",
   "description": "Magnitude e2e testing agent",
   "publishConfig": {
     "access": "public"
@@ -9,7 +9,7 @@
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.cts",
   "bin": {
-    "magnus": "dist/cli.js"
+    "magnus": "dist/cli.cjs"
   },
   "repository": {
     "type": "git",
@@ -32,10 +32,11 @@
     "typescript"
   ],
   "scripts": {
-    "build": "baml-cli generate && tsc && pkgroll",
+    "build": "baml-cli generate && tsc --noEmit && tsup",
     "check": "tsc --noEmit",
     "cli": "bun ./src/cli.ts",
-    "pubdev": "bun run build && yalc publish --force --push"
+    "pubdev": "bun run build && yalc publish --force --push",
+    "prepack": "node ../../scripts/prepare-browser-package.mjs"
   },
   "author": {
     "name": "Magnitude",
@@ -46,11 +47,14 @@
     "Anders Lie <anders@magnitude.run>"
   ],
   "license": "Apache-2.0",
+  "engines": {
+    "node": "^20.20.0 || >=22.22.0"
+  },
   "devDependencies": {
     "@types/node": "^22.13.4",
     "@types/object-hash": "^3.0.6",
-    "pkgroll": "^2.10.0",
-    "typescript": "~5.7.2"
+    "typescript": "~5.7.2",
+    "tsup": "^8.5.1"
   },
   "dependencies": {
     "@boundaryml/baml": "0.226.2",
@@ -62,10 +66,15 @@
     "object-hash": "^3.0.0",
     "pino": "^9.6.0",
     "pino-pretty": "^13.0.0",
-    "playwright": "npm:patchright@^1.52.0",
-    "posthog-node": "^5.1.1",
-    "sharp": "^0.33.5",
-    "zod": "^3.24.4",
-    "zod-to-json-schema": "^3.24.5"
-  }
+    "playwright": "npm:patchright@1.64.3",
+    "posthog-node": "5.61.2",
+    "sharp": "^0.35.5",
+    "zod": "^4.6.6",
+    "patchright-core": "1.64.3"
+  },
+  "type": "module",
+  "bundledDependencies": [
+    "playwright",
+    "patchright-core"
+  ]
 }

package/dist/actions/desktopActions.d.ts

@@ -1,58 +0,0 @@
-export declare const desktopClickAction: import(".").ActionDefinition<{
-    x: number;
-    y: number;
-}>;
-export declare const desktopRightClickAction: import(".").ActionDefinition<{
-    x: number;
-    y: number;
-}>;
-export declare const desktopDoubleClickAction: import(".").ActionDefinition<{
-    x: number;
-    y: number;
-}>;
-export declare const desktopDragAction: import(".").ActionDefinition<{
-    fromX: number;
-    fromY: number;
-    toX: number;
-    toY: number;
-}>;
-export declare const desktopScrollAction: import(".").ActionDefinition<{
-    x: number;
-    y: number;
-    deltaX: number;
-    deltaY: number;
-}>;
-export declare const desktopTypeAction: import(".").ActionDefinition<{
-    text: string;
-}>;
-export declare const desktopKeyAction: import(".").ActionDefinition<{
-    key: string;
-}>;
-export declare const desktopNavigateAction: import(".").ActionDefinition<{
-    url: string;
-}>;
-export declare const desktopWaitAction: import(".").ActionDefinition<{
-    seconds: number;
-}>;
-export declare const desktopActions: (import(".").ActionDefinition<{
-    x: number;
-    y: number;
-}> | import(".").ActionDefinition<{
-    fromX: number;
-    fromY: number;
-    toX: number;
-    toY: number;
-}> | import(".").ActionDefinition<{
-    x: number;
-    y: number;
-    deltaX: number;
-    deltaY: number;
-}> | import(".").ActionDefinition<{
-    text: string;
-}> | import(".").ActionDefinition<{
-    key: string;
-}> | import(".").ActionDefinition<{
-    url: string;
-}> | import(".").ActionDefinition<{
-    seconds: number;
-}>)[];

package/dist/actions/desktopActions.js

@@ -1,155 +0,0 @@
-import { createAction } from ".";
-import { operationSleep } from '@/common/operation';
-import { z } from "zod";
-import { DesktopConnector } from "@/connectors/desktopConnector";
-// Mouse actions
-export const desktopClickAction = createAction({
-    name: 'desktop:click',
-    description: "Click at screen coordinates",
-    schema: z.object({
-        x: z.number().int().describe("X coordinate"),
-        y: z.number().int().describe("Y coordinate"),
-    }),
-    resolver: async ({ input: { x, y }, agent }) => {
-        const desktop = agent.require(DesktopConnector);
-        await desktop.getInterface().click(x, y);
-    },
-    render: ({ x, y }) => `⊙ click (${x}, ${y})`
-});
-export const desktopRightClickAction = createAction({
-    name: 'desktop:right_click',
-    description: "Right-click at screen coordinates",
-    schema: z.object({
-        x: z.number().int(),
-        y: z.number().int(),
-    }),
-    resolver: async ({ input: { x, y }, agent }) => {
-        const desktop = agent.require(DesktopConnector);
-        await desktop.getInterface().rightClick(x, y);
-    },
-    render: ({ x, y }) => `⊙ right-click (${x}, ${y})`
-});
-export const desktopDoubleClickAction = createAction({
-    name: 'desktop:double_click',
-    description: "Double-click at screen coordinates",
-    schema: z.object({
-        x: z.number().int(),
-        y: z.number().int(),
-    }),
-    resolver: async ({ input: { x, y }, agent }) => {
-        const desktop = agent.require(DesktopConnector);
-        await desktop.getInterface().doubleClick(x, y);
-    },
-    render: ({ x, y }) => `⊙ double-click (${x}, ${y})`
-});
-export const desktopDragAction = createAction({
-    name: 'desktop:drag',
-    description: "Drag from one position to another",
-    schema: z.object({
-        fromX: z.number().int(),
-        fromY: z.number().int(),
-        toX: z.number().int(),
-        toY: z.number().int(),
-    }),
-    resolver: async ({ input: { fromX, fromY, toX, toY }, agent }) => {
-        const desktop = agent.require(DesktopConnector);
-        await desktop.getInterface().drag(fromX, fromY, toX, toY);
-    },
-    render: ({ fromX, fromY, toX, toY }) => `⊙ drag from (${fromX}, ${fromY}) to (${toX}, ${toY})`
-});
-export const desktopScrollAction = createAction({
-    name: 'desktop:scroll',
-    description: "Hover mouse over target and scroll",
-    schema: z.object({
-        x: z.number().int(),
-        y: z.number().int(),
-        deltaX: z.number().int().describe("Pixels to scroll horizontally"),
-        deltaY: z.number().int().describe("Pixels to scroll vertically"),
-    }),
-    resolver: async ({ input: { x, y, deltaX, deltaY }, agent }) => {
-        const desktop = agent.require(DesktopConnector);
-        await desktop.getInterface().scroll(x, y, deltaX, deltaY);
-    },
-    render: ({ x, y, deltaX, deltaY }) => `↕ scroll (${deltaX}px, ${deltaY}px)`
-});
-// Keyboard actions
-export const desktopTypeAction = createAction({
-    name: 'desktop:type',
-    description: "Type text at current cursor position",
-    schema: z.object({
-        text: z.string().describe("Text to type"),
-    }),
-    resolver: async ({ input: { text }, agent }) => {
-        const desktop = agent.require(DesktopConnector);
-        await desktop.getInterface().type(text);
-    },
-    render: ({ text }) => `⌨ type "${text}"`
-});
-export const desktopKeyAction = createAction({
-    name: 'desktop:key',
-    description: "Press a key or key combination. Use '+' to combine keys (e.g., 'cmd+c', 'ctrl+shift+t')",
-    schema: z.object({
-        key: z.string().describe("Key to press (e.g., 'enter', 'tab', 'esc') or combination (e.g., 'cmd+c', 'ctrl+a', 'ctrl+shift+t')"),
-    }),
-    resolver: async ({ input: { key }, agent }) => {
-        const desktop = agent.require(DesktopConnector);
-        // Check if it's a key combination (contains +)
-        if (key.includes('+')) {
-            // Parse the combination and use hotkey
-            const keys = key.split('+').map(k => k.trim());
-            await desktop.getInterface().hotkey(keys);
-        }
-        else {
-            // Single key press
-            await desktop.getInterface().key(key);
-        }
-    },
-    render: ({ key }) => {
-        // Show differently based on whether it's a combination
-        if (key.includes('+')) {
-            return `⌨ hotkey ${key}`;
-        }
-        return `⌨ key '${key}'`;
-    }
-});
-// Navigation
-export const desktopNavigateAction = createAction({
-    name: 'desktop:navigate',
-    description: "Open a new browser window/tab with the specified URL. For navigating within an existing browser window, interact with the address bar instead.",
-    schema: z.object({
-        url: z.string().describe("URL to open in a new browser window/tab"),
-    }),
-    resolver: async ({ input: { url }, agent }) => {
-        const desktop = agent.require(DesktopConnector);
-        const interface_ = desktop.getInterface();
-        if (!interface_.navigate) {
-            throw new Error("Desktop interface does not support navigation");
-        }
-        await interface_.navigate(url);
-    },
-    render: ({ url }) => `⛓ open browser with ${url}`
-});
-// Utility
-export const desktopWaitAction = createAction({
-    name: 'desktop: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().describe("Seconds to wait"),
-    }),
-    resolver: async ({ input: { seconds }, agent }) => {
-        await operationSleep(seconds * 1000);
-    },
-    render: ({ seconds }) => `◴ wait ${seconds}s`
-});
-// Export all desktop actions
-export const desktopActions = [
-    desktopClickAction,
-    desktopRightClickAction,
-    desktopDoubleClickAction,
-    desktopDragAction,
-    desktopScrollAction,
-    desktopTypeAction,
-    desktopKeyAction,
-    desktopNavigateAction,
-    desktopWaitAction,
-];

package/dist/actions/index.d.ts

@@ -1,27 +0,0 @@
-import type { Agent } from "@/agent";
-import type { AgentMemory } from '@/memory/agentMemory';
-import { RenderableContent } from "@/memory/observation";
-import { z, Schema, ZodTypeAny } from "zod";
-import type { OperationOptions } from '@/common/operation';
-export type ActionContext<T> = {
-    input: T;
-    agent: Agent;
-    memory?: AgentMemory;
-} & OperationOptions;
-export interface ActionDefinition<T> {
-    name: string;
-    description?: string;
-    schema: Schema<T>;
-    resolver: (context: ActionContext<T>) => Promise<void | RenderableContent>;
-    render: (action: T) => string;
-}
-export declare function createAction<S extends ZodTypeAny>(action: {
-    name: string;
-    description?: string;
-    schema?: S;
-    resolver: (context: ActionContext<z.infer<S>>) => Promise<void | RenderableContent>;
-    render?: (action: z.infer<S>) => string;
-}): ActionDefinition<z.infer<S>>;
-export type ActionPayload<A extends ActionDefinition<any>> = {
-    name: A['name'];
-} & z.infer<A['schema']>;

package/dist/actions/index.js

@@ -1,11 +0,0 @@
-import { z } from "zod";
-export function createAction(action) {
-    // Just a helper for automatic schema typing
-    return {
-        name: action.name,
-        description: action.description,
-        schema: action.schema ?? z.object({}),
-        resolver: action.resolver,
-        render: action.render ?? ((action) => JSON.stringify(action))
-    };
-}

package/dist/actions/memoryActions.d.ts

@@ -1,9 +0,0 @@
-export declare const memoryActions: (import(".").ActionDefinition<{
-    key: string;
-    text: string;
-    sources: number[];
-    operation: "add" | "correct";
-    expected_text: string | null;
-}> | import(".").ActionDefinition<{
-    key: string;
-}>)[];

package/dist/actions/memoryActions.js

@@ -1,34 +0,0 @@
-import { createAction } from '.';
-import { z } from 'zod';
-import { NOTEBOOK_LIMITS, noteUpdateSchema } from '@/memory/notebook';
-export const memoryActions = [
-    createAction({
-        name: 'memory:note',
-        description: 'Add a new record or explicitly correct one existing record before leaving facts needed later. Adds never overwrite. Corrections must match the targeted note\'s current text. Cite supporting observations. This consumes one action without interacting with the browser.',
-        schema: noteUpdateSchema,
-        resolver: async ({ input, agent, memory }) => {
-            try {
-                const { operation, expected_text, ...note } = input;
-                if (operation === 'add' ? expected_text !== null : expected_text === null) {
-                    throw new Error('Use expected_text null for add; for correct, copy the targeted note\'s exact current text.');
-                }
-                (memory ?? agent.memory).remember(note, expected_text ?? undefined);
-                return { saved: input.key };
-            }
-            catch (error) {
-                return { saved: false, error: String(error), instruction: 'No notes changed. Review the error and notebook. New records need new keys; corrections need an exact current-text match. Preserve existing facts when addressing source or capacity errors.' };
-            }
-        },
-        render: input => `note: ${input.key}`,
-    }),
-    createAction({
-        name: 'memory:forget',
-        description: 'Remove an obsolete task note after consolidating any facts still needed. This does not delete the captured observation history.',
-        schema: z.object({ key: z.string().min(1).max(NOTEBOOK_LIMITS.key) }),
-        resolver: async ({ input, agent, memory }) => {
-            (memory ?? agent.memory).forget(input.key);
-            return { forgotten: input.key };
-        },
-        render: input => `forget note: ${input.key}`,
-    }),
-];

package/dist/actions/taskActions.d.ts

@@ -1,8 +0,0 @@
-import { ActionDefinition } from ".";
-export declare const doneAction: ActionDefinition<{
-    evidence: string;
-}>;
-export declare const failAction: ActionDefinition<{}>;
-export declare const taskActions: readonly [ActionDefinition<{
-    evidence: string;
-}>, ActionDefinition<{}>];

package/dist/actions/taskActions.js

@@ -1,27 +0,0 @@
-import { AgentError } from "@/agent/errors";
-import { createAction } from ".";
-import { z } from "zod";
-export const doneAction = createAction({
-    name: 'task:done',
-    description: "ONLY once you have seen sufficient evidence of the task's completion, mark it as done", //Use once sure that task is finished',//'Designate current task as finished',// Do not use until you can verify the task is completed.
-    schema: z.object({
-        evidence: z.string().describe(`Specific observed evidence that verifies the task's completion. Do NOT predict this evidence.`)
-    }),
-    resolver: async ({ agent }) => {
-        agent.queueDone();
-    },
-    render: () => `✓ done`
-});
-export const failAction = createAction({
-    name: 'task:fail',
-    description: 'Use if task was attempted but does not seem possible. Use common sense', //'Designate current task as infeasible',
-    schema: z.object({}),
-    resolver: async ({ agent }) => {
-        throw new AgentError(`Task failed: ${agent.memory.getLastThoughtMessage() ?? "No thought recorded"}`);
-    },
-    render: () => `✕ fail`
-});
-export const taskActions = [
-    doneAction,
-    failAction
-];

package/dist/actions/types.d.ts

@@ -1,35 +0,0 @@
-/**
- * "Intents" are natural language descriptors that align 1:1 with executable web actions.
- * Micro converts intents into web actions.
- */
-import { SwitchTabWebAction } from "@/web/types";
-export interface Action {
-    variant: string;
-    [key: string]: any;
-}
-export type ActionIntent = ClickIntent | HoverIntent | TypeIntent | ScrollIntent | SwitchTabIntent;
-export type Intent = ActionIntent | CheckIntent;
-export interface ClickIntent {
-    variant: 'click';
-    target: string;
-}
-export interface HoverIntent {
-    variant: 'hover';
-    target: string;
-}
-export interface TypeIntent {
-    variant: 'type';
-    target: string;
-    content: string;
-}
-export interface ScrollIntent {
-    variant: 'scroll';
-    target: string;
-    deltaX: number;
-    deltaY: number;
-}
-export type SwitchTabIntent = SwitchTabWebAction;
-export interface CheckIntent {
-    variant: 'check';
-    checks: string[];
-}

package/dist/actions/types.js

@@ -1,5 +0,0 @@
-/**
- * "Intents" are natural language descriptors that align 1:1 with executable web actions.
- * Micro converts intents into web actions.
- */
-export {};

package/dist/actions/util.d.ts

@@ -1,21 +0,0 @@
-import { ActionDefinition } from ".";
-import TypeBuilder from "@/ai/baml_client/type_builder";
-import { FieldType } from "@boundaryml/baml/native";
-import { Schema, ZodSchema } from "zod";
-export interface JsonSchema {
-    type?: string;
-    title?: string;
-    description?: string;
-    default?: any;
-    properties?: Record<string, JsonSchema>;
-    required?: string[];
-    additionalProperties?: boolean | JsonSchema;
-    items?: JsonSchema;
-    enum?: any[];
-    $ref?: string;
-    anyOf?: JsonSchema[];
-    [key: string]: any;
-}
-export declare function convertZodToBaml(tb: TypeBuilder, schema: Schema): FieldType;
-export declare function convertActionDefinitionsToBaml<T>(tb: TypeBuilder, actionVocabulary: ActionDefinition<T>[]): FieldType;
-export declare function actionInputSchema<T>({ name, description, schema }: ActionDefinition<T>): ZodSchema<any>;