@ddwang/magnitude-core 0.3.1-ddwang.1

package/dist/actions/desktopActions.d.ts

@@ -0,0 +1,58 @@
+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

@@ -0,0 +1,154 @@
+import { createAction } from ".";
+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 new Promise((resolve) => setTimeout(resolve, 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

@@ -0,0 +1,26 @@
+import { Agent } from "@/agent";
+import { RenderableContent } from "@/memory/observation";
+import { z, Schema, ZodTypeAny } from "zod";
+export interface ActionDefinition<T> {
+    name: string;
+    description?: string;
+    schema: Schema<T>;
+    resolver: ({ input, agent }: {
+        input: T;
+        agent: Agent;
+    }) => Promise<void | RenderableContent>;
+    render: (action: T) => string;
+}
+export declare function createAction<S extends ZodTypeAny>(action: {
+    name: string;
+    description?: string;
+    schema?: S;
+    resolver: ({ input, agent }: {
+        input: z.infer<S>;
+        agent: Agent;
+    }) => 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

@@ -0,0 +1,11 @@
+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/taskActions.d.ts

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,31 @@
+/**
+ * "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 | TypeIntent | ScrollIntent | SwitchTabIntent;
+export type Intent = ActionIntent | CheckIntent;
+export interface ClickIntent {
+    variant: 'click';
+    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

@@ -0,0 +1,5 @@
+/**
+ * "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

@@ -0,0 +1,20 @@
+import { ActionDefinition } from ".";
+import TypeBuilder from "@/ai/baml_client/type_builder";
+import { FieldType } from "@boundaryml/baml/native";
+import { Schema } 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;

package/dist/actions/util.js

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