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

package/dist/ai/util.d.ts

@@ -1,13 +0,0 @@
-import { type LLMClient } from '@/ai/types';
-import { AgentOptions } from "@/agent";
-import { BrowserConnectorOptions } from "@/connectors/browserConnector";
-export declare function convertToBamlClientOptions(client: LLMClient): Promise<Record<string, any>>;
-export declare function tryDeriveUIGroundedClient(): LLMClient | null;
-export declare function isClaude(llm: LLMClient): boolean;
-export declare function buildDefaultBrowserAgentOptions({ agentOptions, browserOptions }: {
-    agentOptions: AgentOptions;
-    browserOptions: BrowserConnectorOptions;
-}): {
-    agentOptions: AgentOptions;
-    browserOptions: BrowserConnectorOptions;
-};

package/dist/ai/util.js

@@ -1,200 +0,0 @@
-import { completeClaudeCodeAuthFlow } from './claudeCode';
-import { DEFAULT_BASETEN_BASE_URL, DEFAULT_BASETEN_MODEL, validateBasetenOptions } from './baseten';
-function cleanNestedObject(obj) {
-    // Remove null/undefined key values entirely
-    return Object.fromEntries(Object.entries(obj)
-        // Filter out null/undefined values
-        .filter(([_, value]) => value !== null && value !== undefined)
-        // Process nested objects recursively
-        .map(([key, value]) => [
-        key,
-        typeof value === 'object' ? cleanNestedObject(value) : value
-    ]));
-}
-export async function convertToBamlClientOptions(client) {
-    // extract options compatible with https://docs.boundaryml.com/ref/llm-client-providers/overview
-    // Default to temperature 0.0
-    // Some client options (e.g. azure) do not have a temperature setting
-    const temp = 'temperature' in client.options ?
-        (client.options.temperature ?? 0.0) : 0.0;
-    let options;
-    if (client.provider === 'claude-code') {
-        // Special case - oauth with claude code max anthropic account
-        const oauthToken = await completeClaudeCodeAuthFlow();
-        options = {
-            model: client.options.model,
-            temperature: temp,
-            max_tokens: client.options.maxTokens,
-            headers: {
-                'Authorization': `Bearer ${oauthToken}`,
-                'anthropic-beta': 'oauth-2025-04-20' + (client.options.promptCaching ? ',prompt-caching-2024-07-31' : ''),
-                // Overrides this header from being automatically derived from ANTHROPIC_API_KEY
-                'X-API-Key': ''
-            },
-            ...(client.options.promptCaching ? { allowed_role_metadata: "all" } : {}),
-        };
-    }
-    else if (client.provider === 'anthropic') {
-        options = {
-            api_key: client.options.apiKey,
-            model: client.options.model,
-            temperature: temp,
-            max_tokens: client.options.maxTokens,
-            ...(client.options.promptCaching ? {
-                allowed_role_metadata: "all",
-                headers: { 'anthropic-beta': 'prompt-caching-2024-07-31' }
-            } : {}),
-        };
-    }
-    else if (client.provider === 'aws-bedrock') {
-        options = {
-            model_id: client.options.model,
-            inference_configuration: {
-                temperature: temp,
-            }
-        };
-    }
-    else if (client.provider === 'google-ai') {
-        options = {
-            base_url: client.options.baseUrl,
-            model: client.options.model,
-            api_key: client.options.apiKey,
-            generationConfig: {
-                temperature: temp,
-                //thinking_budget: 0
-            }
-        };
-    }
-    else if (client.provider === 'vertex-ai') {
-        options = {
-            location: client.options.location,
-            base_url: client.options.baseUrl,
-            project_id: client.options.projectId,
-            credentials: client.options.credentials,
-            anthropic_version: client.options.anthropicVersion,
-            model: client.options.model,
-            // generationConfig: {
-            //     temperature: temp,
-            // }
-        };
-    }
-    else if (client.provider === 'openai') {
-        options = {
-            api_key: client.options.apiKey,
-            base_url: client.options.baseUrl,
-            model: client.options.model,
-            temperature: client.options.temperature,
-            reasoning_effort: client.options.reasoningEffort,
-            max_completion_tokens: client.options.maxCompletionTokens,
-        };
-    }
-    else if (client.provider === 'baseten') {
-        validateBasetenOptions(client.options);
-        const apiKey = client.options.apiKey ?? process.env.BASETEN_API_KEY;
-        if (!apiKey)
-            throw new Error('Set BASETEN_API_KEY or provide llm.options.apiKey for the Baseten provider.');
-        options = {
-            base_url: client.options.baseUrl ?? DEFAULT_BASETEN_BASE_URL,
-            api_key: apiKey,
-            model: client.options.model,
-            temperature: client.options.temperature,
-            reasoning_effort: client.options.reasoningEffort,
-            max_tokens: client.options.maxTokens,
-        };
-    }
-    else if (client.provider === 'openai-generic') {
-        options = {
-            base_url: client.options.baseUrl,
-            api_key: client.options.apiKey,
-            model: client.options.model,
-            temperature: temp,
-            headers: {
-                "HTTP-Referer": "https://magnitude.run",
-                "X-Title": "Magnitude",
-                ...client.options.headers
-            }
-        };
-    }
-    else if (client.provider === 'azure-openai') {
-        options = {
-            resource_name: client.options.resourceName,
-            deployment_id: client.options.deploymentId,
-            api_version: client.options.apiVersion,
-            api_key: client.options.apiKey
-        };
-    }
-    else {
-        throw new Error(`Invalid provider: ${client.provider}`);
-    }
-    return cleanNestedObject(options);
-}
-export function tryDeriveUIGroundedClient() {
-    if (process.env.ANTHROPIC_API_KEY) {
-        return {
-            provider: 'anthropic',
-            options: {
-                // TODO: do more testing on best claude model for visuals
-                // model: 'claude-3-5-sonnet-20240620', // <- definitely not, pre computer use
-                // model: 'claude-3-5-sonnet-20241022', // <- not great on rescaling res
-                //model: 'claude-3-7-sonnet-latest', // <- underplans
-                // model: 'claude-sonnet-4-20250514', // <- underplans, also supposedly worse at visual reasoning
-                model: 'claude-haiku-4-5-20251001', // <- fast, cost-effective, good performance
-                apiKey: process.env.ANTHROPIC_API_KEY
-            }
-        };
-    }
-    else if (process.env.OPENAI_API_KEY) {
-        return {
-            provider: 'openai',
-            options: { model: 'gpt-5.6-luna', apiKey: process.env.OPENAI_API_KEY }
-        };
-    }
-    else if (process.env.BASETEN_API_KEY) {
-        return {
-            provider: 'baseten',
-            options: { model: DEFAULT_BASETEN_MODEL, apiKey: process.env.BASETEN_API_KEY }
-        };
-    }
-    else {
-        return null;
-    }
-}
-export function isClaude(llm) {
-    if ('model' in llm.options) { //if (llm.provider === 'anthropic' || llm.provider === 'aws-bedrock' || llm.provider === 'vertex-ai') {
-        const model = llm.options.model;
-        if (model.includes('claude'))
-            return true;
-    }
-    return false;
-}
-const DEFAULT_BROWSER_AGENT_TEMP = 0.2;
-export function buildDefaultBrowserAgentOptions({ agentOptions, browserOptions }) {
-    /**
-     * Given any provided options for agent or browser connector, fill out additional key fields using environment,
-     * or any model-specific constraints (e.g. Claude needing 1024x768 virtual screen space)
-     */
-    const envLlm = tryDeriveUIGroundedClient();
-    let llms = agentOptions.llm ? (Array.isArray(agentOptions.llm) ? agentOptions.llm : [agentOptions.llm]) : (envLlm ? [envLlm] : []);
-    if (llms.length == 0) {
-        throw new Error("No LLM configured or available from environment. Set ANTHROPIC_API_KEY, OPENAI_API_KEY, or BASETEN_API_KEY, or configure llm explicitly. See https://docs.magnitude.run/customizing/llm-configuration for details");
-    }
-    // Set reasonable temp if not provided
-    let virtualScreenDimensions = null;
-    for (const llm of llms) {
-        let llmOptions = {
-            ...(llm.provider === 'openai' || llm.provider === 'baseten' ? {} : { temperature: DEFAULT_BROWSER_AGENT_TEMP }),
-            ...llm.options
-        };
-        //let modifiedLlm = {...llm, options: llmOptions as any }
-        llm.options = llmOptions;
-        if (isClaude(llm)) {
-            // Claude only really works on 1024x768 screenshots
-            // if any model is claude, use virtual screen dimensions
-            virtualScreenDimensions = { width: 1024, height: 768 };
-        }
-    }
-    return {
-        agentOptions: { ...agentOptions, llm: llms },
-        browserOptions: { ...browserOptions, virtualScreenDimensions: virtualScreenDimensions ?? undefined }
-    };
-}

