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

package/dist/ai/multiModelHarness.d.ts

@@ -1,24 +0,0 @@
-import { MultiMediaContentPart } from "@/memory/rendering";
-import { ModelHarnessEvents } from "./modelHarness";
-import { LLMClient } from "./types";
-import { ActionDefinition } from "@/actions";
-import { AgentContext } from "./baml_client";
-import { Image } from '@/memory/image';
-import EventEmitter from "eventemitter3";
-import z from "zod";
-import type { PlannerResponse } from './plannerResponse';
-export declare class MultiModelHarness {
-    /**
-     * Delegates model responsibilites to different LLMs and consolidates their usage
-     */
-    private roles;
-    private uniqueModels;
-    readonly events: EventEmitter<ModelHarnessEvents>;
-    constructor(clients: LLMClient[]);
-    setup(): Promise<void>;
-    describe(): string;
-    partialAct<T>(context: AgentContext, task: string, data: MultiMediaContentPart[], actionVocabulary: ActionDefinition<T>[]): Promise<PlannerResponse>;
-    extract<T extends z.Schema>(instructions: string, schema: T, screenshot: Image, domContent: string): Promise<z.infer<T>>;
-    query<T extends z.Schema>(context: AgentContext, query: string, schema: T): Promise<z.infer<T>>;
-    get numUniqueModels(): number;
-}

package/dist/ai/multiModelHarness.js

@@ -1,52 +0,0 @@
-import { ModelHarness } from "./modelHarness";
-import { allBrowserAgentRoles } from "./types";
-import EventEmitter from "eventemitter3";
-export class MultiModelHarness {
-    /**
-     * Delegates model responsibilites to different LLMs and consolidates their usage
-     */
-    // Roles may reference the same harness
-    roles = {};
-    uniqueModels = [];
-    events = new EventEmitter();
-    constructor(clients) {
-        // Sort by specificity (from least specific to most specific)
-        const sortedClients = clients.toSorted((a, b) => (b.roles ? b.roles.length : 9999) - (a.roles ? a.roles.length : 9999));
-        for (const client of sortedClients) {
-            const harness = new ModelHarness({ llm: client });
-            this.uniqueModels.push(harness);
-            if (client.roles) {
-                for (const role of client.roles) {
-                    this.roles[role] = harness;
-                }
-            }
-            else {
-                for (const role of allBrowserAgentRoles) {
-                    this.roles[role] = harness;
-                }
-            }
-            // Forward token usage events upward
-            harness.events.on('tokensUsed', (usage) => { this.events.emit('tokensUsed', usage); }, this);
-        }
-    }
-    async setup() {
-        await Promise.all(this.uniqueModels.map(model => model.setup()));
-    }
-    describe() {
-        // for now - describe least specific model
-        return this.uniqueModels[0].describeModel();
-    }
-    // TODO: generalize responsibility delegation
-    async partialAct(context, task, data, actionVocabulary) {
-        return await this.roles['act'].partialAct(context, task, data, actionVocabulary);
-    }
-    async extract(instructions, schema, screenshot, domContent) {
-        return await this.roles['extract'].extract(instructions, schema, screenshot, domContent);
-    }
-    async query(context, query, schema) {
-        return await this.roles['query'].query(context, query, schema);
-    }
-    get numUniqueModels() {
-        return this.uniqueModels.length;
-    }
-}

package/dist/ai/plannerResponse.d.ts

@@ -1,34 +0,0 @@
-import { z } from 'zod';
-import type { ActionDefinition } from '@/actions';
-import type { Action } from '@/actions/types';
-import { type NoteUpdate } from '@/memory/notebook';
-export interface PlannerResponse {
-    reasoning: string;
-    memory_updates: NoteUpdate[];
-    actions: Action[];
-}
-export declare const memoryUpdatesSchema: z.ZodArray<z.ZodObject<{
-    key: z.ZodString;
-    text: z.ZodString;
-    sources: z.ZodArray<z.ZodNumber, "many">;
-} & {
-    operation: z.ZodEnum<["add", "correct"]>;
-    expected_text: z.ZodNullable<z.ZodString>;
-}, "strict", z.ZodTypeAny, {
-    key: string;
-    text: string;
-    sources: number[];
-    operation: "add" | "correct";
-    expected_text: string | null;
-}, {
-    key: string;
-    text: string;
-    sources: number[];
-    operation: "add" | "correct";
-    expected_text: string | null;
-}>, "many">;
-export declare class PlannerResponseError extends Error {
-    readonly diagnostic: string;
-    constructor(diagnostic?: string, message?: string);
-}
-export declare function parsePlannerResponse<T>(raw: string | null, vocabulary: ActionDefinition<T>[]): PlannerResponse;

