@modelprofile.com/browser-runtime 1.0.0

package/ts/classes.flexprovider.ts

@@ -0,0 +1,134 @@
+import * as plugins from './plugins.js';
+import type {
+  IBrowserRuntimeFlexToolProviderOptions,
+} from './interfaces.js';
+import { BrowserRuntimeError } from './errors.js';
+import { validateBoundedString, validateExactKeys } from './utils.js';
+
+const allowedActions = [
+  'navigate',
+  'snapshot',
+  'screenshot',
+  'click',
+  'fill',
+  'press',
+] as const satisfies readonly plugins.smartagent.TBrowserToolAction[];
+
+export class BrowserRuntimeFlexToolProvider<TScope>
+implements plugins.flexharness.IFlexToolProvider<TScope> {
+  private readonly client: IBrowserRuntimeFlexToolProviderOptions<TScope>['client'];
+  private readonly resolveCapability: IBrowserRuntimeFlexToolProviderOptions<TScope>['resolveCapability'];
+  private state: 'unused' | 'provisioning' | 'active' | 'closed' = 'unused';
+
+  constructor(options: IBrowserRuntimeFlexToolProviderOptions<TScope>) {
+    if (!options || typeof options !== 'object') throw new BrowserRuntimeError('INVALID_INPUT');
+    if (!options.client || typeof options.resolveCapability !== 'function') {
+      throw new BrowserRuntimeError('INVALID_INPUT');
+    }
+    this.client = options.client;
+    this.resolveCapability = options.resolveCapability;
+  }
+
+  public async provideTools(
+    context: plugins.flexharness.IFlexToolProviderContext<TScope>,
+  ): Promise<plugins.flexharness.IFlexToolHandle> {
+    if (this.state !== 'unused') throw new BrowserRuntimeError('BUSY');
+    this.state = 'provisioning';
+    const scopeId = validateBoundedString(context.scopeId, 'scopeId', 1, 128);
+    const sessionId = validateBoundedString(context.sessionId, 'sessionId', 1, 128);
+    if (this.client.scopeId !== scopeId || this.client.sessionId !== sessionId) {
+      this.state = 'closed';
+      throw new BrowserRuntimeError('CAPABILITY_INVALID');
+    }
+    try {
+      context.signal.throwIfAborted();
+      const resolved = validateExactKeys(
+        await this.resolveCapability(context),
+        ['capabilityToken'],
+        'resolved capability',
+      );
+      const capabilityToken = validateBoundedString(
+        resolved.capabilityToken,
+        'capabilityToken',
+        16,
+        512,
+      );
+      context.signal.throwIfAborted();
+      await this.client.acquire(capabilityToken, context.signal);
+      context.signal.throwIfAborted();
+    } catch (error) {
+      await this.client.release().catch(() => undefined);
+      await this.client.close().catch(() => undefined);
+      this.state = 'closed';
+      throw error;
+    }
+    this.state = 'active';
+
+    const tools = plugins.smartagent.createBrowserTools({
+      abortSignal: context.signal,
+      browser: this.client.asToolBrowserContext(),
+      requestPermission: async (request) => {
+        const metadata = request.metadata ?? {};
+        const actionValue = metadata.action;
+        if (typeof actionValue !== 'string' || !allowedActions.includes(
+          actionValue as (typeof allowedActions)[number],
+        )) {
+          throw new BrowserRuntimeError('INVALID_INPUT');
+        }
+        const action = actionValue as (typeof allowedActions)[number];
+        const toolCallId = request.toolCallId === undefined
+          ? undefined
+          : validateBoundedString(request.toolCallId, 'toolCallId', 1, 128);
+        const permission = context.requestPermission({
+          kind: `browser.${action}`,
+          description: `Allow the browser to perform the ${action} action.`,
+          ...(toolCallId ? { toolCallId } : {}),
+          metadata: { action },
+        });
+        const signal = AbortSignal.any([
+          context.signal,
+          request.abortSignal ?? new AbortController().signal,
+        ]);
+        signal.throwIfAborted();
+        let onAbort!: () => void;
+        const aborted = new Promise<never>((_resolve, reject) => {
+          onAbort = () => reject(new BrowserRuntimeError('ABORTED'));
+          signal.addEventListener('abort', onAbort, { once: true });
+        });
+        try {
+          await Promise.race([permission, aborted]);
+          signal.throwIfAborted();
+        } finally {
+          signal.removeEventListener('abort', onAbort);
+        }
+      },
+    }, {
+      allowedActions,
+      maxLines: 2000,
+      maxBytes: 128 * 1024,
+    });
+
+    let closePromise: Promise<void> | undefined;
+    const close = (): Promise<void> => {
+      if (closePromise) return closePromise;
+      closePromise = (async () => {
+        context.signal.removeEventListener('abort', onRunAbort);
+        let releaseError: unknown;
+        await this.client.release().catch((error) => { releaseError = error; });
+        await this.client.close();
+        this.state = 'closed';
+        if (releaseError) throw releaseError;
+      })();
+      return closePromise;
+    };
+    const onRunAbort = (): void => {
+      void close().catch(() => undefined);
+    };
+    context.signal.addEventListener('abort', onRunAbort, { once: true });
+    return {
+      tools,
+      close,
+    };
+  }
+
+}