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

package/dist/agent/browserAgent.js

@@ -1,136 +0,0 @@
-import { Agent } from ".";
-import { BrowserConnector } from "@/connectors/browserConnector";
-import { buildDefaultBrowserAgentOptions } from "@/ai/util";
-import { narrateBrowserAgent } from "./narrator";
-import { partitionHtml, serializeToMarkdown } from 'magnitude-extract';
-import EventEmitter from "eventemitter3";
-import { retry } from "@/common/retry";
-import { checkOperation } from '@/common/operation';
-// export interface StartAgentWithWebOptions {
-//     agentBaseOptions?: Partial<AgentOptions>;
-//     webConnectorOptions?: BrowserConnectorOptions;
-// }
-const DEFAULT_BROWSER_AGENT_TEMP = 0.2;
-// Helper function to start a web agent
-export async function startBrowserAgent(options //StartAgentWithWebOptions = {}
-) {
-    //console.log("sba options:", options);
-    const { agentOptions, browserOptions } = buildDefaultBrowserAgentOptions({ agentOptions: options ?? {}, browserOptions: options ?? {} });
-    const agent = new BrowserAgent({
-        agentOptions: agentOptions,
-        browserOptions: browserOptions,
-    });
-    if (options?.narrate || process.env.MAGNITUDE_NARRATE) {
-        narrateBrowserAgent(agent);
-        //agent.events.on('actionStarted', (action: any) => { console.log(action) })
-    }
-    //console.log('starting agent')
-    await agent.start();
-    //console.log('agent started');
-    return agent;
-}
-async function getFullPageContent(page) {
-    checkOperation();
-    // 1. Get all iframe element handles
-    const iframeHandles = await page.locator('iframe').elementHandles();
-    // 2. Iterate through each iframe handle
-    for (const iframeHandle of iframeHandles) {
-        checkOperation();
-        // 3. Get the Frame object for the iframe
-        const frame = await iframeHandle.contentFrame();
-        checkOperation();
-        if (frame) {
-            // 4. Get the HTML content of the iframe
-            const iframeContent = await frame.content();
-            checkOperation();
-            // 5. Use evaluate to replace the iframe element with its content.
-            // We pass the content as an argument to avoid issues with string escaping.
-            await iframeHandle.evaluate((iframeNode, { content }) => {
-                // Create a new div element to hold the iframe's content
-                const div = document.createElement('div');
-                // Use DOMParser to handle Trusted Types restrictions
-                const parser = new DOMParser();
-                const doc = parser.parseFromString(content, 'text/html');
-                // Move all body children to the div
-                while (doc.body.firstChild) {
-                    div.appendChild(doc.body.firstChild);
-                }
-                // Also preserve any head elements that might be important (styles, etc)
-                const headElements = doc.head.querySelectorAll('style, link[rel="stylesheet"]');
-                headElements.forEach(el => div.appendChild(el.cloneNode(true)));
-                // Add a data-attribute to mark that this was an expanded iframe
-                div.dataset.expandedFromIframe = 'true';
-                div.dataset.iframeSrc = iframeNode.getAttribute('src') || '';
-                // Replace the iframeNode with the new div
-                iframeNode.parentNode?.replaceChild(div, iframeNode);
-            }, { content: iframeContent });
-        }
-    }
-    // 6. Return the final, modified page content
-    checkOperation();
-    return page.content();
-}
-export class BrowserAgent extends Agent {
-    browserAgentEvents = new EventEmitter();
-    constructor({ agentOptions, browserOptions }) {
-        //console.log("agent options:", agent);
-        //console.log("browser options:", browserOptions);
-        super({
-            ...agentOptions,
-            connectors: [new BrowserConnector(browserOptions || {}), ...(agentOptions?.connectors ?? [])]
-        });
-    }
-    get page() {
-        return this.require(BrowserConnector).getHarness().page;
-    }
-    get context() {
-        return this.require(BrowserConnector).getHarness().context;
-    }
-    async nav(url, options = {}) {
-        return this.runOperation(options, async () => {
-            this.browserAgentEvents.emit('nav', url);
-            checkOperation();
-            await this.require(BrowserConnector).getHarness().navigate(url);
-        });
-    }
-    async extract(instructions, schema, options = {}) {
-        return this.runOperation(options, () => this._extract(instructions, schema));
-    }
-    async _extract(instructions, schema) {
-        this.browserAgentEvents.emit('extractStarted', instructions, schema);
-        //const htmlContent = await this.page.content();
-        const htmlContent = await retry(async () => await getFullPageContent(this.page), { retries: 5, delay: 200, exponential: true });
-        // const accessibilityTree = await this.page.accessibility.snapshot({ interestingOnly: true });
-        // const pageRepr = renderMinimalAccessibilityTree(accessibilityTree);
-        const partitionOptions = {
-            extractImages: true,
-            extractForms: true,
-            extractLinks: true,
-            skipNavigation: false, // NAVIGATION SKIPPING IS BROKEN
-            minTextLength: 3,
-            includeOriginalHtml: false,
-            includeMetadata: true
-        };
-        // Process HTML
-        const result = partitionHtml(htmlContent, partitionOptions);
-        // Configure markdown serializer options
-        const markdownOptions = {
-            includeMetadata: false,
-            includePageNumbers: true,
-            includeElementIds: false,
-            includeCoordinates: false,
-            preserveHierarchy: true,
-            escapeSpecialChars: true,
-            includeFormFields: true,
-            includeImageMetadata: true
-        };
-        // Convert to markdown
-        const markdown = serializeToMarkdown(result, markdownOptions);
-        const screenshot = await this.require(BrowserConnector).getHarness().screenshot();
-        checkOperation();
-        const data = await this.models.extract(instructions, schema, screenshot, markdown);
-        checkOperation();
-        this.browserAgentEvents.emit('extractDone', instructions, data);
-        return data;
-    }
-}