package/dist/ai/plannerResponse.js

@@ -1,96 +0,0 @@
-import { z } from 'zod';
-import { noteUpdateSchema, NOTEBOOK_LIMITS } from '@/memory/notebook';
-export const memoryUpdatesSchema = z.array(noteUpdateSchema).max(NOTEBOOK_LIMITS.entries)
-    .describe('Review the current observations before acting. Add exact facts and completed checks as separate records; correct only the targeted existing record with an exact current-text match. Omitted records stay unchanged. Return [] when nothing new needs retaining. Never record imagined action results. Each update costs one action.');
-export class PlannerResponseError extends Error {
-    diagnostic;
-    constructor(diagnostic = '$: expected one complete JSON plan with reasoning, memory_updates and actions', message = 'Invalid planner response') {
-        const bounded = diagnostic.slice(0, 1024);
-        super(`${message}: ${bounded}`);
-        this.name = 'PlannerResponseError';
-        this.diagnostic = bounded;
-    }
-}
-const planSchema = z.object({
-    reasoning: z.string().trim().min(1),
-    memory_updates: memoryUpdatesSchema,
-    actions: z.array(z.object({ variant: z.string() }).passthrough()).min(1),
-}).strict();
-// Only schema-owned field names and array indices may enter the repair prompt.
-// Record keys, custom refinement paths/messages and received values can contain
-// model output or page text; do not echo them into prompts or persisted errors.
-function diagnosticPath(schema, path, prefix) {
-    let current = schema;
-    for (const part of path.slice(0, 6)) {
-        for (let depth = 0; depth < 16; depth++) {
-            if (current instanceof z.ZodOptional || current instanceof z.ZodNullable)
-                current = current.unwrap();
-            else if (current instanceof z.ZodEffects)
-                current = current.innerType();
-            else if (current instanceof z.ZodDefault)
-                current = current.removeDefault();
-            else
-                break;
-        }
-        if (typeof part === 'string' && current instanceof z.ZodObject
-            && Object.hasOwn(current.shape, part) && /^[A-Za-z_][A-Za-z0-9_]{0,31}$/.test(part)) {
-            prefix += `.${part}`;
-            current = current.shape[part];
-        }
-        else if (typeof part === 'number' && Number.isSafeInteger(part) && part >= 0 && current instanceof z.ZodArray) {
-            prefix += `[${part}]`;
-            current = current.element;
-        }
-        else
-            return `${prefix}[*]`;
-    }
-    return path.length > 6 ? `${prefix}...` : prefix;
-}
-function schemaDiagnostic(error, schema, prefix = '$') {
-    const details = error.issues.slice(0, 3).map(issue => {
-        let constraint = '';
-        if (issue.code === 'invalid_type' && Object.hasOwn(z.ZodParsedType, issue.expected)) {
-            constraint = ` (expected ${issue.expected})`;
-        }
-        else if (issue.code === 'too_big' || issue.code === 'too_small') {
-            const limit = issue.code === 'too_big' ? issue.maximum : issue.minimum;
-            if (typeof limit === 'number' && Number.isFinite(limit)) {
-                constraint = ` (${issue.code === 'too_big' ? 'maximum' : 'minimum'} ${limit}, ${issue.inclusive ? 'inclusive' : 'exclusive'})`;
-            }
-        }
-        const code = Object.hasOwn(z.ZodIssueCode, issue.code) ? issue.code : 'schema constraint failed';
-        return `${diagnosticPath(schema, issue.path, prefix)}: ${code}${constraint}`;
-    });
-    if (error.issues.length > 3)
-        details.push('additional issues omitted');
-    return details.join('; ');
-}
-// BAML can coerce prose, incomplete JSON, or multiple objects into a plan. Do not
-// execute that recovery: a simulated multi-turn transcript is not a safe batch.
-export function parsePlannerResponse(raw, vocabulary) {
-    const text = raw?.trim() ?? '';
-    // Accept a single JSON fence for compatibility, but no surrounding narrative.
-    const fenced = /^```(?:json)?\s*\n([\s\S]*?)\n```$/i.exec(text);
-    let value;
-    try {
-        value = JSON.parse(fenced ? fenced[1] : text);
-    }
-    catch {
-        throw new PlannerResponseError('$: invalid_json; return exactly one complete JSON object');
-    }
-    const plan = planSchema.safeParse(value);
-    if (!plan.success)
-        throw new PlannerResponseError(schemaDiagnostic(plan.error, planSchema));
-    for (const [index, action] of plan.data.actions.entries()) {
-        const definition = vocabulary.find(candidate => candidate.name === action.variant);
-        if (!definition)
-            throw new PlannerResponseError(`$.actions[${index}].variant: unknown action; choose an action from the schema`);
-        const { variant, ...fields } = action;
-        const objectInput = definition.schema instanceof z.ZodObject;
-        const parsed = definition.schema.safeParse(objectInput ? fields : action.input);
-        if (!parsed.success) {
-            throw new PlannerResponseError(schemaDiagnostic(parsed.error, definition.schema, `$.actions[${index}]${objectInput ? '' : '.input'}`));
-        }
-    }
-    return plan.data;
-}

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

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

