Node.js Capabilities

import { Lexmount } from "lexmount";

const client = new Lexmount({
  region: "<region-id>",
  timeout: 60_000,
});

console.log(await client.regionInfo());
console.log(await client.catalogInfo());

const session = await client.sessions.create({
  browserMode: "normal",
  windowSize: "1920,1080",
  downloads: { enabled: true },
  recording: { persistent: true },
});

const session = await client.sessions.create({
  browserMode: "normal",
  enableCaptcha: true,
});
try {
  console.log(session.id);
} finally {
  await session.close();
}

const current = await client.sessions.get(session.id);
const sessions = await client.sessions.list({ status: "active" });

console.log(sessions.pagination.totalCount);
for (const item of sessions) {
  console.log(item.id, item.status, item.regionId, item.browserType);
}

for (const target of await client.sessions.listTargets(session.id)) {
  console.log(target.title, target.url, target.inspectUrl);
}

await session.close();
// Equivalent when only the ID is available:
await client.sessions.delete({ sessionId: session.id });

const result = await client.sessions.downloads.list(session.id);
console.log(result.summary.count, result.summary.totalSize);

const file = await client.sessions.downloads.get(session.id, "<download-id>");
const archive = await client.sessions.downloads.archive(session.id);
const deleted = await client.sessions.downloads.delete(session.id);
console.log(file.length, archive.length, deleted.deletedCount);

const context = await client.contexts.create({
  description: "Authenticated storefront",
  metadata: { owner: "agent-a" },
});

const session = await client.sessions.create({
  context: { id: context.id, mode: "readWrite" },
});

const contexts = await client.contexts.list({ status: "available", limit: 20 });
const details = await client.contexts.get(context.id);
const forked = await client.contexts.fork(context.id);

await client.contexts.forceRelease(context.id);
await client.contexts.delete(forked.id);

const extension = await client.extensions.upload(
  "/absolute/path/to/extension.zip",
  {
    name: "demo-extension",
  },
);

const extensions = await client.extensions.list({ limit: 20, offset: 0 });
const details = await client.extensions.get(extension.id);

const session = await client.sessions.create({ extensionIds: [extension.id] });
await session.close();
await client.extensions.delete(extension.id);

import { connectOverCDP, Lexmount } from "lexmount";

const client = new Lexmount();
const session = await client.sessions.create();
const cdp = await connectOverCDP(session);

console.log(await cdp.send("Browser.getVersion"));

await cdp.close();
await session.close();
client.close();

import {
  APIError,
  AuthenticationError,
  ContextLockedError,
  NetworkError,
  TimeoutError,
  setLogLevel,
} from "lexmount";

setLogLevel("INFO");

try {
  await client.sessions.create();
} catch (error) {
  if (error instanceof AuthenticationError) {
    console.error("Check API Key and Project ID");
  } else if (error instanceof ContextLockedError) {
    console.error(error.activeSessionId, error.retryAfter);
  } else if (error instanceof NetworkError || error instanceof TimeoutError) {
    console.error("Check whether a session was reserved before retrying");
  } else if (error instanceof APIError) {
    console.error(error.statusCode);
  } else {
    throw error;
  }
}

npm install lexmount@0.7.0
export LEXMOUNT_API_KEY='<your-api-key>'
export LEXMOUNT_PROJECT_ID='<your-project-id>'
# Optional: SDK 0.7.0 defaults to this global COM origin.
export LEXMOUNT_BASE_URL=https://api.lexmount.com

export RUN_IDEMPOTENCY_KEY='<persistent-unique-key-for-this-task>'

import { APIError, Lexmount, RunWaitTimeout } from 'lexmount';

const key = process.env.RUN_IDEMPOTENCY_KEY;
if (!key) throw new Error('Set a persistent RUN_IDEMPOTENCY_KEY first');
const client = new Lexmount();
try {
  const receipt = await client.browserAgent.runs.create(
    {
      query: 'Read the page title and summarize the page.',
      start_url: 'https://example.com/',
    },
    { idempotencyKey: key }
  );
  console.log('Accepted:', receipt.id); // Save this Run ID before waiting.
  const run = await client.browserAgent.runs.wait(receipt.id, {
    timeoutMs: 300_000,
  });
  console.log(run.id, run.status, run.output);
  if (run.status !== 'succeeded') {
    console.error(run.stop_reason, run.error);
    process.exitCode = 1;
  }
} catch (error) {
  if (error instanceof RunWaitTimeout) {
    console.error('Resume with runs.get/wait:', error.run_id);
  } else if (error instanceof APIError) {
    console.error(error.status_code, error.code, error.request_id);
  } else {
    throw error;
  }
  process.exitCode = 1;
} finally {
  client.close();
}

import { Lexmount } from 'lexmount';

const agentKey = process.env.AGENT_IDEMPOTENCY_KEY;
const runKey = process.env.SAVED_RUN_IDEMPOTENCY_KEY;
if (!agentKey || !runKey)
  throw new Error('Set both persistent idempotency keys');
const client = new Lexmount();
try {
  const agent = await client.browserAgent.agents.create(
    {
      name: 'Page summary',
      instruction: 'Summarize the page in {{language}}.',
      start_url: 'https://example.com/',
      output_schema: {
        type: 'object',
        properties: { summary: { type: 'string' } },
        required: ['summary'],
        additionalProperties: false,
      },
    },
    { idempotencyKey: agentKey }
  );
  const receipt = await client.browserAgent.runs.create(
    {
      agent_id: agent.id,
      variables: { language: 'English' },
      metadata: { source: 'docs' },
    },
    { idempotencyKey: runKey }
  );
  console.log('Agent:', agent.id, 'Run:', receipt.id);
  // Recover this Run later with runs.get(receipt.id) or runs.wait(receipt.id).
} finally {
  client.close();
}