package/dist/ai/util.test.d.ts

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

package/dist/ai/util.test.js

@@ -1,95 +0,0 @@
-import { expect, test } from 'bun:test';
-import { buildDefaultBrowserAgentOptions, convertToBamlClientOptions, tryDeriveUIGroundedClient } from './util';
-import { DEFAULT_BASETEN_MODEL } from './baseten';
-test('Anthropic output limits are explicit and omitted limits retain transport defaults', async () => {
-    const options = { model: 'claude-sonnet-5', apiKey: 'fixture', temperature: 1 };
-    expect(await convertToBamlClientOptions({ provider: 'anthropic', options }))
-        .toEqual({ model: options.model, api_key: 'fixture', temperature: 1 });
-    expect(await convertToBamlClientOptions({ provider: 'anthropic', options: { ...options, maxTokens: 32_768 } }))
-        .toEqual({ model: options.model, api_key: 'fixture', temperature: 1, max_tokens: 32_768 });
-});
-test('OpenAI option conversion preserves explicit values without injecting sampling defaults', async () => {
-    expect(await convertToBamlClientOptions({ provider: 'openai', options: { model: 'gpt-5.6-luna' } }))
-        .toEqual({ model: 'gpt-5.6-luna' });
-    expect(await convertToBamlClientOptions({ provider: 'openai', options: {
-            model: 'gpt-5.6-luna', apiKey: 'fixture', baseUrl: 'http://127.0.0.1:8080/v1',
-            temperature: 0, reasoningEffort: 'none', maxCompletionTokens: 4096,
-        } })).toEqual({ model: 'gpt-5.6-luna', api_key: 'fixture', base_url: 'http://127.0.0.1:8080/v1',
-        temperature: 0, reasoning_effort: 'none', max_completion_tokens: 4096 });
-});
-test('Baseten uses its own credentials, endpoint and token parameter', async () => {
-    const previous = process.env.BASETEN_API_KEY;
-    try {
-        process.env.BASETEN_API_KEY = 'fixture-baseten';
-        expect(await convertToBamlClientOptions({ provider: 'baseten', options: { model: DEFAULT_BASETEN_MODEL } }))
-            .toEqual({ model: DEFAULT_BASETEN_MODEL, api_key: 'fixture-baseten', base_url: 'https://inference.baseten.co/v1' });
-        expect(await convertToBamlClientOptions({ provider: 'baseten', options: {
-                model: DEFAULT_BASETEN_MODEL, apiKey: 'override', baseUrl: 'http://127.0.0.1:8080/v1',
-                temperature: 0, reasoningEffort: 'none', maxTokens: 4096,
-            } })).toEqual({ model: DEFAULT_BASETEN_MODEL, api_key: 'override', base_url: 'http://127.0.0.1:8080/v1',
-            temperature: 0, reasoning_effort: 'none', max_tokens: 4096 });
-        for (const reasoningEffort of ['minimal', 'medium', 'xhigh']) {
-            await expect(convertToBamlClientOptions({ provider: 'baseten', options: { model: DEFAULT_BASETEN_MODEL, reasoningEffort } }))
-                .rejects.toThrow('reasoning effort must be none, low, high, or max');
-        }
-        delete process.env.BASETEN_API_KEY;
-        await expect(convertToBamlClientOptions({ provider: 'baseten', options: { model: DEFAULT_BASETEN_MODEL } }))
-            .rejects.toThrow('Set BASETEN_API_KEY');
-    }
-    finally {
-        if (previous === undefined)
-            delete process.env.BASETEN_API_KEY;
-        else
-            process.env.BASETEN_API_KEY = previous;
-    }
-});
-test('browser defaults leave OpenAI and Baseten sampling unset while retaining Claude defaults', () => {
-    const llm = [
-        { provider: 'openai', options: { model: 'gpt-5.6-luna', reasoningEffort: 'high' } },
-        { provider: 'anthropic', options: { model: 'claude-haiku-4-5-20251001' } },
-        { provider: 'baseten', options: { model: DEFAULT_BASETEN_MODEL, reasoningEffort: 'high' } },
-    ];
-    const result = buildDefaultBrowserAgentOptions({ agentOptions: { llm }, browserOptions: {} });
-    expect(llm[0].options).toEqual({ model: 'gpt-5.6-luna', reasoningEffort: 'high' });
-    expect(llm[1].options).toEqual({ model: 'claude-haiku-4-5-20251001', temperature: 0.2 });
-    expect(llm[2].options).toEqual({ model: DEFAULT_BASETEN_MODEL, reasoningEffort: 'high' });
-    expect(result.browserOptions.virtualScreenDimensions).toEqual({ width: 1024, height: 768 });
-});
-test('environment discovery supports Baseten alone and preserves existing provider precedence', () => {
-    const previous = { anthropic: process.env.ANTHROPIC_API_KEY, openai: process.env.OPENAI_API_KEY, baseten: process.env.BASETEN_API_KEY };
-    try {
-        delete process.env.ANTHROPIC_API_KEY;
-        delete process.env.OPENAI_API_KEY;
-        delete process.env.BASETEN_API_KEY;
-        expect(tryDeriveUIGroundedClient()).toBeNull();
-        expect(() => buildDefaultBrowserAgentOptions({ agentOptions: {}, browserOptions: {} })).toThrow('OPENAI_API_KEY');
-        process.env.BASETEN_API_KEY = 'fixture-baseten';
-        const baseten = buildDefaultBrowserAgentOptions({ agentOptions: {}, browserOptions: {} });
-        expect(baseten.agentOptions.llm).toEqual([{ provider: 'baseten', options: { model: DEFAULT_BASETEN_MODEL, apiKey: 'fixture-baseten' } }]);
-        expect(baseten.browserOptions.virtualScreenDimensions).toBeUndefined();
-        process.env.OPENAI_API_KEY = 'fixture-openai';
-        expect(tryDeriveUIGroundedClient()).toEqual({ provider: 'openai', options: { model: 'gpt-5.6-luna', apiKey: 'fixture-openai' } });
-        const defaults = buildDefaultBrowserAgentOptions({ agentOptions: {}, browserOptions: {} });
-        expect(defaults.agentOptions.llm).toEqual([{ provider: 'openai', options: { model: 'gpt-5.6-luna', apiKey: 'fixture-openai' } }]);
-        expect(defaults.browserOptions.virtualScreenDimensions).toBeUndefined();
-        process.env.ANTHROPIC_API_KEY = 'fixture-anthropic';
-        expect(tryDeriveUIGroundedClient()?.provider).toBe('anthropic');
-        const explicit = { provider: 'openai', options: { model: 'gpt-5.6-luna', temperature: 0 } };
-        expect(buildDefaultBrowserAgentOptions({ agentOptions: { llm: explicit }, browserOptions: {} }).agentOptions.llm).toEqual([explicit]);
-        expect(explicit.options.temperature).toBe(0);
-    }
-    finally {
-        if (previous.anthropic === undefined)
-            delete process.env.ANTHROPIC_API_KEY;
-        else
-            process.env.ANTHROPIC_API_KEY = previous.anthropic;
-        if (previous.openai === undefined)
-            delete process.env.OPENAI_API_KEY;
-        else
-            process.env.OPENAI_API_KEY = previous.openai;
-        if (previous.baseten === undefined)
-            delete process.env.BASETEN_API_KEY;
-        else
-            process.env.BASETEN_API_KEY = previous.baseten;
-    }
-});

