donobu 5.56.0 → 5.57.0

package/dist/clients/OpenAiGptClient.js

@@ -29,6 +29,189 @@ class OpenAiGptClient extends GptClient_1.GptClient {
             'Content-Type': 'application/json',
         });
     }
+    /**
+     * Transform a general JSON Schema into one that fits the OpenAI Structured Outputs subset.
+     * Key behaviors:
+     *  - Enforce additionalProperties:false on objects and require all defined properties.
+     *  - Remove unsupported validation keywords.
+     *  - Convert tuple `items: [A,B]` into `items: { anyOf: [A,B] }`.
+     *  - Preserve $ref and $defs, cleaning nested definitions recursively.
+     *  - If the root is `anyOf`, wrap it into an object schema with a single `value` property.
+     *
+     * Notes for optional fields:
+     *  - Since all fields must be required, emulate optionals with union types that include "null".
+     *    e.g., `type: ["string", "null"]` while keeping the field in `required`.
+     */
+    static createOpenAiCompatibleJsonSchema(schema) {
+        // Defensive deep clone to avoid mutating the caller's object.
+        const clone = (obj) => obj === null || typeof obj !== 'object'
+            ? obj
+            : Array.isArray(obj)
+                ? obj.map(clone)
+                : Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, clone(v)]));
+        // Set of keywords we will strip because they are not supported or risky per docs.
+        // (Docs list these as unsupported in Structured Outputs.)
+        const STRIP_KEYS = new Set([
+            // string
+            'minLength',
+            'maxLength',
+            'pattern',
+            'format',
+            'contentMediaType',
+            'contentEncoding',
+            'contentSchema',
+            // number
+            'minimum',
+            'maximum',
+            'exclusiveMinimum',
+            'exclusiveMaximum',
+            'multipleOf',
+            // object
+            'patternProperties',
+            'unevaluatedProperties',
+            'propertyNames',
+            'minProperties',
+            'maxProperties',
+            'dependentRequired',
+            'dependentSchemas',
+            // arrays
+            'unevaluatedItems',
+            'contains',
+            'minContains',
+            'maxContains',
+            'minItems',
+            'maxItems',
+            'uniqueItems',
+            'additionalItems',
+            'prefixItems',
+            // schema/meta rarely needed for model guidance
+            '$dynamicRef',
+            '$dynamicAnchor',
+            '$vocabulary',
+            'allOf', // conservative: remove; can be rewritten as anyOf in many cases
+            'oneOf', // conservative: remove; prefer anyOf
+            'not', // conservative: remove
+            'if',
+            'then',
+            'else',
+        ]);
+        // Normalize `items`:
+        // - if array (tuple validation), convert to anyOf branch for a simpler, supported pattern.
+        const normalizeItems = (items) => {
+            if (Array.isArray(items)) {
+                return {
+                    anyOf: items.map((s) => cleanSchema(s)),
+                };
+            }
+            return cleanSchema(items);
+        };
+        // Ensure object properties are all required and additionalProperties:false
+        const normalizeObject = (s) => {
+            const out = s;
+            if (!out.properties) {
+                out.properties = {};
+            }
+            // Enforce additionalProperties:false per docs
+            out.additionalProperties = false;
+            // Compute required = all keys in properties (OpenAI requires all params/fields required)
+            const propKeys = Object.keys(out.properties);
+            out.required = Array.from(new Set([...(out.required ?? []), ...propKeys]));
+            // Recurse into each property
+            for (const [key, subschema] of Object.entries(out.properties)) {
+                if (typeof subschema === 'boolean') {
+                    // Convert boolean schemas to permissive object (true) or impossible (false).
+                    // We'll treat `true` as `{}` and `false` as `{ "enum": [] }` which is unmatchable.
+                    out.properties[key] = subschema ? {} : { enum: [] };
+                }
+                else {
+                    out.properties[key] = cleanSchema(subschema);
+                }
+            }
+            return out;
+        };
+        // Core cleaner: strip unsupported keys, normalize arrays/objects/anyOf/$defs.
+        const cleanSchema = (input) => {
+            if (input === undefined) {
+                return {};
+            }
+            if (typeof input === 'boolean') {
+                return input ? {} : { enum: [] }; // keep shape valid; `enum: []` is unsatisfiable.
+            }
+            let s = clone(input);
+            // Remove unsupported keys at this level
+            for (const k of Object.keys(s)) {
+                if (STRIP_KEYS.has(k)) {
+                    delete s[k];
+                }
+            }
+            // Clean $defs recursively
+            if (s.$defs) {
+                for (const [defKey, defSchema] of Object.entries(s.$defs)) {
+                    s.$defs[defKey] = cleanSchema(defSchema);
+                }
+            }
+            // Handle anyOf branches
+            if (s.anyOf) {
+                s.anyOf = s.anyOf.map((branch) => cleanSchema(branch));
+            }
+            // Keep enum/const/description/title/$ref as-is.
+            // Normalize arrays
+            if (s.type === 'array') {
+                if (s.items !== undefined) {
+                    s.items = normalizeItems(s.items);
+                }
+                else {
+                    // Provide a permissive default for items to avoid undefined behavior.
+                    s.items = {};
+                }
+            }
+            // Normalize objects
+            if (s.type === 'object') {
+                s = normalizeObject(s);
+            }
+            // If `type` is a union array, keep it (this is how optionals are expressed: includes "null")
+            // Nothing to do here; we just don't strip it.
+            // If `properties` exists but `type` is missing, make it an object to be explicit
+            if (!s.type && s.properties) {
+                s.type = 'object';
+                s = normalizeObject(s);
+            }
+            // If we still have tuple constructs in "items" (e.g., array of schemas after clean), ensure we normalized
+            if (Array.isArray(s.items)) {
+                s.items = normalizeItems(s.items);
+            }
+            return s;
+        };
+        // Start by cleaning the provided schema
+        let cleaned = cleanSchema(schema);
+        // Root cannot be `anyOf`: wrap if necessary
+        if (cleaned &&
+            !cleaned.type &&
+            cleaned.anyOf &&
+            Object.keys(cleaned).every((k) => k === 'anyOf' ||
+                k === '$defs' ||
+                k === 'description' ||
+                k === 'title')) {
+            cleaned = {
+                type: 'object',
+                properties: {
+                    value: { anyOf: cleaned.anyOf.map((b) => cleanSchema(b)) },
+                },
+                required: ['value'],
+                additionalProperties: false,
+                ...(cleaned.$defs ? { $defs: cleaned.$defs } : {}),
+                ...(cleaned.title ? { title: cleaned.title } : {}),
+                ...(cleaned.description ? { description: cleaned.description } : {}),
+            };
+        }
+        // Final safety: if an object lacks properties, make properties:{} and still enforce additionalProperties:false
+        if (cleaned.type === 'object' && !cleaned.properties) {
+            cleaned.properties = {};
+            cleaned.required = [];
+            cleaned.additionalProperties = false;
+        }
+        return cleaned;
+    }
     async ping(options) {
         const resp = await this.makeRequest(`/v1/models/${this.openAiConfig.modelName}`, 'GET', undefined, options?.signal);
         if (resp.status === 404) {
@@ -284,189 +467,6 @@ class OpenAiGptClient extends GptClient_1.GptClient {
             }
         }
     }
