@the-open-engine/zeroshot 6.35.3 → 6.37.0

package/src/agent/agent-liveness-poll.js

@@ -0,0 +1,93 @@
+const { isPlatformSupported } = require('./agent-stuck-detector');
+
+function hasRecoverableTask(agent) {
+  return (
+    Boolean(agent.currentTask) ||
+    Boolean(agent.isolation?.enabled && agent.currentTaskId) ||
+    agent.nestedExecutions?.hasActive === true
+  );
+}
+
+function handlePendingTermination(agent, settings, now, attemptTermination) {
+  if (!agent.livenessTerminationContext) return false;
+  if (now >= agent.livenessTerminationRetryAt) attemptTermination(agent, settings);
+  return true;
+}
+
+function taskTiming(agent, now) {
+  const taskStartedAt = agent.taskStartedAt || agent.lastOutputTime || now;
+  const lastOutputTime = agent.lastOutputTime || taskStartedAt;
+  return {
+    taskRuntime: now - taskStartedAt,
+    timeSinceLastOutput: now - lastOutputTime,
+    lastOutputTime,
+  };
+}
+
+function handleTaskTimeout(context, timing) {
+  const { agent, settings, configuredTimeout, beginTermination } = context;
+  if (!configuredTimeout || timing.taskRuntime < configuredTimeout) return false;
+  beginTermination(
+    agent,
+    settings,
+    `Task timed out after ${configuredTimeout}ms`,
+    'AGENT_TASK_TIMEOUT',
+    {
+      taskId: agent.currentTaskId,
+      taskRuntime: timing.taskRuntime,
+      timeout: configuredTimeout,
+    }
+  );
+  return true;
+}
+
+function publishStaleWarning(context, timing) {
+  const { agent, staleDuration, warningsBeforeKill } = context;
+  agent.consecutiveStaleWarnings += 1;
+  agent._publishLifecycle('AGENT_STALE_WARNING', {
+    taskId: agent.currentTaskId,
+    timeSinceLastOutput: timing.timeSinceLastOutput,
+    staleDuration,
+    lastOutputTime: timing.lastOutputTime,
+    consecutiveWarnings: agent.consecutiveStaleWarnings,
+    warningsBeforeKill,
+    processDiagnosticsAvailable: isPlatformSupported(),
+    analysis: `Provider produced no output for ${timing.timeSinceLastOutput}ms`,
+  });
+}
+
+function terminateForInactivity(context, timing) {
+  const { agent, settings, staleDuration, beginTermination } = context;
+  beginTermination(
+    agent,
+    settings,
+    `Provider produced no output for ${timing.timeSinceLastOutput}ms`,
+    'PROVIDER_INACTIVITY_TIMEOUT',
+    {
+      taskId: agent.currentTaskId,
+      timeSinceLastOutput: timing.timeSinceLastOutput,
+      staleDuration,
+      consecutiveWarnings: agent.consecutiveStaleWarnings,
+    }
+  );
+}
+
+function createLivenessPoll(context) {
+  const { agent, settings, staleDuration, warningsBeforeKill, attemptTermination } = context;
+  return () => {
+    if (!hasRecoverableTask(agent) || agent.livenessTerminationStarted) return;
+    const now = Date.now();
+    if (handlePendingTermination(agent, settings, now, attemptTermination)) return;
+    const timing = taskTiming(agent, now);
+    if (handleTaskTimeout(context, timing)) return;
+    if (timing.timeSinceLastOutput < staleDuration) {
+      agent.consecutiveStaleWarnings = 0;
+      return;
+    }
+    publishStaleWarning(context, timing);
+    if (agent.consecutiveStaleWarnings < warningsBeforeKill) return;
+    terminateForInactivity(context, timing);
+  };
+}
+
+module.exports = { createLivenessPoll };

package/src/agent/agent-task-executor.js

@@ -1866,6 +1866,19 @@ function finalizeLogFollow(agent, state) {
   }
 }
 