package/dist/cli.js

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-

package/dist/common/actions.js

@@ -1,14 +0,0 @@
-"use strict";
-// import { ClickWebAction, NavigateWebAction, ScrollWebAction, SwitchTabWebAction, TypeWebAction } from "@/web/types";
-// import { ClickIntent, TypeIntent, ScrollIntent, SwitchTabIntent, Action } from "@/actions/types";
-// //'load' | 'click' | 'hover' | 'type' | 'scroll' | 'wait' | 'back';
-// // move somewhere else, to action types, why is this here
-// export type ActionDescriptor = Action & { screenshot: string };
-// // export type ActionDescriptor = NavigateActionDescriptor | ClickActionDescriptor | TypeActionDescriptor | ScrollActionDescriptor | SwitchTabDescriptor;
-// // export type ActionVariant = ActionDescriptor['variant'];
-// // export type NavigateActionDescriptor = NavigateWebAction & { screenshot: string };
-// // export type ClickActionDescriptor = ClickIntent & ClickWebAction & { screenshot: string };
-// // export type TypeActionDescriptor = TypeIntent & TypeWebAction & { screenshot: string };
-// // export type ScrollActionDescriptor = ScrollIntent & ScrollWebAction & { screenshot: string };
-// // export type SwitchTabDescriptor = SwitchTabIntent & SwitchTabWebAction & { screenshot: string };
-// //const a: ClickActionDescriptor = { variant: 'click', x: 1, y: 2, target: ''}

