@the-open-engine/zeroshot 6.27.0 → 6.29.0

package/src/target/device-flow.ts

@@ -0,0 +1,168 @@
+export interface DeviceCodeResponse {
+  readonly device_code: string;
+  readonly user_code: string;
+  readonly verification_uri: string;
+  readonly verification_uri_complete?: string;
+  readonly expires_in: number;
+  readonly interval: number;
+}
+
+export interface TokenResponse {
+  readonly access_token: string;
+  readonly refresh_token: string;
+  readonly token_type: string;
+  readonly expires_in: number;
+  readonly organization?: { readonly id: string; readonly name: string };
+}
+
+export interface HttpTransport {
+  fetch(url: string, init: RequestInit & { redirect: 'error' }): Promise<Response>;
+}
+
+export interface Clock {
+  now(): number;
+}
+
+export interface DeviceIdentity {
+  readonly token: string;
+  readonly label: string;
+}
+
+export class DeviceFlowDeniedError extends Error {
+  constructor() {
+    super('Device authorization denied by user');
+    this.name = 'DeviceFlowDeniedError';
+  }
+}
+
+export class DeviceFlowExpiredError extends Error {
+  constructor() {
+    super('Device authorization code expired');
+    this.name = 'DeviceFlowExpiredError';
+  }
+}
+
+export class UnboundSessionError extends Error {
+  readonly verificationUri: string;
+  constructor(verificationUri: string) {
+    super(
+      `Session not bound to an organization. Re-approve at ${verificationUri} and select an organization.`
+    );
+    this.name = 'UnboundSessionError';
+    this.verificationUri = verificationUri;
+  }
+}
+
+const DEFAULT_CLOCK: Clock = { now: () => Date.now() };
+
+function sleep(ms: number, signal?: AbortSignal): Promise<void> {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(signal.reason ?? new DOMException('Aborted', 'AbortError'));
+      return;
+    }
+    const timer = setTimeout(resolve, ms);
+    signal?.addEventListener(
+      'abort',
+      () => {
+        clearTimeout(timer);
+        reject(signal.reason ?? new DOMException('Aborted', 'AbortError'));
+      },
+      { once: true }
+    );
+  });
+}
+
+export async function requestDeviceCode(
+  deviceAuthorizationEndpoint: string,
+  clientId: string,
+  http: HttpTransport,
+  signal?: AbortSignal
+): Promise<DeviceCodeResponse> {
+  const body = new URLSearchParams({
+    client_id: clientId,
+    scope: 'openid',
+  });
+
+  const init: RequestInit & { redirect: 'error' } = {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+    body: body.toString(),
+    redirect: 'error',
+  };
+  if (signal) init.signal = signal;
+
+  const response = await http.fetch(deviceAuthorizationEndpoint, init);
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Device code request failed (${response.status}): ${text}`);
+  }
+
+  return (await response.json()) as DeviceCodeResponse;
+}
+
+export async function pollForToken(
+  tokenEndpoint: string,
+  clientId: string,
+  deviceCode: string,
+  interval: number,
+  expiresIn: number,
+  http: HttpTransport,
+  clock: Clock = DEFAULT_CLOCK,
+  signal?: AbortSignal,
+  deviceIdentity?: DeviceIdentity
+): Promise<TokenResponse> {
+  const deadline = clock.now() + expiresIn * 1000;
+  let currentInterval = interval;
+
+  while (clock.now() < deadline) {
+    if (signal?.aborted) {
+      throw signal.reason ?? new DOMException('Aborted', 'AbortError');
+    }
+
+    await sleep(currentInterval * 1000, signal);
+
+    const body = new URLSearchParams({
+      grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+      device_code: deviceCode,
+      client_id: clientId,
+    });
+    if (deviceIdentity) {
+      body.set('audience', 'admin');
+      body.set('device_token', deviceIdentity.token);
+      body.set('device_label', deviceIdentity.label);
+    }
+
+    const init: RequestInit & { redirect: 'error' } = {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+      body: body.toString(),
+      redirect: 'error',
+    };
+    if (signal) init.signal = signal;
+
+    const response = await http.fetch(tokenEndpoint, init);
+
+    if (response.ok) {
+      return (await response.json()) as TokenResponse;
+    }
+
+    const errorBody = (await response.json()) as { error: string };
+    switch (errorBody.error) {
+      case 'authorization_pending':
+        continue;
+      case 'slow_down':
+        currentInterval += 5;
+        continue;
+      case 'access_denied':
+        throw new DeviceFlowDeniedError();
+      case 'expired_token':
+        throw new DeviceFlowExpiredError();
+      default:
+        throw new Error(`Token endpoint error: ${errorBody.error}`);
+    }
+  }
+
+  throw new DeviceFlowExpiredError();
+}

package/src/target/discovery.ts

@@ -0,0 +1,131 @@
+import type { HttpTransport } from './device-flow.ts';
+import { readBoundedJson } from './bounded-json.ts';
+
+const DISCOVERY_PATH = '/.well-known/openengine-hosted-target';
+const MAX_DISCOVERY_BYTES = 64 * 1024;
+
+export interface TargetSessionEndpoints {
+  readonly deviceAuthorizationEndpoint: string;
+  readonly tokenEndpoint: string;
+  readonly revocationEndpoint?: string;
+  readonly clientId: string;
+  readonly capsuleApiBaseUrl: string;
+}
+
+export class TargetDiscoveryError extends Error {
+  constructor(message: string) {
+    super(`Target discovery failed: ${message}`);
+    this.name = 'TargetDiscoveryError';
+  }
+}
+
+function record(value: unknown, field: string): Record<string, unknown> {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+    throw new TargetDiscoveryError(`${field} must be an object`);
+  }
+  return value as Record<string, unknown>;
+}
+
+function stringField(source: Record<string, unknown>, field: string): string {
+  const value = source[field];
+  if (typeof value !== 'string' || value.length === 0) {
+    throw new TargetDiscoveryError(`${field} must be a non-empty string`);
+  }
+  return value;
+}
+
+function safeEndpoint(value: unknown, field: string, serviceOrigin: string): string {
+  if (typeof value !== 'string') {
+    throw new TargetDiscoveryError(`${field} must be an absolute URL`);
+  }
+  let endpoint: URL;
+  try {
+    endpoint = new URL(value);
+  } catch {
+    throw new TargetDiscoveryError(`${field} must be an absolute URL`);
+  }
+  if (endpoint.username || endpoint.password || endpoint.search || endpoint.hash) {
+    throw new TargetDiscoveryError(`${field} contains forbidden URL components`);
+  }
+  if (endpoint.origin !== serviceOrigin) {
+    throw new TargetDiscoveryError(`${field} must remain on the target origin`);
+  }
+  return endpoint.href;
+}
+
+async function fetchDocument(http: HttpTransport, url: string): Promise<Record<string, unknown>> {
+  const response = await http.fetch(url, {
+    method: 'GET',
+    headers: { Accept: 'application/json' },
+    redirect: 'error',
+  });
+  if (!response.ok) {
+    throw new TargetDiscoveryError(`request failed with status ${response.status}`);
+  }
+  const body = await readBoundedJson(response, MAX_DISCOVERY_BYTES, {
+    tooLarge: () => new TargetDiscoveryError('response exceeds the size limit'),
+    invalid: () => new TargetDiscoveryError('response is not valid JSON'),
+  });
+  return record(body, 'response');
+}
+
+export async function discoverTargetSessionEndpoints(
+  targetUrl: string,
+  http: HttpTransport
+): Promise<TargetSessionEndpoints> {
+  const target = new URL(targetUrl);
+  const discovery = await fetchDocument(http, new URL(DISCOVERY_PATH, target).href);
+  if (discovery.kind !== 'openengine.hosted-target/v1') {
+    throw new TargetDiscoveryError('unsupported hosted-target version');
+  }
+  if (discovery.organization_binding !== 'device_approval') {
+    throw new TargetDiscoveryError('unsupported organization binding');
+  }
+
+  const oauth = record(discovery.oauth, 'oauth');
+  const capsuleProtocol = record(discovery.capsule_protocol, 'capsule_protocol');
+  if (capsuleProtocol.name !== 'openengine.capsules/v1' || capsuleProtocol.major_version !== 1) {
+    throw new TargetDiscoveryError('unsupported capsule protocol');
+  }
+  const capsuleApiBaseUrl = safeEndpoint(
+    capsuleProtocol.base_url,
+    'capsule_protocol.base_url',
+    target.origin
+  ).replace(/\/$/, '');
+  const metadataUrl = safeEndpoint(oauth.metadata_url, 'oauth.metadata_url', target.origin);
+  const deviceEndpoint = safeEndpoint(
+    oauth.device_authorization_endpoint,
+    'oauth.device_authorization_endpoint',
+    target.origin
+  );
+  const tokenEndpoint = safeEndpoint(oauth.token_endpoint, 'oauth.token_endpoint', target.origin);
+  const clientId = stringField(oauth, 'client_id');
+
+  const metadata = await fetchDocument(http, metadataUrl);
+  const metadataDeviceEndpoint = safeEndpoint(
+    metadata.device_authorization_endpoint,
+    'device_authorization_endpoint',
+    target.origin
+  );
+  const metadataTokenEndpoint = safeEndpoint(
+    metadata.token_endpoint,
+    'token_endpoint',
+    target.origin
+  );
+  if (metadataDeviceEndpoint !== deviceEndpoint || metadataTokenEndpoint !== tokenEndpoint) {
+    throw new TargetDiscoveryError('OAuth metadata does not match hosted-target discovery');
+  }
+
+  const revocationEndpoint =
+    metadata.revocation_endpoint === undefined
+      ? undefined
+      : safeEndpoint(metadata.revocation_endpoint, 'revocation_endpoint', target.origin);
+
+  return {
+    deviceAuthorizationEndpoint: deviceEndpoint,
+    tokenEndpoint,
+    ...(revocationEndpoint === undefined ? {} : { revocationEndpoint }),
+    clientId,
+    capsuleApiBaseUrl,
+  };
+}

package/src/target/hosted-run/client.ts

@@ -0,0 +1,198 @@
+import { acquireTargetLock } from '../credential-lock.ts';
+import { KeyringCredentialStore } from '../credential-store.ts';
+import { discoverTargetSessionEndpoints } from '../discovery.ts';
+import { getTarget } from '../target-registry.ts';
+import { getAccessTokenProvider, type TargetAccessTokenProvider } from '../target-session.ts';
+import { readBoundedJson } from '../bounded-json.ts';
+
+import type { HostedRunDependencies, HostedRunIntent } from './contracts.ts';
+
+const MAX_RESPONSE_BYTES = 1024 * 1024;
+export const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export const TERMINAL_STATES = new Set(['succeeded', 'failed', 'cancelled', 'expired']);
+const RUN_INTENT_STATES = new Set([
+  'queued',
+  'provisioning',
+  'running',
+  'cancelling',
+  ...TERMINAL_STATES,
+]);
+
+export interface HostedContext {
+  readonly targetName: string;
+  readonly organization: string;
+  readonly client: RunIntentClient;
+}
+
+function wait(milliseconds: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+
+export class HostedRunHttpError extends Error {
+  readonly status: number;
+  readonly code: string | null;
+
+  constructor(status: number, message: string, code: string | null = null) {
+    super(message);
+    this.name = 'HostedRunHttpError';
+    this.status = status;
+    this.code = code;
+  }
+}
+
+function validateIntent(value: unknown): HostedRunIntent {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error('Zero Cloud returned an invalid run intent');
+  }
+  const record = value as Record<string, unknown>;
+  if (
+    typeof record['intent_id'] !== 'string' ||
+    !UUID.test(record['intent_id']) ||
+    typeof record['state'] !== 'string' ||
+    !RUN_INTENT_STATES.has(record['state'])
+  ) {
+    throw new Error('Zero Cloud returned an invalid run intent');
+  }
+  const result = record['result'];
+  if (result !== null && (typeof result !== 'object' || Array.isArray(result))) {
+    throw new Error('Zero Cloud returned an invalid run intent result');
+  }
+  return record as unknown as HostedRunIntent;
+}
+
+export class RunIntentClient {
+  private readonly baseUrl: string;
+  private readonly organization: string;
+  private readonly tokenProvider: TargetAccessTokenProvider;
+  private readonly fetch: typeof globalThis.fetch;
+
+  constructor(
+    baseUrl: string,
+    organization: string,
+    tokenProvider: TargetAccessTokenProvider,
+    fetchImplementation: typeof globalThis.fetch
+  ) {
+    this.baseUrl = baseUrl.replace(/\/$/, '');
+    this.organization = organization;
+    this.tokenProvider = tokenProvider;
+    this.fetch = fetchImplementation;
+  }
+
+  async submit(body: Record<string, unknown>, submissionKey: string): Promise<HostedRunIntent> {
+    let failure: unknown;
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      try {
+        return await this.request('', {
+          method: 'POST',
+          body: JSON.stringify(body),
+          headers: { 'Idempotency-Key': submissionKey },
+        });
+      } catch (error) {
+        failure = error;
+        if (error instanceof HostedRunHttpError && error.status < 500) throw error;
+        if (attempt === 0) await wait(250);
+      }
+    }
+    throw failure;
+  }
+
+  get(intentId: string): Promise<HostedRunIntent> {
+    return this.request(`/${encodeURIComponent(intentId)}`, { method: 'GET' });
+  }
+
+  cancel(intentId: string): Promise<HostedRunIntent> {
+    return this.request(`/${encodeURIComponent(intentId)}`, { method: 'DELETE' });
+  }
+
+  private async request(
+    suffix: string,
+    options: { method: string; body?: string; headers?: Record<string, string> }
+  ): Promise<HostedRunIntent> {
+    const token = await this.tokenProvider.getAccessToken();
+    const url = `${this.baseUrl}/orgs/${encodeURIComponent(this.organization)}/run-intents${suffix}`;
+    const init: RequestInit & { redirect: 'error' } = {
+      method: options.method,
+      redirect: 'error',
+      headers: {
+        Accept: 'application/json',
+        Authorization: `Bearer ${token}`,
+        'Content-Type': 'application/json',
+        ...options.headers,
+      },
+    };
+    if (options.body !== undefined) init.body = options.body;
+    let response: Response;
+    try {
+      response = await this.fetch(url, init);
+    } catch (error) {
+      throw new Error(
+        `Zero Cloud request failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    const body = await readBoundedJson(response, MAX_RESPONSE_BYTES, {
+      tooLarge: () => new Error('Zero Cloud response exceeded 1 MiB'),
+      invalid: () => new Error('Zero Cloud returned invalid JSON'),
+    });
+    if (!response.ok) {
+      const problem = body as Record<string, unknown>;
+      const code = typeof problem['code'] === 'string' ? problem['code'] : null;
+      const message =
+        typeof problem['message'] === 'string' ? problem['message'] : 'request failed';
+      throw new HostedRunHttpError(
+        response.status,
+        `Zero Cloud ${response.status}: ${message}`,
+        code
+      );
+    }
+    return validateIntent(body);
+  }
+}
+
+export async function context(targetName: string, deps: HostedRunDependencies): Promise<HostedContext> {
+  const environment = deps.environment ?? process.env;
+  const target = getTarget(targetName, deps.settings);
+  if (!target) throw new Error(`Target "${targetName}" not found.`);
+  const http = {
+    fetch: (url: string, init: RequestInit & { redirect: 'error' }) =>
+      (deps.fetch ?? globalThis.fetch)(url, init),
+  };
+  const discovery = await discoverTargetSessionEndpoints(target.url, http);
+  const ephemeralToken = environment['ZEROSHOT_TARGET_ACCESS_TOKEN']?.trim();
+  const ephemeralOrganization = environment['ZEROSHOT_TARGET_ORGANIZATION']?.trim();
+  if ((ephemeralToken && !ephemeralOrganization) || (!ephemeralToken && ephemeralOrganization)) {
+    throw new Error(
+      'ZEROSHOT_TARGET_ACCESS_TOKEN and ZEROSHOT_TARGET_ORGANIZATION must be provided together'
+    );
+  }
+
+  let organization: string;
+  let tokenProvider: TargetAccessTokenProvider;
+  if (ephemeralToken && ephemeralOrganization) {
+    organization = ephemeralOrganization;
+    tokenProvider = { getAccessToken: async () => ephemeralToken };
+  } else {
+    if (!target.organization) {
+      throw new Error(`Login required. Run: zeroshot target login ${targetName}`);
+    }
+    organization = target.organization.id;
+    const credentials = await KeyringCredentialStore.create();
+    tokenProvider = getAccessTokenProvider(
+      targetName,
+      target,
+      credentials,
+      () => acquireTargetLock(target.id),
+      { http, discoveryEndpoints: discovery }
+    );
+  }
+
+  return {
+    targetName,
+    organization,
+    client: new RunIntentClient(
+      discovery.capsuleApiBaseUrl,
+      organization,
+      tokenProvider,
+      deps.fetch ?? globalThis.fetch
+    ),
+  };
+}