+function finishHostLogCapture(agent, state, pollLogFile, processNewContent, broadcastLine) {
+  // A task status can become terminal before the watcher has flushed its final
+  // filesystem write (observed on Modal). Stop the timers first, then take one
+  // authoritative catch-up read and finish any final UTF-8/non-newline record.
+  finalizeLogFollow(agent, state);
+  pollLogFile();
+  const decoderTail = state.logDecoder.end();
+  if (decoderTail) processNewContent(decoderTail);
+  if (state.lineBuffer.byteLength > 0) {
+    completeLogRecord(state.lineBuffer, broadcastLine, true);
+  }
+}
+
 function settleHostStatusFailure({ agent, providerName, state, resolve, text, data, error }) {
   if (state.resolved) return;
   state.resolved = true;
@@ -1986,6 +1999,7 @@ function handleStatusCompletion({
   state,
   stdout,
   pollLogFile,
+  finishLogCapture,
   resolve,
   reject,
 }) {
@@ -2012,7 +2026,7 @@ function handleStatusCompletion({
     if (state.resolved) return;
     state.resolved = true;
 
-    finalizeLogFollow(agent, state);
+    finishLogCapture();
     flushAgentOutput(agent, providerName, state);
 
     buildCompletionResult({
@@ -2066,14 +2080,12 @@ function createLogFollower({
     const state = createLogFollowState();
     state.skipStructuredResultCheck = skipStructuredResultCheck;
     state.nested = nested;
-
     state.logFilePath = lookupLogFilePath(ctPath, taskId);
     if (state.logFilePath) {
       agent._log(`📋 Agent ${agent.id}: Following ct logs for ${taskId}`);
     } else {
       agent._log(`⏳ Agent ${agent.id}: Waiting for log file...`);
     }
-
     const broadcastLine = (line) => broadcastAgentLine({ agent, providerName, state, line });
     const processNewContent = (content) => appendContentToBuffer(state, content, broadcastLine);
     const pollLogFile = () =>
@@ -2085,6 +2097,8 @@ function createLogFollower({
         state,
         onNewContent: processNewContent,
       });
+    const finishLogCapture = () =>
+      finishHostLogCapture(agent, state, pollLogFile, processNewContent, broadcastLine);
 
     state.pollInterval = setInterval(pollLogFile, 300);
 
@@ -2120,6 +2134,7 @@ function createLogFollower({
             state,
             stdout,
             pollLogFile,
+            finishLogCapture,
             resolve,
             reject,
           });
@@ -3546,6 +3561,7 @@ module.exports = {
   consumeIsolatedTailChunk,
   flushAgentOutput,
   flushIsolatedOutput,
+  finishHostLogCapture,
   CONTROL_PLANE_OUTPUT_LIMITS: Object.freeze({
     maxBytes: MAX_CONTROL_PLANE_OUTPUT_BYTES,
     maxRecords: MAX_CONTROL_PLANE_OUTPUT_RECORDS,

package/src/agent-cli-provider/adapters/omp.ts

@@ -81,7 +81,7 @@ function detectCliFeatures(helpText?: string | null, versionText?: string | null
   return {
     provider: 'omp',
     versionMatches: VERSION_TOKEN_PATTERN.test(version),
-    supportsRpcMode: /(^|\s)rpc(\s|$)/m.test(help),
+    supportsRpcMode: /(?<![A-Za-z0-9_-])rpc(?![A-Za-z0-9_-])/.test(help),
     supportsConfig: /--config\b/.test(help),
     supportsModel: /--model\b/.test(help),
     supportsThinking: /--thinking\b/.test(help),

package/src/foreground-benchmark-files.js

@@ -0,0 +1,81 @@
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { buildTelemetry } = require('./foreground-benchmark-result');
+
+function serialized(value) {
+  return Buffer.from(`${JSON.stringify(value)}\n`, 'utf8');
+}
+
+function atomicWriteNew(targetPath, content) {
+  const directory = path.dirname(targetPath);
+  const temporary = path.join(
+    directory,
+    `.${path.basename(targetPath)}.${process.pid}.${crypto.randomBytes(8).toString('hex')}.tmp`
+  );
+  let descriptor;
+  let published = false;
+  try {
+    descriptor = fs.openSync(temporary, 'wx', 0o600);
+    fs.writeFileSync(descriptor, content);
+    fs.fsyncSync(descriptor);
+    fs.closeSync(descriptor);
+    descriptor = undefined;
+    fs.linkSync(temporary, targetPath);
+    published = true;
+    fs.unlinkSync(temporary);
+    const directoryDescriptor = fs.openSync(directory, fs.constants.O_RDONLY);
+    try {
+      fs.fsyncSync(directoryDescriptor);
+    } finally {
+      fs.closeSync(directoryDescriptor);
+    }
+  } catch (error) {
+    error.atomicTargetPublished = published;
+    throw error;
+  } finally {
+    if (descriptor !== undefined) fs.closeSync(descriptor);
+    try {
+      fs.unlinkSync(temporary);
+    } catch {
+      // Preserve the primary write error; a leftover randomized temp is non-authoritative.
+    }
+  }
+}
+
+function removeOrphanTelemetry(telemetryPath, primaryError) {
+  try {
+    fs.unlinkSync(telemetryPath);
+  } catch (cleanupError) {
+    if (cleanupError.code !== 'ENOENT') primaryError.cleanupError = cleanupError;
+  }
+}
+
+function writeBenchmarkResultBundle(resultPath, result, snapshot) {
+  if (typeof resultPath !== 'string' || resultPath.length === 0) {
+    throw new Error('result path must be non-empty text');
+  }
+  const resolvedResult = path.resolve(resultPath);
+  const telemetryPath = `${resolvedResult}.telemetry.json`;
+  const telemetry = buildTelemetry(result.runId, snapshot);
+  const telemetryBytes = serialized(telemetry);
+  atomicWriteNew(telemetryPath, telemetryBytes);
+  const receipt = {
+    ...result,
+    telemetry: {
+      artifact: path.basename(telemetryPath),
+      byteLength: telemetryBytes.length,
+      sha256: crypto.createHash('sha256').update(telemetryBytes).digest('hex'),
+    },
+  };
+  try {
+    atomicWriteNew(resolvedResult, serialized(receipt));
+  } catch (error) {
+    if (!error.atomicTargetPublished) removeOrphanTelemetry(telemetryPath, error);
+    throw error;
+  }
+  return receipt;
+}
+
+module.exports = { writeBenchmarkResultBundle };

package/src/foreground-benchmark-result.js

@@ -0,0 +1,233 @@
+const crypto = require('node:crypto');
+const { VALID_PROVIDERS } = require('../lib/provider-names');
+
+const RESULT_SCHEMA = 'zeroshot-benchmark-result/v1';
+const TELEMETRY_SCHEMA = 'zeroshot-benchmark-telemetry/v1';
+const EMPTY_DIAGNOSTIC = Object.freeze({
+  byteLength: 0,
+  sha256: crypto.createHash('sha256').update('').digest('hex'),
+});
+const TASK_FAILURE_REASONS = new Set(['max_iterations', 'structured_output_invalid']);
+const PROVIDER_CODES = new Set(['crash', 'refusal']);
+const PROVIDERS = new Set(VALID_PROVIDERS);
+const PROVIDER_EVENTS = new Set(['terminal_error', 'turn.failed']);
+const PROVIDER_CATEGORIES = new Set([
+  'authentication',
+  'permanent',
+  'quota',
+  'transient',
+  'unknown',
+]);
+const PROVIDER_KINDS = new Set([
+  'permanent-pattern',
+  'rate-limit',
+  'retryable-pattern',
+  'status-permanent',
+  'status-retryable',
+  'code-retryable',
+  'unknown-retryable',
+]);
+const TOKEN_FIELDS = [
+  'inputTokens',
+  'outputTokens',
+  'cacheReadInputTokens',
+  'cacheCreationInputTokens',
+  'totalCostUsd',
+  'count',
+];
+
+function requireObject(value, label) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error(`${label} must be an object`);
+  }
+  return value;
+}
+
+function requireClosedText(value, allowed, label) {
+  if (typeof value !== 'string' || !allowed.has(value)) {
+    throw new Error(`${label} is outside the closed result contract`);
+  }
+  return value;
+}
+
+function requireDiagnostic(value) {
+  if (
+    value &&
+    Number.isSafeInteger(value.byteLength) &&
+    value.byteLength >= 0 &&
+    typeof value.sha256 === 'string' &&
+    /^[a-f0-9]{64}$/.test(value.sha256)
+  ) {
+    return { byteLength: value.byteLength, sha256: value.sha256 };
+  }
+  throw new Error('provider diagnostic is outside the closed result contract');
+}
+
+function terminalData(message) {
+  return requireObject(requireObject(message.content, 'terminal content').data, 'terminal data');
+}
+
+function isExplicitTaskFailure(message, data) {
+  if (message.sender === 'orchestrator' || !TASK_FAILURE_REASONS.has(data.reason)) return false;
+  if (data.reason === 'max_iterations') return message.receiver === 'system';
+  return message.receiver === 'broadcast' && data.code === 'STRUCTURED_OUTPUT_INVALID';
+}
+
+function classifyTerminal(message) {
+  if (message.topic === 'CLUSTER_COMPLETE') {
+    return {
+      outcome: 'completed',
+      terminalOwner: 'task',
+      code: 'ok',
+      kind: 'workflow_complete',
+      retryable: false,
+      diagnostic: { ...EMPTY_DIAGNOSTIC },
+      provider: null,
+      event: null,
+      category: null,
+    };
+  }
+
+  if (message.topic !== 'CLUSTER_FAILED') {
+    throw new Error(`unsupported terminal topic: ${message.topic}`);
+  }
+  const data = terminalData(message);
+  if (isExplicitTaskFailure(message, data)) {
+    return {
+      outcome: 'task_failure',
+      terminalOwner: 'task',
+      code: data.reason,
+      kind: 'declared_failure',
+      retryable: false,
+      diagnostic: { ...EMPTY_DIAGNOSTIC },
+      provider: null,
+      event: null,
+      category: null,
+    };
+  }
+  if (data.reason === 'provider_execution_failed') {
+    if (typeof data.retryable !== 'boolean') {
+      throw new Error('provider retryable must be boolean');
+    }
+    return {
+      outcome: 'provider_failure',
+      terminalOwner: 'provider',
+      code: requireClosedText(data.code, PROVIDER_CODES, 'provider code'),
+      kind: requireClosedText(data.kind, PROVIDER_KINDS, 'provider kind'),
+      retryable: data.retryable,
+      diagnostic: requireDiagnostic(data.diagnostic),
+      provider: requireClosedText(data.provider, PROVIDERS, 'provider'),
+      event: requireClosedText(data.event, PROVIDER_EVENTS, 'provider event'),
+      category: requireClosedText(data.category, PROVIDER_CATEGORIES, 'provider category'),
+    };
+  }
+  return {
+    outcome: 'engine_failure',
+    terminalOwner: 'engine',
+    code: 'engine_failed',
+    kind: 'declared_failure',
+    retryable: false,
+    diagnostic: { ...EMPTY_DIAGNOSTIC },
+    provider: null,
+    event: null,
+    category: null,
+  };
+}
+
+function validateStoppedAgents(agents) {
+  if (!Array.isArray(agents)) throw new Error('agents must be an array');
+  for (const agent of agents) {
+    const state = requireObject(agent, 'agent state');
+    if (state.pid !== null && state.pid !== undefined) {
+      throw new Error(`agent ${String(state.id)} still has a live process identity`);
+    }
+  }
+}
+
+function validateRunId(runId) {
+  const parts = typeof runId === 'string' ? runId.split('-') : [];
+  const valid =
+    parts.length >= 2 &&
+    parts.every(
+      (part) => part.length > 0 && [...part].every((character) => /[a-z0-9]/.test(character))
+    );
+  if (!valid) {
+    throw new Error('runId must be a canonical cluster id');
+  }
+}
+
+function buildBenchmarkResult({ runId, terminalMessages, agents }) {
+  validateRunId(runId);
+  if (!Array.isArray(terminalMessages) || terminalMessages.length !== 1) {
+    throw new Error('foreground run must have exactly one terminal event');
+  }
+  validateStoppedAgents(agents);
+  return {
+    schema: RESULT_SCHEMA,
+    runId,
+    ...classifyTerminal(terminalMessages[0]),
+  };
+}
+
+function buildCancelledResult({ runId, agents }) {
+  validateRunId(runId);
+  validateStoppedAgents(agents);
+  return {
+    schema: RESULT_SCHEMA,
+    runId,
+    outcome: 'cancelled',
+    terminalOwner: 'controller',
+    code: 'cancelled',
+    kind: 'controlled_cancellation',
+    retryable: false,
+    diagnostic: { ...EMPTY_DIAGNOSTIC },
+    provider: null,
+    event: null,
+    category: null,
+  };
+}
+
+function normalizeTokenEntry(value, label) {
+  const source = requireObject(value, label);
+  const entry = {};
+  for (const field of TOKEN_FIELDS) {
+    const amount = source[field] ?? 0;
+    if (typeof amount !== 'number' || !Number.isFinite(amount) || amount < 0) {
+      throw new Error(`${label}.${field} must be a finite non-negative number`);
+    }
+    entry[field] = amount;
+  }
+  return entry;
+}
+
+function buildTelemetry(runId, snapshot) {
+  validateRunId(runId);
+  const source = requireObject(snapshot, 'telemetry snapshot');
+  if (!Number.isSafeInteger(source.messageCount) || source.messageCount < 0) {
+    throw new Error('telemetry messageCount must be a non-negative safe integer');
+  }
+  const roles = requireObject(source.tokensByRole, 'tokensByRole');
+  const names = Object.keys(roles).sort();
+  if (names.length > 64) throw new Error('telemetry role count exceeds 64');
+  const tokensByRole = {};
+  for (const name of names) {
+    const validRoleName =
+      name === '_total' ||
+      (name.length <= 128 &&
+        /^[a-zA-Z0-9]$/.test(name[0] || '') &&
+        [...name].every((character) => /[a-zA-Z0-9_.-]/.test(character)));
+    if (!validRoleName) {
+      throw new Error('telemetry role name is invalid');
+    }
+    tokensByRole[name] = normalizeTokenEntry(roles[name], `tokensByRole.${name}`);
+  }
+  return { schema: TELEMETRY_SCHEMA, runId, messageCount: source.messageCount, tokensByRole };
+}
+
+module.exports = {
+  RESULT_SCHEMA,
+  TELEMETRY_SCHEMA,
+  buildBenchmarkResult,
+  buildCancelledResult,
+  buildTelemetry,
+};

package/src/foreground-benchmark-run.js

@@ -0,0 +1,72 @@
+const { buildBenchmarkResult, buildCancelledResult } = require('./foreground-benchmark-result');
+const { writeBenchmarkResultBundle } = require('./foreground-benchmark-files');
+
+const TERMINAL_TOPICS = ['CLUSTER_COMPLETE', 'CLUSTER_FAILED'];
+const VERIFIER_ELIGIBLE = new Set(['completed', 'task_failure']);
+const EXIT_CODES = Object.freeze({
+  provider_failure: 20,
+  engine_failure: 21,
+  cancelled: 22,
+});
+
+function isForegroundStatusSettled(status) {
+  return (
+    status &&
+    ['stopped', 'killed'].includes(status.state) &&
+    status.isZombie === false &&
+    Array.isArray(status.agents) &&
+    status.agents.every((agent) => agent && (agent.pid === null || agent.pid === undefined))
+  );
+}
+
+function terminalMessages(cluster, clusterId) {
+  const messages = TERMINAL_TOPICS.flatMap((topic) =>
+    cluster.messageBus.query({ cluster_id: clusterId, topic })
+  );
+  return messages.sort((left, right) => {
+    const a = BigInt(left.sequence);
+    const b = BigInt(right.sequence);
+    if (a < b) return -1;
+    if (a > b) return 1;
+    return 0;
+  });
+}
+
+function requireSettledStatus(orchestrator, clusterId) {
+  const status = orchestrator.getStatus(clusterId);
+  if (!isForegroundStatusSettled(status)) {
+    throw new Error(`foreground cluster is not settled: ${String(status?.state || 'unavailable')}`);
+  }
+  return status;
+}
+
+function writeForegroundResult({ orchestrator, cluster, clusterId, resultPath, cancelled }) {
+  const status = requireSettledStatus(orchestrator, clusterId);
+  const terminals = terminalMessages(cluster, clusterId);
+  let result;
+  if (cancelled && terminals.length === 0) {
+    result = buildCancelledResult({ runId: clusterId, agents: status.agents });
+  } else {
+    result = buildBenchmarkResult({
+      runId: clusterId,
+      terminalMessages: terminals,
+      agents: status.agents,
+    });
+  }
+  const snapshot = cluster.messageBus.readSnapshot(clusterId);
+  return writeBenchmarkResultBundle(resultPath, result, snapshot);
+}
+
+function exitCodeForResult(result) {
+  if (VERIFIER_ELIGIBLE.has(result.outcome)) return 0;
+  const exitCode = EXIT_CODES[result.outcome];
+  if (exitCode === undefined) throw new Error(`unsupported result outcome: ${result.outcome}`);
+  return exitCode;
+}
+
+module.exports = {
+  exitCodeForResult,
+  isForegroundStatusSettled,
+  terminalMessages,
+  writeForegroundResult,
+};

package/src/hosted-target/adapter-types.ts

@@ -12,13 +12,6 @@ import type {
   TargetAccessTokenProvider,
 } from './types.js';
 
-export type CredentialInstallCapability =
-  | { readonly supported: false }
-  | {
-      readonly supported: true;
-      readonly descriptor: NonNullable<TargetDiscoveryDescriptor['credentialInstall']>;
-    };
-
 export interface TargetAdapter {
   allocate(req: AllocateRequest, signal?: AbortSignal): Promise<Capsule>;
   list(req?: ListRequest, signal?: AbortSignal): Promise<CapsuleListPage>;
@@ -26,13 +19,6 @@ export interface TargetAdapter {
   terminate(capsuleId: string, signal?: AbortSignal): Promise<Capsule>;
   limits(signal?: AbortSignal): Promise<CapsuleLimits>;
   access(capsuleId: string, signal?: AbortSignal): Promise<CapsuleAccess>;
-  installRuntime(
-    capsuleId: string,
-    runtime: unknown,
-    accessToken: string,
-    signal?: AbortSignal
-  ): Promise<void>;
-  readonly credentialInstall: CredentialInstallCapability;
 }
 
 export interface CreateTargetAdapterOptions {

package/src/hosted-target/index.ts

@@ -2,7 +2,6 @@ export {
   createTargetAdapter,
   type TargetAdapter,
   type CreateTargetAdapterOptions,
-  type CredentialInstallCapability,
 } from './target-adapter.js';
 export {
   TargetAdapterError,

package/src/hosted-target/retry-executor.ts

@@ -2,14 +2,7 @@ import { MAX_RETRY_ELAPSED_MS } from './bounds.js';
 import { TargetAdapterError } from './errors.js';
 import type { Clock, RetryPolicy } from './types.js';
 
-export type TargetOperation =
-  | 'allocate'
-  | 'list'
-  | 'inspect'
-  | 'terminate'
-  | 'limits'
-  | 'access'
-  | 'installRuntime';
+export type TargetOperation = 'allocate' | 'list' | 'inspect' | 'terminate' | 'limits' | 'access';
 
 function throwIfAborted(signal?: AbortSignal): void {
   if (signal?.aborted) {
@@ -22,10 +15,16 @@ async function wait(delayMs: number, signal?: AbortSignal): Promise<void> {
   if (delayMs <= 0) return;
   await new Promise<void>((resolve, reject) => {
     const timer = setTimeout(resolve, delayMs);
-    signal?.addEventListener('abort', () => {
-      clearTimeout(timer);
-      reject(signal.reason ?? new globalThis.DOMException('The operation was aborted', 'AbortError'));
-    }, { once: true });
+    signal?.addEventListener(
+      'abort',
+      () => {
+        clearTimeout(timer);
+        reject(
+          signal.reason ?? new globalThis.DOMException('The operation was aborted', 'AbortError')
+        );
+      },
+      { once: true }
+    );
   });
 }
 
@@ -41,12 +40,11 @@ function validRetryDelay(retry: boolean, delayMs: number, remaining: number): bo
   return retry && Number.isFinite(delayMs) && delayMs >= 0 && delayMs < remaining;
 }
 
-
 export async function withTargetRetry<T>(
   operation: TargetOperation,
   effect: () => Promise<T>,
   signal: AbortSignal | undefined,
-  context: RetryContext,
+  context: RetryContext
 ): Promise<T> {
   const retrySafe = operation !== 'access';
   const started = context.clock.now();

package/src/hosted-target/target-adapter.ts

@@ -1,10 +1,6 @@
 import { ZeroCloudV1TargetAdapter } from './zero-cloud-v1-adapter.js';
 import type { CreateTargetAdapterOptions, TargetAdapter } from './adapter-types.js';
-export type {
-  CreateTargetAdapterOptions,
-  CredentialInstallCapability,
-  TargetAdapter,
-} from './adapter-types.js';
+export type { CreateTargetAdapterOptions, TargetAdapter } from './adapter-types.js';
 
 export function createTargetAdapter(options: CreateTargetAdapterOptions): TargetAdapter {
   if (options.descriptor.adapter.majorVersion !== 1) {