package/dist/common/events.d.ts

@@ -1,17 +0,0 @@
-import { Action } from "@/actions/types";
-import { ActOptions } from "@/agent";
-import { ModelUsage } from "@/ai/types";
-export interface AgentEvents {
-    'start': () => void;
-    'stop': () => void;
-    'thought': (thought: string) => void;
-    'actStarted': (task: string, options: ActOptions) => void;
-    'actDone': (task: string, options: ActOptions) => void;
-    'actionStarted': (action: Action) => void;
-    'actionDone': (action: Action) => void;
-    'observationsRecorded': () => void;
-    'planningStarted': () => void;
-    'pause': () => void;
-    'resume': () => void;
-    'tokensUsed': (usage: ModelUsage) => void;
-}

package/dist/common/events.js

@@ -1,3 +0,0 @@
-// Common interfaces that can be used anywhere
-// Goal is not to expose internals but provide all necessary info in events
-export {};

package/dist/common/failure.d.ts

@@ -1,68 +0,0 @@
-/**
- * Represents any reason why a test case could have failed, for example:
- * - Step could not be completed
- * - Check did not pass
- * - Could not navigate to starting URL
- * - Time or action based timeout
- * - Operation cancelled by signal
- * - ...
- */
-export type FailureDescriptor = BugDetectedFailure | MisalignmentFailure | NetworkFailure | BrowserFailure | RateLimitFailure | ApiKeyFailure | UnknownFailure | CancelledFailure;
-export type BugSeverity = 'critical' | 'high' | 'medium' | 'low';
-/**
- * Step and check failures are classified into one of:
- * BugDetectedFailure: seems to be something wrong with the application itself
- * MisalignmentFailure: seems to be a discrepency between the test case and the interface
- *    OR the agent did not properly recognize the relationship between test case and interface
- */
-export interface BugDetectedFailure {
-    variant: 'bug';
-    title: string;
-    expectedResult: string;
-    actualResult: string;
-    severity: BugSeverity;
-}
-export interface MisalignmentFailure {
-    /**
-     * Major misalignment: when a step/check fails due to:
-     * 1. Poorly written step/check that is completely unrelated to the interface
-     * 2. Or interface has changed so much that step/check no longer applicable
-     * 3. Planner did not do good enough job adjusting recipe for minor misalignment
-     * Misalignment could be due to a poorly written test case OR bad agent behavior.
-     */
-    variant: 'misalignment';
-    message: string;
-}
-export interface NetworkFailure {
-    /**
-     * For example, failure to connect to starting URL, or any other network errors
-     * that would completely prevent the test from executing.
-     */
-    variant: 'network';
-    message: string;
-}
-export interface BrowserFailure {
-    /**
-     * E.g. something goes wrong with playwright interactions, any DOM manipulation, etc.
-     */
-    variant: 'browser';
-    message: string;
-}
-export interface RateLimitFailure {
-    variant: 'rate_limit';
-    message: string;
-}
-export interface ApiKeyFailure {
-    variant: 'api_key';
-    message: string;
-}
-export interface UnknownFailure {
-    variant: 'unknown';
-    message: string;
-}
-export interface CancelledFailure {
-    /**
-     * Operation was cancelled, typically by an AbortSignal from a controlling process (e.g., test runner pool).
-     */
-    variant: 'cancelled';
-}