-    /**
-     * Transform a general JSON Schema into one that fits the OpenAI Structured Outputs subset.
-     * Key behaviors:
-     *  - Enforce additionalProperties:false on objects and require all defined properties.
-     *  - Remove unsupported validation keywords.
-     *  - Convert tuple `items: [A,B]` into `items: { anyOf: [A,B] }`.
-     *  - Preserve $ref and $defs, cleaning nested definitions recursively.
-     *  - If the root is `anyOf`, wrap it into an object schema with a single `value` property.
-     *
-     * Notes for optional fields:
-     *  - Since all fields must be required, emulate optionals with union types that include "null".
-     *    e.g., `type: ["string", "null"]` while keeping the field in `required`.
-     */
-    static createOpenAiCompatibleJsonSchema(schema) {
-        // Defensive deep clone to avoid mutating the caller's object.
-        const clone = (obj) => obj === null || typeof obj !== 'object'
-            ? obj
-            : Array.isArray(obj)
-                ? obj.map(clone)
-                : Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, clone(v)]));
-        // Set of keywords we will strip because they are not supported or risky per docs.
-        // (Docs list these as unsupported in Structured Outputs.)
-        const STRIP_KEYS = new Set([
-            // string
-            'minLength',
-            'maxLength',
-            'pattern',
-            'format',
-            'contentMediaType',
-            'contentEncoding',
-            'contentSchema',
-            // number
-            'minimum',
-            'maximum',
-            'exclusiveMinimum',
-            'exclusiveMaximum',
-            'multipleOf',
-            // object
-            'patternProperties',
-            'unevaluatedProperties',
-            'propertyNames',
-            'minProperties',
-            'maxProperties',
-            'dependentRequired',
-            'dependentSchemas',
-            // arrays
-            'unevaluatedItems',
-            'contains',
-            'minContains',
-            'maxContains',
-            'minItems',
-            'maxItems',
-            'uniqueItems',
-            'additionalItems',
-            'prefixItems',
-            // schema/meta rarely needed for model guidance
-            '$dynamicRef',
-            '$dynamicAnchor',
-            '$vocabulary',
-            'allOf', // conservative: remove; can be rewritten as anyOf in many cases
-            'oneOf', // conservative: remove; prefer anyOf
-            'not', // conservative: remove
-            'if',
-            'then',
-            'else',
-        ]);
-        // Normalize `items`:
-        // - if array (tuple validation), convert to anyOf branch for a simpler, supported pattern.
-        const normalizeItems = (items) => {
-            if (Array.isArray(items)) {
-                return {
-                    anyOf: items.map((s) => cleanSchema(s)),
-                };
-            }
-            return cleanSchema(items);
-        };
-        // Ensure object properties are all required and additionalProperties:false
-        const normalizeObject = (s) => {
-            const out = s;
-            if (!out.properties) {
-                out.properties = {};
-            }
-            // Enforce additionalProperties:false per docs
-            out.additionalProperties = false;
-            // Compute required = all keys in properties (OpenAI requires all params/fields required)
-            const propKeys = Object.keys(out.properties);
-            out.required = Array.from(new Set([...(out.required ?? []), ...propKeys]));
-            // Recurse into each property
-            for (const [key, subschema] of Object.entries(out.properties)) {
-                if (typeof subschema === 'boolean') {
-                    // Convert boolean schemas to permissive object (true) or impossible (false).
-                    // We'll treat `true` as `{}` and `false` as `{ "enum": [] }` which is unmatchable.
-                    out.properties[key] = subschema ? {} : { enum: [] };
-                }
-                else {
-                    out.properties[key] = cleanSchema(subschema);
-                }
-            }
-            return out;
-        };
-        // Core cleaner: strip unsupported keys, normalize arrays/objects/anyOf/$defs.
-        const cleanSchema = (input) => {
-            if (input === undefined) {
-                return {};
-            }
-            if (typeof input === 'boolean') {
-                return input ? {} : { enum: [] }; // keep shape valid; `enum: []` is unsatisfiable.
-            }
-            let s = clone(input);
-            // Remove unsupported keys at this level
-            for (const k of Object.keys(s)) {
-                if (STRIP_KEYS.has(k)) {
-                    delete s[k];
-                }
-            }
-            // Clean $defs recursively
-            if (s.$defs) {
-                for (const [defKey, defSchema] of Object.entries(s.$defs)) {
-                    s.$defs[defKey] = cleanSchema(defSchema);
-                }
-            }
-            // Handle anyOf branches
-            if (s.anyOf) {
-                s.anyOf = s.anyOf.map((branch) => cleanSchema(branch));
-            }
-            // Keep enum/const/description/title/$ref as-is.
-            // Normalize arrays
-            if (s.type === 'array') {
-                if (s.items !== undefined) {
-                    s.items = normalizeItems(s.items);
-                }
-                else {
-                    // Provide a permissive default for items to avoid undefined behavior.
-                    s.items = {};
-                }
-            }
-            // Normalize objects
-            if (s.type === 'object') {
-                s = normalizeObject(s);
-            }
-            // If `type` is a union array, keep it (this is how optionals are expressed: includes "null")
-            // Nothing to do here; we just don't strip it.
-            // If `properties` exists but `type` is missing, make it an object to be explicit
-            if (!s.type && s.properties) {
-                s.type = 'object';
-                s = normalizeObject(s);
-            }
-            // If we still have tuple constructs in "items" (e.g., array of schemas after clean), ensure we normalized
-            if (Array.isArray(s.items)) {
-                s.items = normalizeItems(s.items);
-            }
-            return s;
-        };
-        // Start by cleaning the provided schema
-        let cleaned = cleanSchema(schema);
-        // Root cannot be `anyOf`: wrap if necessary
-        if (cleaned &&
-            !cleaned.type &&
-            cleaned.anyOf &&
-            Object.keys(cleaned).every((k) => k === 'anyOf' ||
-                k === '$defs' ||
-                k === 'description' ||
-                k === 'title')) {
-            cleaned = {
-                type: 'object',
-                properties: {
-                    value: { anyOf: cleaned.anyOf.map((b) => cleanSchema(b)) },
-                },
-                required: ['value'],
-                additionalProperties: false,
-                ...(cleaned.$defs ? { $defs: cleaned.$defs } : {}),
-                ...(cleaned.title ? { title: cleaned.title } : {}),
-                ...(cleaned.description ? { description: cleaned.description } : {}),
-            };
-        }
-        // Final safety: if an object lacks properties, make properties:{} and still enforce additionalProperties:false
-        if (cleaned.type === 'object' && !cleaned.properties) {
-            cleaned.properties = {};
-            cleaned.required = [];
-            cleaned.additionalProperties = false;
-        }
-        return cleaned;
-    }
 }
 exports.OpenAiGptClient = OpenAiGptClient;
 OpenAiGptClient.DEFAULT_API_URL = 'https://api.openai.com';