package/dist/ai/plannerResponse.test.js

@@ -1,112 +0,0 @@
-import { expect, test } from 'bun:test';
-import { z } from 'zod';
-import { createAction } from '@/actions';
-import { parsePlannerResponse, PlannerResponseError } from './plannerResponse';
-const vocabulary = [createAction({ name: 'click', schema: z.object({ x: z.number() }), resolver: async () => { } })];
-const plan = { reasoning: 'Click the observed button.', memory_updates: [], actions: [{ variant: 'click', x: 12 }] };
-test('accepts exactly one JSON plan, optionally in a single JSON fence', () => {
-    expect(parsePlannerResponse(JSON.stringify(plan), vocabulary)).toEqual(plan);
-    expect(parsePlannerResponse(['', '```json', JSON.stringify(plan), '```', ''].join('\n'), vocabulary)).toEqual(plan);
-});
-for (const raw of [
-    null, '', '<function_calls><invoke name="web_action">...</invoke></function_calls>',
-    `Here is the plan: ${JSON.stringify(plan)}`, `${JSON.stringify(plan)}\nNow I see a new page.`,
-    `${JSON.stringify(plan)}\n${JSON.stringify(plan)}`, JSON.stringify(plan).slice(0, -2),
-    JSON.stringify([plan]), JSON.stringify({ ...plan, actions: [] }),
-    JSON.stringify({ ...plan, reasoning: '' }), JSON.stringify({ actions: plan.actions }),
-    JSON.stringify({ ...plan, observations: 'Invented results' }),
-    JSON.stringify({ ...plan, actions: [{ variant: 'unknown', x: 12 }] }),
-    JSON.stringify({ ...plan, actions: [{ variant: 'click', x: '12' }] }),
-    JSON.stringify({ ...plan, actions: [{ variant: 'click' }] }),
-    JSON.stringify({ ...plan, actions: [...plan.actions, { variant: 'click', x: 'invalid' }] }),
-])
-    test(`rejects invalid planner output: ${String(raw).slice(0, 75)}`, () => {
-        expect(() => parsePlannerResponse(raw, vocabulary)).toThrow(PlannerResponseError);
-    });
-test('validates primitive action inputs without transforming them twice', () => {
-    const primitive = createAction({ name: 'say', schema: z.string().transform(text => `${text}!`), resolver: async () => { } });
-    const response = { reasoning: 'Answer.', memory_updates: [], actions: [{ variant: 'say', input: 'hello' }] };
-    expect(parsePlannerResponse(JSON.stringify(response), [primitive])).toEqual(response);
-});
-test('requires a bounded memory review and validates every update before accepting actions', () => {
-    const note = { key: 'record', text: 'Observed value: 731.', sources: [0], operation: 'add', expected_text: null };
-    const valid = { ...plan, memory_updates: [note] };
-    expect(parsePlannerResponse(JSON.stringify(valid), vocabulary)).toEqual(valid);
-    const correction = { ...valid, memory_updates: [{ ...note, operation: 'correct', expected_text: note.text, text: 'Corrected value: 914.' }] };
-    expect(parsePlannerResponse(JSON.stringify(correction), vocabulary)).toEqual(correction);
-    const { memory_updates, ...missing } = valid;
-    for (const invalid of [missing, ...[null, {}, [null], [{ ...note, sources: [] }],
-            [{ ...note, sources: [-1] }], [{ ...note, sources: ['0'] }], [{ ...note, sources: [0.5] }],
-            [{ ...note, text: '' }], [{ ...note, text: 'a'.repeat(2001) }], [{ ...note, key: 'a'.repeat(81) }],
-            [{ ...note, fabricated: true }], [{ ...note, operation: 'replace' }], [{ ...note, operation: undefined }],
-            [{ ...note, expected_text: undefined }], [{ ...note, expected_text: '' }], [{ ...note, expected_text: 'a'.repeat(2001) }],
-            Array(33).fill(note), [note, { ...note, sources: [] }],
-        ].map(memory_updates => ({ ...plan, memory_updates }))]) {
-        expect(() => parsePlannerResponse(JSON.stringify(invalid), vocabulary)).toThrow(PlannerResponseError);
-    }
-});
-function rejection(value, actions = vocabulary) {
-    try {
-        parsePlannerResponse(JSON.stringify(value), actions);
-    }
-    catch (error) {
-        expect(error).toBeInstanceOf(PlannerResponseError);
-        return error;
-    }
-    throw new Error('Expected the whole plan to be rejected');
-}
-test('diagnoses missing fields, empty actions, and nested note limits', () => {
-    const { memory_updates, ...missing } = plan;
-    expect(rejection(missing).diagnostic).toContain('$.memory_updates: invalid_type (expected array)');
-    expect(rejection({ ...plan, actions: [] }).diagnostic).toContain('$.actions: too_small (minimum 1, inclusive)');
-    const note = { key: 'record', text: 'x'.repeat(2001), sources: Array(9).fill(0), operation: 'add', expected_text: null };
-    const diagnostic = rejection({ ...plan, memory_updates: [note] }).diagnostic;
-    expect(diagnostic).toContain('$.memory_updates[0].text: too_big (maximum 2000, inclusive)');
-    expect(diagnostic).toContain('$.memory_updates[0].sources: too_big (maximum 8, inclusive)');
-});
-test('diagnoses the failing action without exposing its values or unknown variant', () => {
-    const secret = 'REJECTED_RESPONSE_SECRET';
-    const error = rejection({ ...plan, actions: [...plan.actions, { variant: 'click', x: secret }] });
-    expect(error.diagnostic).toContain('$.actions[1].x: invalid_type (expected number)');
-    expect(error.message).toContain(error.diagnostic);
-    expect(error.message).not.toContain(secret);
-    const unknown = rejection({ ...plan, actions: [{ variant: secret }] });
-    expect(unknown.diagnostic).toContain('$.actions[0].variant: unknown action');
-    expect(unknown.message).not.toContain(secret);
-});
-test('primitive and wrapped action inputs retain precise schema paths', () => {
-    const say = createAction({ name: 'say', schema: z.string().max(4), resolver: async () => { } });
-    expect(rejection({ ...plan, actions: [{ variant: 'say', input: 'longer' }] }, [say]).diagnostic)
-        .toContain('$.actions[0].input: too_big (maximum 4, inclusive)');
-    const nested = createAction({ name: 'nested', schema: z.object({ items: z.array(z.object({ count: z.number().int() }).optional()) }), resolver: async () => { } });
-    expect(rejection({ ...plan, actions: [{ variant: 'nested', items: [{ count: 1.5 }] }] }, [nested]).diagnostic)
-        .toContain('$.actions[0].items[0].count: invalid_type (expected integer)');
-});
-test('diagnostics omit unknown keys, dynamic record keys, and custom refinement messages', () => {
-    const secret = 'REJECTED_RESPONSE_SECRET';
-    expect(rejection({ ...plan, [secret]: true }).message).not.toContain(secret);
-    const record = createAction({ name: 'record', schema: z.object({ values: z.record(z.number()) }), resolver: async () => { } });
-    const error = rejection({ ...plan, actions: [{ variant: 'record', values: { [secret]: 'invalid' } }] }, [record]);
-    expect(error.diagnostic).toContain('$.actions[0].values[*]: invalid_type (expected number)');
-    expect(error.message).not.toContain(secret);
-    const custom = createAction({ name: 'custom', schema: z.string().refine(() => false, { message: secret, path: [secret] }), resolver: async () => { } });
-    const refined = rejection({ ...plan, actions: [{ variant: 'custom', input: secret }] }, [custom]);
-    expect(refined.diagnostic).toContain('custom');
-    expect(refined.message).not.toContain(secret);
-});
-test('diagnostics remain bounded for many errors and enormous malformed text', () => {
-    const error = rejection({ ...plan, memory_updates: Array(100).fill({ key: '', text: '' }) });
-    expect(error.diagnostic.length).toBeLessThanOrEqual(1024);
-    expect(error.diagnostic).toContain('additional issues omitted');
-    const secret = 'REJECTED_RESPONSE_SECRET';
-    try {
-        parsePlannerResponse(`${secret.repeat(10000)}{`, vocabulary);
-    }
-    catch (error) {
-        expect(error).toBeInstanceOf(PlannerResponseError);
-        expect(error.diagnostic).toContain('invalid_json');
-        expect(error.message).not.toContain(secret);
-        return;
-    }
-    throw new Error('Malformed output was accepted');
-});