package/dist/common/failure.js

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

package/dist/common/index.d.ts

@@ -1,3 +0,0 @@
-export * from './events';
-export * from './failure';
-export * from './util';

package/dist/common/index.js

@@ -1,3 +0,0 @@
-export * from './events';
-export * from './failure';
-export * from './util';

package/dist/common/operation.d.ts

@@ -1,31 +0,0 @@
-export interface OperationOptions {
-    signal?: AbortSignal;
-    /** Absolute Unix time in milliseconds, shared by every step, retry, and wait. */
-    deadline?: number;
-}
-export declare class Operation {
-    readonly owner: object;
-    private options;
-    private controller;
-    private timer?;
-    private closed;
-    readonly signal: AbortSignal;
-    readonly deadline?: number;
-    private externalAbort;
-    constructor(owner: object, options: OperationOptions);
-    private scheduleDeadline;
-    cancel(reason?: unknown): void;
-    check(): void;
-    run<T>(fn: () => Promise<T>): Promise<T>;
-    dispose(): void;
-}
-export declare function currentOperation(): Operation | undefined;
-export declare function checkOperation(): void;
-export declare function operationOptions(): OperationOptions;
-/** Wait for every branch, even when one fails, before releasing the operation. */
-export declare function drainAll<T extends readonly unknown[]>(promises: {
-    [K in keyof T]: Promise<T[K]>;
-}): Promise<T>;
-/** Only race the public result or passive waits. The worker must still drain before reuse. */
-export declare function untilAborted<T>(promise: Promise<T>, signal?: AbortSignal): Promise<T>;
-export declare function operationSleep(ms: number, signal?: AbortSignal | undefined): Promise<void>;