package/dist/agent/errors.d.ts

@@ -1,22 +0,0 @@
-export interface AgentErrorOptions {
-    variant?: string;
-    adaptable?: boolean;
-}
-export declare class AgentError extends Error {
-    readonly options: Required<AgentErrorOptions>;
-    constructor(message: string, options?: AgentErrorOptions);
-}
-export declare class ActionLimitError extends AgentError {
-    readonly limit: number;
-    constructor(limit: number);
-}
-export declare class OperationCancelledError extends AgentError {
-    constructor(reason?: unknown);
-}
-export declare class OperationDeadlineError extends AgentError {
-    readonly deadline: number;
-    constructor(deadline: number);
-}
-export declare class AgentBusyError extends AgentError {
-    constructor();
-}

package/dist/agent/errors.js

@@ -1,97 +0,0 @@
-// export class AgentError extends Error {
-//     public readonly failure: FailureDescriptor;
-//     public readonly options: Required<AgentErrorOptions>;
-//     constructor(failure: FailureDescriptor, options: AgentErrorOptions = {}) {
-//         super(`${failure.variant}: ${JSON.stringify(failure.variant, null, 4)}`);
-//         this.options = {
-//             adaptable: options.adaptable ?? false
-//         };
-//         this.failure = failure;
-//     }
-// }
-export class AgentError extends Error {
-    //public readonly failure: FailureDescriptor;
-    options;
-    constructor(message, options = {}) {
-        // super(`${failure.variant}: ${JSON.stringify(failure.variant, null, 4)}`);
-        super(message);
-        this.options = {
-            variant: options.variant ?? 'unknown',
-            adaptable: options.adaptable ?? false,
-        };
-        // if (options.variant !== 'unknown') {
-        //     super(`${failure.variant}: ${JSON.stringify(failure.variant, null, 4)}`);
-        // }
-        //this.options = options;
-        //this.failure = failure;
-    }
-}
-export class ActionLimitError extends AgentError {
-    limit;
-    constructor(limit) {
-        super(`Task did not finish within ${limit} actions`, { variant: 'action_limit' });
-        this.limit = limit;
-        this.name = 'ActionLimitError';
-    }
-}
-export class OperationCancelledError extends AgentError {
-    constructor(reason) {
-        super('Operation cancelled', { variant: 'cancelled' });
-        this.name = 'OperationCancelledError';
-        this.cause = reason;
-    }
-}
-export class OperationDeadlineError extends AgentError {
-    deadline;
-    constructor(deadline) {
-        super('Operation deadline exceeded', { variant: 'deadline' });
-        this.deadline = deadline;
-        this.name = 'OperationDeadlineError';
-    }
-}
-export class AgentBusyError extends AgentError {
-    constructor() {
-        super('Agent has an active operation; await whenIdle() before reusing it', { variant: 'busy' });
-        this.name = 'AgentBusyError';
-    }
-}
-// // Agent will only throw these types of errors
-// import { ActionIngredient } from "./recipe/types";
-// import { WebAction } from "./web/types";
-// export class TestCaseError extends Error {};
-// // Base class for wrapping errors
-// class WrapperError extends TestCaseError {
-//     public readonly originalError: Error;
-//     constructor(message: string, originalError: Error) {
-//         super(`${message} - ${originalError.message}`);
-//         this.name = this.constructor.name;
-//         this.originalError = originalError;
-//         // Preserve the stack trace
-//         if (Error.captureStackTrace) {
-//             Error.captureStackTrace(this, this.constructor);
-//         }
-//     }
-// }
-// export class NavigationError extends WrapperError {
-//     public readonly url: string;
-//     constructor(url: string, originalError: Error) {
-//         super(`Failed to navigate to URL: ${url}`, originalError);
-//         this.url = url;
-//     }
-// }
-// export class ActionExecutionError extends WrapperError {
-//     public readonly action: WebAction;
-//     public readonly statusCode?: number;
-//     constructor(action: WebAction, originalError: Error) {
-//         super(`Browser encountered error while executing action: ${action}`, originalError);
-//         this.action = action;
-//     }
-// }
-// export class ActionConversionError extends WrapperError {
-//     public readonly action: ActionIngredient;
-//     public readonly statusCode?: number;
-//     constructor(action: ActionIngredient, originalError: Error) {
-//         super(`Micro failed to convert action (does the target line up with the screenshot?): ${action}`, originalError);
-//         this.action = action;
-//     }
-// }