package/dist/ai/structuredOutput.d.ts

@@ -1,11 +0,0 @@
-import { type Schema } from 'zod';
-import type { LLMClient } from './types';
-import type { ActionDefinition } from '@/actions';
-type JsonSchema = Record<string, any>;
-export declare function usesStructuredOutput(client: LLMClient): boolean;
-export declare function plannerSchema(vocabulary: ActionDefinition<any>[]): Schema;
-export declare function anthropicOutputFormat(schema: Schema): {
-    type: 'json_schema';
-    schema: JsonSchema;
-} | undefined;
-export {};

package/dist/ai/structuredOutput.js

@@ -1,94 +0,0 @@
-import { zodToJsonSchema } from 'zod-to-json-schema';
-import { z } from 'zod';
-import { actionInputSchema } from '@/actions/util';
-import { memoryUpdatesSchema } from './plannerResponse';
-import { DEFAULT_BASETEN_BASE_URL } from './baseten';
-export function usesStructuredOutput(client) {
-    if (client.provider === 'baseten') {
-        return client.options.structuredOutputs ?? (client.options.baseUrl === undefined
-            || client.options.baseUrl.replace(/\/+$/, '') === DEFAULT_BASETEN_BASE_URL);
-    }
-    if (client.provider !== 'anthropic')
-        return false;
-    // Unknown/older models and OAuth providers keep their existing transport.
-    return client.options.structuredOutputs ?? /^claude-(?:haiku-4-5|sonnet-(?:4-5|4-6|5)|opus-(?:4-5|4-6|4-7|4-8|5))(?:-\d{8})?$/.test(client.options.model);
-}
-export function plannerSchema(vocabulary) {
-    const actions = vocabulary.map(actionInputSchema);
-    if (!actions.length)
-        throw new Error('Planner requires at least one action definition');
-    return z.object({
-        reasoning: z.string(),
-        memory_updates: memoryUpdatesSchema,
-        actions: z.array(actions.length === 1 ? actions[0] : z.union(actions)).min(1),
-    });
-}
-// https://platform.claude.com/docs/en/build-with-claude/structured-outputs
-// Provider constraints are narrower than Zod. Retain unsupported value constraints
-// in descriptions and validate the response against the original Zod schema.
-// Open maps, recursive schemas, and unknown schema constructs use the existing
-// BAML path instead of silently changing the caller's data shape.
-export function anthropicOutputFormat(schema) {
-    const root = zodToJsonSchema(schema);
-    const constraints = new Set(['minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum', 'multipleOf', 'minLength', 'maxLength', 'pattern', 'format', 'maxItems', 'uniqueItems']);
-    const annotations = new Set(['$schema', 'definitions', '$defs', 'title', 'description', 'default']);
-    let optionalCount = 0;
-    let unionCount = 0;
-    function convert(input, ancestors = new Set()) {
-        if (!input || typeof input !== 'object' || Array.isArray(input) || ancestors.has(input))
-            throw new Error('Unsupported schema');
-        const path = new Set(ancestors).add(input);
-        if (input.$ref) {
-            if (!input.$ref.startsWith('#/'))
-                throw new Error('Unsupported schema reference');
-            const referenced = input.$ref.slice(2).split('/').reduce((value, key) => value?.[key.replaceAll('~1', '/').replaceAll('~0', '~')], root);
-            return convert(referenced, path);
-        }
-        const result = {};
-        const notes = [];
-        for (const [key, value] of Object.entries(input)) {
-            if (constraints.has(key) || (key === 'minItems' && value > 1)) {
-                notes.push(`${key}: ${JSON.stringify(value)}`);
-            }
-            else if (key === 'properties') {
-                result.properties = Object.fromEntries(Object.entries(value).map(([name, property]) => [name, convert(property, path)]));
-            }
-            else if (key === 'items') {
-                result.items = convert(value, path);
-            }
-            else if (key === 'anyOf' || key === 'allOf') {
-                if (key === 'anyOf')
-                    unionCount++;
-                result[key] = value.map((item) => convert(item, path));
-            }
-            else if (['type', 'enum', 'const', 'required', 'minItems', 'additionalProperties'].includes(key)) {
-                result[key] = value;
-                if (key === 'type' && Array.isArray(value))
-                    unionCount++;
-            }
-            else if (!annotations.has(key))
-                throw new Error('Unsupported schema keyword');
-        }
-        if (!result.type && !result.anyOf && !result.allOf && !('const' in result) && !result.enum)
-            throw new Error('Unconstrained schema');
-        if (result.enum?.some((value) => value !== null && typeof value === 'object') || (result.const !== null && typeof result.const === 'object'))
-            throw new Error('Complex literal');
-        if (result.type === 'object') {
-            if (result.additionalProperties !== false)
-                throw new Error('Open-ended object');
-            optionalCount += Object.keys(result.properties ?? {}).filter(key => !result.required?.includes(key)).length;
-        }
-        if (input.description || notes.length)
-            result.description = [input.description, ...notes].filter(Boolean).join('\n');
-        return result;
-    }
-    try {
-        const converted = convert(root);
-        if (optionalCount > 24 || unionCount > 16)
-            return undefined;
-        return { type: 'json_schema', schema: converted };
-    }
-    catch {
-        return undefined;
-    }
-}

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

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