package/dist/common/operation.js

@@ -1,102 +0,0 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
-import { OperationCancelledError, OperationDeadlineError } from '@/agent/errors';
-// Keep context through async callbacks so a late callback cannot act on a reused agent.
-const operations = new AsyncLocalStorage();
-export class Operation {
-    owner;
-    options;
-    controller = new AbortController();
-    timer;
-    closed = false;
-    signal = this.controller.signal;
-    deadline;
-    externalAbort = () => this.cancel(this.options.signal?.reason);
-    constructor(owner, options) {
-        this.owner = owner;
-        this.options = options;
-        if (options.deadline !== undefined && !Number.isFinite(options.deadline)) {
-            throw new TypeError('deadline must be a finite Unix timestamp in milliseconds');
-        }
-        this.deadline = options.deadline;
-        options.signal?.addEventListener('abort', this.externalAbort, { once: true });
-        if (options.signal?.aborted)
-            this.externalAbort();
-        this.scheduleDeadline();
-    }
-    scheduleDeadline() {
-        if (this.deadline === undefined || this.signal.aborted)
-            return;
-        const remaining = this.deadline - Date.now();
-        if (remaining <= 0)
-            this.controller.abort(new OperationDeadlineError(this.deadline));
-        else
-            this.timer = setTimeout(() => this.scheduleDeadline(), Math.min(remaining, 2_147_483_647));
-    }
-    cancel(reason) {
-        clearTimeout(this.timer);
-        if (!this.signal.aborted)
-            this.controller.abort(new OperationCancelledError(reason));
-    }
-    check() {
-        if (!this.signal.aborted && this.deadline !== undefined && Date.now() >= this.deadline) {
-            this.controller.abort(new OperationDeadlineError(this.deadline));
-        }
-        if (this.signal.aborted)
-            throw this.signal.reason;
-        if (this.closed)
-            throw new OperationCancelledError('Operation already finished');
-    }
-    run(fn) {
-        return operations.run(this, fn);
-    }
-    dispose() {
-        this.closed = true;
-        clearTimeout(this.timer);
-        this.options.signal?.removeEventListener('abort', this.externalAbort);
-    }
-}
-export function currentOperation() {
-    return operations.getStore();
-}
-export function checkOperation() {
-    currentOperation()?.check();
-}
-export function operationOptions() {
-    checkOperation();
-    const operation = currentOperation();
-    return { signal: operation?.signal, deadline: operation?.deadline };
-}
-/** Wait for every branch, even when one fails, before releasing the operation. */
-export async function drainAll(promises) {
-    const results = await Promise.allSettled(promises);
-    const failure = results.find(result => result.status === 'rejected');
-    if (failure?.status === 'rejected')
-        throw failure.reason;
-    return results.map(result => result.value);
-}
-/** Only race the public result or passive waits. The worker must still drain before reuse. */
-export function untilAborted(promise, signal) {
-    if (!signal)
-        return promise;
-    return new Promise((resolve, reject) => {
-        const abort = () => {
-            signal.removeEventListener('abort', abort);
-            reject(signal.reason);
-        };
-        signal.addEventListener('abort', abort, { once: true });
-        if (signal.aborted)
-            abort();
-        promise.then(resolve, reject).finally(() => signal.removeEventListener('abort', abort));
-    });
-}
-export async function operationSleep(ms, signal = currentOperation()?.signal) {
-    checkOperation();
-    let timer;
-    try {
-        await untilAborted(new Promise(resolve => { timer = setTimeout(resolve, ms); }), signal);
-        checkOperation();
-    }
-    finally {
-        clearTimeout(timer);
-    }
-}

