Function testConnectionStrict

packages/runtime/src/test-connection.ts:122–175

(
  connection: ConnectionEffectConnection,
  apiKey: string,
  model: string | undefined,
  fetchFn: ConnectionEffectFetch | undefined,
  t0: number,
  timeoutMs = CONNECTION_TEST_TIMEOUT_MS,
)

}

async function testConnectionStrict(
  connection: ConnectionEffectConnection,
  apiKey: string,
  model: string | undefined,
  fetchFn: ConnectionEffectFetch | undefined,
  t0: number,
  timeoutMs = CONNECTION_TEST_TIMEOUT_MS,
): Promise<ConnectionTestResult> {
  const defaults = PROVIDER_DEFAULTS[connection.providerType];
  // Unknown providerType → can't pick an auth path or fallback model. Return a
  // clear failure rather than crashing. Mirrors `isFakeBackend`.
  if (!defaults) {
    return { ok: false, errorMessage: `Unknown provider type "${connection.providerType}"` };
  }
  const auth = defaults.authKind;
  const secret = auth === 'none' ? '' : apiKey;
  const testModel = resolveConnectionTestModel(connection, model, defaults.fallbackModels);

  if (!testModel) {
    return { ok: false, errorMessage: 'No model to test' };
  }
  if (connection.providerType === 'opencode-free' && !model?.trim()) {
    const candidates = [
      ...new Set([...connectionEnabledModelIds(connection), ...defaults.fallbackModels]),
    ];
    let lastFailure: ConnectionTestResult | undefined;
    for (let index = 0; index < candidates.length; index += 1) {
      const candidate = candidates[index]!;
      const remainingMs = timeoutMs - (Date.now() - t0);
      if (remainingMs <= 0) {
        return connectionTestFailure(new ConnectionEffectFetchError('timeout'), t0);
      }
      const remainingCandidates = candidates.length - index;
      const attemptTimeoutMs = Math.max(1, Math.floor(remainingMs / remainingCandidates));
      try {
        const result = await testConnectionModel(
          connection,
          secret,
          candidate,
          fetchFn,
          t0,
          attemptTimeoutMs,
        );
        if (result.ok) return result;
        lastFailure = result;
      } catch (error) {
        lastFailure = connectionTestFailure(error, t0, true);
      }
    }
    return lastFailure ?? connectionTestFailure(new ConnectionEffectFetchError('timeout'), t0);
  }

  return await testConnectionModel(connection, secret, testModel, fetchFn, t0, timeoutMs);
}

async function testConnectionModel(
  connection: ConnectionEffectConnection,