package/dist/ai/structuredOutput.test.js

@@ -1,91 +0,0 @@
-import { expect, test } from 'bun:test';
-import { z } from 'zod';
-import { createAction } from '@/actions';
-import { webActions } from '@/actions/webActions';
-import { anthropicOutputFormat, plannerSchema, usesStructuredOutput } from './structuredOutput';
-test('Anthropic native output is automatic only for known supported direct models', () => {
-    for (const model of ['claude-haiku-4-5-20251001', 'claude-sonnet-5', 'claude-opus-4-6']) {
-        expect(usesStructuredOutput({ provider: 'anthropic', options: { model } })).toBe(true);
-        expect(usesStructuredOutput({ provider: 'anthropic', options: { model, structuredOutputs: false } })).toBe(false);
-    }
-    for (const model of ['claude-sonnet-4-20250514', 'claude-sonnet-50', 'future-custom-model']) {
-        expect(usesStructuredOutput({ provider: 'anthropic', options: { model } })).toBe(false);
-    }
-    expect(usesStructuredOutput({ provider: 'anthropic', options: { model: 'future-custom-model', structuredOutputs: true } })).toBe(true);
-    expect(usesStructuredOutput({ provider: 'claude-code', options: { model: 'claude-sonnet-5' } })).toBe(false);
-    expect(usesStructuredOutput({ provider: 'openai', options: { model: 'claude-sonnet-5' } })).toBe(false);
-});
-test('Baseten hosted Model APIs enable native output with an explicit custom-endpoint opt-in', () => {
-    for (const model of ['deepseek-ai/DeepSeek-V4.1-Flash', 'zai-org/GLM-5.3-Flash', 'future-hosted-model']) {
-        for (const baseUrl of [undefined, 'https://inference.baseten.co/v1', 'https://inference.baseten.co/v1/']) {
-            expect(usesStructuredOutput({ provider: 'baseten', options: { model, baseUrl } })).toBe(true);
-            expect(usesStructuredOutput({ provider: 'baseten', options: { model, baseUrl, structuredOutputs: false } })).toBe(false);
-        }
-    }
-    for (const baseUrl of ['http://127.0.0.1:8080/v1', 'https://inference.baseten.co/v1/custom', 'https://proxy.example/v1']) {
-        expect(usesStructuredOutput({ provider: 'baseten', options: { model: 'custom', baseUrl } })).toBe(false);
-        expect(usesStructuredOutput({ provider: 'baseten', options: { model: 'custom', baseUrl, structuredOutputs: true } })).toBe(true);
-    }
-});
-test('wire schema uses existing action definitions, including primitive and nested payloads', () => {
-    const actions = [
-        createAction({ name: 'move', schema: z.object({ to: z.object({ x: z.number().int(), y: z.number().int() }) }), resolver: async () => { } }),
-        createAction({ name: 'report', schema: z.string(), resolver: async () => { } }),
-    ];
-    const schema = anthropicOutputFormat(plannerSchema(actions)).schema;
-    expect(schema.additionalProperties).toBe(false);
-    expect(schema.required).toEqual(['reasoning', 'memory_updates', 'actions']);
-    expect(schema.properties.memory_updates.type).toBe('array');
-    expect(schema.properties.memory_updates.items.required).toEqual(['key', 'text', 'sources', 'operation', 'expected_text']);
-    expect(schema.properties.memory_updates.items.properties.operation.enum).toEqual(['add', 'correct']);
-    expect(schema.properties.memory_updates.items.properties.expected_text.anyOf.map((option) => option.type)).toEqual(['string', 'null']);
-    expect(schema.properties.memory_updates.items.properties.sources.items.type).toBe('integer');
-    expect(schema.properties.actions.minItems).toBe(1);
-    expect(schema.properties.actions.items.anyOf.map((item) => item.properties.variant.const)).toEqual(['move', 'report']);
-    expect(schema.properties.actions.items.anyOf[0].properties.to.properties.x.type).toBe('integer');
-    expect(schema.properties.actions.items.anyOf[1].properties.input.type).toBe('string');
-    expect(() => plannerSchema([])).toThrow('at least one action');
-    expect(anthropicOutputFormat(plannerSchema([...webActions]))?.schema.properties.actions.items.anyOf).toHaveLength(webActions.length);
-});
-test('unsupported value constraints stay in descriptions and the original validator', () => {
-    const original = z.object({
-        size: z.number().int().min(2).max(5),
-        text: z.string().min(2).max(4).regex(/^A/),
-        rows: z.array(z.string()).min(3).max(7),
-    });
-    const format = anthropicOutputFormat(original);
-    expect(format.schema.properties.size.minimum).toBeUndefined();
-    expect(format.schema.properties.size.description).toContain('minimum: 2');
-    expect(format.schema.properties.text.pattern).toBeUndefined();
-    expect(format.schema.properties.rows.minItems).toBeUndefined();
-    expect(format.schema.properties.rows.description).toContain('minItems: 3');
-    expect(original.safeParse({ size: 1, text: 'bad', rows: [] }).success).toBe(false);
-});
-test('reused nonrecursive definitions resolve without treating property names as keywords', () => {
-    const coordinate = z.object({ x: z.number() });
-    const format = anthropicOutputFormat(z.object({ minimum: coordinate, properties: coordinate, 'a/b~c': coordinate }));
-    expect(format.schema.properties.minimum).toEqual(format.schema.properties.properties);
-    expect(format.schema.properties['a/b~c']).toEqual(format.schema.properties.minimum);
-});
-test('unsupported data shapes retain prompt-only compatibility instead of changing their shape', () => {
-    const recursive = z.lazy(() => z.object({ next: recursive.optional() }));
-    for (const schema of [z.record(z.string()), z.object({}).passthrough(), z.any(), recursive, z.tuple([z.string(), z.number()])]) {
-        expect(anthropicOutputFormat(schema)).toBeUndefined();
-    }
-    expect(anthropicOutputFormat(z.object(Object.fromEntries(Array.from({ length: 25 }, (_, i) => [`field${i}`, z.string().optional()]))))).toBeUndefined();
-});
-test('generated schemas stay stable across varied field names and action vocabularies', () => {
-    // Synthetic protocol cases, independent of website task content or answers.
-    let seed = 0x9147;
-    const next = () => { seed = (Math.imul(seed, 1664525) + 1013904223) >>> 0; return seed.toString(36); };
-    for (let i = 0; i < 64; i++) {
-        const name = `op:${next()}`;
-        const field = `field_${next()}_\"\\é`;
-        const schema = plannerSchema([createAction({ name, schema: z.object({ [field]: z.string(), enabled: z.boolean().optional() }), resolver: async () => { } })]);
-        const first = anthropicOutputFormat(schema);
-        expect(first).toEqual(anthropicOutputFormat(schema));
-        expect(first.schema.properties.actions.items.properties[field].type).toBe('string');
-        expect(first.schema.properties.actions.items.properties.variant.const).toBe(name);
-        expect(first.schema.properties.actions.items.required).not.toContain('enabled');
-    }
-});