package/dist/common/operation.test.d.ts

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

package/dist/common/operation.test.js

@@ -1,53 +0,0 @@
-import { expect, test } from 'bun:test';
-import { Operation, checkOperation, currentOperation, operationSleep } from './operation';
-import { OperationCancelledError, OperationDeadlineError } from '@/agent/errors';
-test('operation context is isolated across concurrent owners and cleared outside them', async () => {
-    const first = new Operation({}, {}), second = new Operation({}, {});
-    try {
-        await Promise.all([first, second].map(operation => operation.run(async () => {
-            await operationSleep(1);
-            expect(currentOperation()).toBe(operation);
-        })));
-        expect(currentOperation()).toBeUndefined();
-    }
-    finally {
-        first.dispose();
-        second.dispose();
-    }
-});
-test('deadline wakes waits and remains a typed cause', async () => {
-    const deadline = Date.now() + 30;
-    const operation = new Operation({}, { deadline });
-    try {
-        await expect(operation.run(() => operationSleep(10_000))).rejects.toBeInstanceOf(OperationDeadlineError);
-        expect(operation.signal.reason.deadline).toBe(deadline);
-    }
-    finally {
-        operation.dispose();
-    }
-});
-test('deadlines beyond the timer maximum do not overflow into immediate cancellation', async () => {
-    const operation = new Operation({}, { deadline: Date.now() + 2_147_483_647 + 100_000 });
-    try {
-        await operation.run(() => operationSleep(5));
-        expect(operation.signal.aborted).toBe(false);
-    }
-    finally {
-        operation.dispose();
-    }
-});
-test('first abort wins and external listeners are removed on disposal', async () => {
-    const controller = new AbortController();
-    const operation = new Operation({}, { signal: controller.signal });
-    operation.cancel('first');
-    controller.abort('second');
-    expect(operation.signal.reason).toBeInstanceOf(OperationCancelledError);
-    expect(operation.signal.reason.cause).toBe('first');
-    operation.dispose();
-    const anotherController = new AbortController();
-    const completed = new Operation({}, { signal: anotherController.signal });
-    completed.dispose();
-    anotherController.abort();
-    expect(completed.signal.aborted).toBe(false);
-    await expect(completed.run(async () => checkOperation())).rejects.toBeInstanceOf(OperationCancelledError);
-});

package/dist/common/retry.d.ts

@@ -1,16 +0,0 @@
-type RetryOptions = {
-    retries?: number;
-    delay?: number;
-    maxDelay?: number;
-    exponential?: boolean | number;
-    throwOnExhaustion?: boolean;
-    retryIf?: (error: Error) => boolean;
-    onRetry?: (error: Error, attempt: number) => void;
-};
-export declare function retry<T>(fn: () => Promise<T>, options: RetryOptions & {
-    throwOnExhaustion: false;
-}): Promise<T | null>;
-export declare function retry<T>(fn: () => Promise<T>, options?: RetryOptions & {
-    throwOnExhaustion?: true;
-}): Promise<T>;
-export {};