package/src/target/hosted-run/commands.ts

@@ -0,0 +1,140 @@
+import crypto from 'node:crypto';
+
+import type { HostedOptions, HostedRunDependencies, HostedRunIntent } from './contracts.ts';
+import {
+  context,
+  HostedRunHttpError,
+  TERMINAL_STATES,
+  UUID,
+  type HostedContext,
+} from './client.ts';
+import {
+  githubToken,
+  providerKey,
+  resolveHostedInput,
+  validateHostedOptions,
+} from './input.ts';
+
+const DEFAULT_MODEL = 'openai/gpt-5.4';
+const RUN_INTENT_VERSION = 'zeroshot.run-intent/v1';
+const MAX_RUN_INTENT_BYTES = 1024 * 1024 + 64 * 1024;
+const RUN_INTENT_POLL_MS = 500;
+
+function output(deps: HostedRunDependencies, value: string): void {
+  (deps.stdout ?? process.stdout).write(`${value}\n`);
+}
+
+function wait(milliseconds: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+
+function displayState(intent: HostedRunIntent): string {
+  return intent.waiting_reason ? `${intent.state} (${intent.waiting_reason})` : intent.state;
+}
+
+function resumeCommand(value: HostedContext, intentId: string): string {
+  return `zeroshot target status ${value.targetName} ${intentId} --follow`;
+}
+
+async function follow(
+  value: HostedContext,
+  initial: HostedRunIntent,
+  deps: HostedRunDependencies
+): Promise<Record<string, unknown> | null> {
+  let intent = initial;
+  let displayed: string | null = null;
+  for (;;) {
+    const state = displayState(intent);
+    if (state !== displayed) {
+      output(deps, `Run ${intent.intent_id}: ${state}`);
+      displayed = state;
+    }
+    if (TERMINAL_STATES.has(intent.state)) break;
+    await (deps.delay ?? wait)(RUN_INTENT_POLL_MS);
+    intent = await value.client.get(intent.intent_id);
+  }
+  if (intent.state === 'succeeded') {
+    const summary = intent.result?.['summary'];
+    if (typeof summary === 'string' && summary) output(deps, summary);
+    return intent.result;
+  }
+  const detail = intent.error_code ? ` (${intent.error_code})` : '';
+  throw new Error(`hosted run ${intent.state}${detail}`);
+}
+
+export async function runHosted(
+  input: string,
+  options: HostedOptions,
+  deps: HostedRunDependencies
+): Promise<HostedRunIntent | Record<string, unknown> | null> {
+  validateHostedOptions(options);
+  const environment = deps.environment ?? process.env;
+  const resolved = await resolveHostedInput(input, options, environment);
+  const value = await context(options.target!, deps);
+  const body = {
+    label: 'zeroshot-cli',
+    size: options.size ?? 'standard',
+    intent: {
+      version: RUN_INTENT_VERSION,
+      credentials: {
+        githubToken: githubToken(environment),
+        openrouterApiKey: providerKey(environment),
+        repository: resolved.repository,
+        model: options.model ?? DEFAULT_MODEL,
+      },
+      request: resolved.request,
+    },
+  };
+  if (Buffer.byteLength(JSON.stringify(body)) > MAX_RUN_INTENT_BYTES) {
+    throw new Error('hosted run intent exceeds the 1088 KiB upload limit');
+  }
+  const submissionKey = options.submissionKey ?? crypto.randomUUID();
+  let created: HostedRunIntent;
+  try {
+    created = await value.client.submit(body, submissionKey);
+  } catch (error) {
+    if (error instanceof HostedRunHttpError) throw error;
+    throw new Error(
+      `${error instanceof Error ? error.message : String(error)}. Recover this submission by rerunning ` +
+        `the same command with --submission-key ${submissionKey}`,
+      { cause: error }
+    );
+  }
+  output(deps, `Run ${created.intent_id} queued`);
+  output(deps, `Resume: ${resumeCommand(value, created.intent_id)}`);
+  if (options.detach) return created;
+  output(deps, 'Ctrl+C disconnects without cancelling.');
+  return follow(value, created, deps);
+}
+
+export async function statusHostedRun(
+  targetName: string,
+  intentId: string,
+  shouldFollow: boolean,
+  deps: HostedRunDependencies
+): Promise<HostedRunIntent | Record<string, unknown> | null> {
+  if (!UUID.test(intentId)) throw new Error('run intent id must be a UUID');
+  const value = await context(targetName, deps);
+  const intent = await value.client.get(intentId);
+  if (!shouldFollow) {
+    output(deps, JSON.stringify(intent, null, 2));
+    return intent;
+  }
+  if (!TERMINAL_STATES.has(intent.state)) {
+    output(deps, `Following ${intentId}; Ctrl+C disconnects without cancelling.`);
+    output(deps, `Resume: ${resumeCommand(value, intentId)}`);
+  }
+  return follow(value, intent, deps);
+}
+
+export async function cancelHostedRun(
+  targetName: string,
+  intentId: string,
+  deps: HostedRunDependencies
+): Promise<HostedRunIntent> {
+  if (!UUID.test(intentId)) throw new Error('run intent id must be a UUID');
+  const value = await context(targetName, deps);
+  const intent = await value.client.cancel(intentId);
+  output(deps, `Run ${intent.intent_id}: ${displayState(intent)}`);
+  return intent;
+}

package/src/target/hosted-run/contracts.ts

@@ -0,0 +1,53 @@
+// Shared hosted-run command contracts.
+
+import type { SettingsPort } from '../target-registry.ts';
+
+export interface HostedOptions {
+  readonly target?: string;
+  readonly repository?: string;
+  readonly model?: string;
+  readonly size?: string;
+  readonly submissionKey?: string;
+  readonly detach?: boolean;
+  readonly pr?: boolean;
+  readonly provider?: string;
+  readonly config?: string;
+  readonly docker?: boolean;
+  readonly worktree?: boolean;
+  readonly dockerImage?: string;
+  readonly strictSchema?: boolean;
+  readonly ship?: boolean;
+  readonly prBase?: string;
+  readonly mergeQueue?: boolean;
+  readonly closeIssue?: string;
+  readonly workers?: number;
+  readonly gitlab?: boolean;
+  readonly jira?: boolean;
+  readonly devops?: boolean;
+  readonly linear?: boolean;
+  readonly mount?: readonly string[];
+  readonly noMounts?: boolean;
+  readonly containerHome?: string;
+}
+
+export interface HostedRunIntent {
+  readonly intent_id: string;
+  readonly state: string;
+  readonly waiting_reason: string | null;
+  readonly result: Record<string, unknown> | null;
+  readonly error_code: string | null;
+  readonly [key: string]: unknown;
+}
+
+export interface HostedRunDependencies {
+  readonly settings: SettingsPort;
+  readonly environment?: NodeJS.ProcessEnv;
+  readonly fetch?: typeof globalThis.fetch;
+  readonly delay?: (milliseconds: number) => Promise<void>;
+  readonly stdout?: { write(value: string): void };
+}
+
+export interface ResolvedInput {
+  readonly repository: string;
+  readonly request: Record<string, unknown>;
+}