package/dist/esm/apis/GptConfigsApi.d.ts

@@ -34,6 +34,11 @@ export declare class GptConfigsApi {
      */
     private static readonly REDACTED_FIELD_NAMES;
     constructor(gptConfigsManager: GptConfigsManager, agentsManager: AgentsManager);
+    /**
+     * Redacts sensative data from the given GPT configuration so that the record
+     * can be safely returned through the API.
+     */
+    static redactSensativeData(config: GptConfigInput): GptConfigInput;
     /**
      * Creates or updates a GPT configuration.
      *
@@ -82,10 +87,5 @@ export declare class GptConfigsApi {
      * 3. Unlinks the configuration from all dependent agents
      */
     delete(req: Request, res: Response): Promise<void>;
-    /**
-     * Redacts sensative data from the given GPT configuration so that the record
-     * can be safely returned through the API.
-     */
-    static redactSensativeData(config: GptConfigInput): GptConfigInput;
 }
 //# sourceMappingURL=GptConfigsApi.d.ts.map

package/dist/esm/apis/GptConfigsApi.js

@@ -27,6 +27,20 @@ class GptConfigsApi {
         this.gptConfigsManager = gptConfigsManager;
         this.agentsManager = agentsManager;
     }
+    /**
+     * Redacts sensative data from the given GPT configuration so that the record
+     * can be safely returned through the API.
+     */
+    static redactSensativeData(config) {
+        const configCopy = { ...config };
+        for (const redactedFieldName of GptConfigsApi.REDACTED_FIELD_NAMES) {
+            if (redactedFieldName in configCopy) {
+                // Use type assertion to tell TypeScript this is allowed
+                configCopy[redactedFieldName] = '****************';
+            }
+        }
+        return configCopy;
+    }
     /**
      * Creates or updates a GPT configuration.
      *
@@ -112,20 +126,6 @@ class GptConfigsApi {
         }
         res.json({});
     }
-    /**
-     * Redacts sensative data from the given GPT configuration so that the record
-     * can be safely returned through the API.
-     */
-    static redactSensativeData(config) {
-        const configCopy = { ...config };
-        for (const redactedFieldName of GptConfigsApi.REDACTED_FIELD_NAMES) {
-            if (redactedFieldName in configCopy) {
-                // Use type assertion to tell TypeScript this is allowed
-                configCopy[redactedFieldName] = '****************';
-            }
-        }
-        return configCopy;
-    }
 }
 exports.GptConfigsApi = GptConfigsApi;
 /**

package/dist/esm/bindings/PageInteractionTracker.d.ts

@@ -46,8 +46,8 @@ export interface InteractionTrackingHost {
 export declare class PageInteractionTracker implements NamedBindingCallback {
     private readonly host;
     static readonly NAME = "__donobuTrackInteraction";
-    static register(host: InteractionTrackingHost, browserContext: BrowserContext): Promise<PageInteractionTracker>;
     private constructor();
+    static register(host: InteractionTrackingHost, browserContext: BrowserContext): Promise<PageInteractionTracker>;
     name(): string;
     /**
      * Handles tracking of page interactions.

package/dist/esm/bindings/PageInteractionTracker.js

@@ -38,6 +38,9 @@ exports.InteractionEventSchema = v4_1.z.object({
  * This tracker records direct user actions for reliable replay and GPT visibility.
  */
 class PageInteractionTracker {
+    constructor(host) {
+        this.host = host;
+    }
     static async register(host, browserContext) {
         const instance = new PageInteractionTracker(host);
         try {
@@ -62,9 +65,6 @@ class PageInteractionTracker {
         }
         return instance;
     }
-    constructor(host) {
-        this.host = host;
-    }
     name() {
         return PageInteractionTracker.NAME;
     }

package/dist/esm/bindings/SetDonobuAnnotations.d.ts

@@ -9,8 +9,8 @@ import type { NamedBindingCallback } from './NamedBindingCallback';
 export declare class SetDonobuAnnotations implements NamedBindingCallback {
     private readonly pageInspector;
     static readonly NAME = "__donobuSetAnnotations";
-    static register(pageInspector: PageInspector, browserContext: BrowserContext): Promise<SetDonobuAnnotations>;
     constructor(pageInspector: PageInspector);
+    static register(pageInspector: PageInspector, browserContext: BrowserContext): Promise<SetDonobuAnnotations>;
     name(): string;
     call(source: {
         context: BrowserContext;

package/dist/esm/bindings/SetDonobuAnnotations.js

@@ -9,6 +9,9 @@ const JsonUtils_1 = require("../utils/JsonUtils");
  * as understood by the Donobu engine.
  */
 class SetDonobuAnnotations {
+    constructor(pageInspector) {
+        this.pageInspector = pageInspector;
+    }
     static async register(pageInspector, browserContext) {
         const instance = new SetDonobuAnnotations(pageInspector);
         try {
@@ -19,9 +22,6 @@ class SetDonobuAnnotations {
         }
         return instance;
     }
-    constructor(pageInspector) {
-        this.pageInspector = pageInspector;
-    }
     name() {
         return SetDonobuAnnotations.NAME;
     }

package/dist/esm/clients/AnthropicGptClient.d.ts

@@ -18,6 +18,8 @@ export declare class AnthropicGptClient extends GptClient {
     private static readonly MAX_TOKENS;
     private readonly headers;
     constructor(anthropicConfig: AnthropicConfig);
+    private static chatRequestMessageFromGptMessage;
+    private static toolChoiceFromTool;
     ping(options?: {
         signal?: AbortSignal;
     }): Promise<void>;
@@ -32,7 +34,5 @@ export declare class AnthropicGptClient extends GptClient {
     }): Promise<ProposedToolCallsMessage>;
     private mapErrorResponseToDonobuException;
     private makeRequest;
-    private static chatRequestMessageFromGptMessage;
-    private static toolChoiceFromTool;
 }
 //# sourceMappingURL=AnthropicGptClient.d.ts.map