package/dist/agent/index.d.ts

@@ -1,64 +0,0 @@
-import EventEmitter from "eventemitter3";
-import z from "zod";
-import { Action } from "@/actions/types";
-import { AgentEvents } from "@/common/events";
-import { AgentConnector } from '@/connectors';
-import { RenderableContent } from '@/memory/observation';
-import { LLMClient } from "@/ai/types";
-import { type OperationOptions } from '@/common/operation';
-import { AgentMemory, MemoryRenderOptions } from "@/memory";
-import { ActionDefinition } from "@/actions";
-import { MultiModelHarness } from '@/ai/multiModelHarness';
-export interface AgentOptions {
-    llm?: LLMClient | LLMClient[];
-    connectors?: AgentConnector[];
-    actions?: ActionDefinition<any>[];
-    prompt?: string | null;
-    telemetry?: boolean;
-    maxActions?: number;
-}
-export interface ActOptions extends OperationOptions {
-    prompt?: string;
-    data?: RenderableContent;
-    memory?: AgentMemory;
-}
-export declare class Agent {
-    private options;
-    private connectors;
-    private actions;
-    private memoryOptions;
-    readonly models: MultiModelHarness;
-    readonly events: EventEmitter<AgentEvents>;
-    private doneActing;
-    private _paused;
-    private _pauseResolve;
-    private activeOperation?;
-    private idle;
-    private stopped;
-    protected latestTaskMemory: AgentMemory;
-    constructor(baseConfig?: Partial<AgentOptions>);
-    getConnector<C extends AgentConnector>(connectorClass: new (...args: any[]) => C): C | undefined;
-    require<C extends AgentConnector>(connectorClass: new (...args: any[]) => C): C;
-    start(): Promise<void>;
-    identifyAction(action: Action): ActionDefinition<any>;
-    /** True until underlying work settles, including after a cancelled caller returns. */
-    get busy(): boolean;
-    whenIdle(): Promise<void>;
-    protected runOperation<T>(options: OperationOptions, fn: () => Promise<T>): Promise<T>;
-    exec(action: Action, memory?: AgentMemory, options?: OperationOptions): Promise<unknown>;
-    private _exec;
-    protected _recordConnectorObservations(memory: AgentMemory): Promise<void>;
-    get memory(): AgentMemory;
-    act(taskOrSteps: string | string[], options?: ActOptions): Promise<void>;
-    private _runAct;
-    private _traceAct;
-    private _buildContext;
-    private _act;
-    query<T extends z.Schema>(query: string, schema: T, options?: MemoryRenderOptions & OperationOptions): Promise<z.infer<T>>;
-    queueDone(): Promise<void>;
-    private _waitIfPaused;
-    pause(): void;
-    resume(): void;
-    get paused(): boolean;
-    stop(): Promise<void>;
-}