package/dist/ai/types.d.ts

@@ -1,119 +0,0 @@
-export type BrowserAgentRole = 'act' | 'extract' | 'query';
-export declare const allBrowserAgentRoles: BrowserAgentRole[];
-export type LLMClient = (AnthropicClient | ClaudeCodeClient | BedrockClient | GoogleAIClient | GoogleVertexClient | OpenAIClient | BasetenClient | OpenAIGenericClient | AzureOpenAIClient) & {
-    roles?: BrowserAgentRole[];
-};
-export interface AnthropicClient {
-    provider: 'anthropic';
-    options: {
-        model: string;
-        apiKey?: string;
-        temperature?: number;
-        promptCaching?: boolean;
-        /** Maximum output tokens, including thinking. Omitted uses the transport default. */
-        maxTokens?: number;
-        /** Default: enabled for known supporting models. False retains prompt-only JSON. */
-        structuredOutputs?: boolean;
-    };
-}
-export interface ClaudeCodeClient {
-    provider: 'claude-code';
-    options: {
-        model: string;
-        temperature?: number;
-        promptCaching?: boolean;
-        /** Maximum output tokens, including thinking. Omitted uses the transport default. */
-        maxTokens?: number;
-    };
-}
-export interface BedrockClient {
-    provider: 'aws-bedrock';
-    options: {
-        model: string;
-        temperature?: number;
-    };
-}
-export interface GoogleAIClient {
-    provider: 'google-ai';
-    options: {
-        model: string;
-        apiKey?: string;
-        temperature?: number;
-        baseUrl?: string;
-    };
-}
-export interface GoogleVertexClient {
-    provider: 'vertex-ai';
-    options: {
-        model: string;
-        location?: string;
-        baseUrl?: string;
-        projectId?: string;
-        credentials?: string | object;
-        anthropicVersion?: string;
-        temperature?: number;
-    };
-}
-export interface OpenAIClient {
-    provider: 'openai';
-    options: {
-        model: string;
-        apiKey?: string;
-        baseUrl?: string;
-        /** Omitted by default: reasoning models may reject sampling parameters. */
-        temperature?: number;
-        reasoningEffort?: 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
-        /** Includes both visible output and reasoning tokens. */
-        maxCompletionTokens?: number;
-    };
-}
-export interface BasetenClient {
-    provider: 'baseten';
-    options: {
-        model: string;
-        /** Defaults to BASETEN_API_KEY; never falls back to OPENAI_API_KEY. */
-        apiKey?: string;
-        /** Defaults to https://inference.baseten.co/v1. */
-        baseUrl?: string;
-        /** Omitted by default to preserve model-specific sampling defaults. */
-        temperature?: number;
-        /** Model-dependent. DeepSeek V4.1 Flash accepts none, low, high, or max. */
-        reasoningEffort?: OpenAIClient['options']['reasoningEffort'];
-        /** Baseten max_tokens: includes both visible output and reasoning tokens. */
-        maxTokens?: number;
-        /** Default: enabled on the hosted Model API; custom base URLs require opt-in. */
-        structuredOutputs?: boolean;
-    };
-}
-export interface AzureOpenAIClient {
-    provider: 'azure-openai';
-    options: {
-        resourceName: string;
-        deploymentId: string;
-        apiVersion: string;
-        apiKey: string;
-    };
-}
-export interface OpenAIGenericClient {
-    provider: 'openai-generic';
-    options: {
-        model: string;
-        baseUrl: string;
-        apiKey?: string;
-        temperature?: number;
-        headers?: Record<string, string>;
-    };
-}
-export interface LLMClientIdentifier {
-    provider: string;
-    model: string;
-}
-export interface ModelUsage {
-    llm: LLMClientIdentifier;
-    inputTokens: number;
-    outputTokens: number;
-    cacheWriteInputTokens?: number;
-    cacheReadInputTokens?: number;
-    inputCost?: number;
-    outputCost?: number;
-}

package/dist/ai/types.js

@@ -1,5 +0,0 @@
-// export interface CheckResult {
-//     passed: boolean,
-//     confidence: number
-// }
-export const allBrowserAgentRoles = ['act', 'extract', 'query'];